/* 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";
       sha256 = "42df8b886598bdfbb10f67d718eae41fb9866618dd8852e97549d915cb26379f";
       libraryHaskellDepends = [ AbortT-transformers base mtl ];
       jailbreak = true;
       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.1";
       sha256 = "773dc6aefb5b50937032a5c02d0ccd8320218f6d361361400882e694af600303";
       libraryHaskellDepends = [ base transformers ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       jailbreak = true;
       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";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       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 ];
       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";
       sha256 = "21be5fddcfe8e1970c94872f36d5f29d07709f69e8e139b68bf6b27e75677f34";
       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" = 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 ];
       homepage = "http://byorgey.wordpress.com/blogliterately/";
       description = "A tool for posting Haskelly articles to blogs";
       license = "GPL";
     }) {};

  "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-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" = 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 ];
       description = "Include images in blog posts with inline diagrams code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "BlogLiterately-diagrams_0_2_0_2" = 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 ];
       jailbreak = true;
       description = "Include images in blog posts with inline diagrams code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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 ];
       jailbreak = true;
       homepage = "http://www.cse.chalmers.se/~emax/bookshelf/Manual.shelf.html";
       description = "A simple document organizer with some wiki functionality";
       license = "GPL";
     }) {};

  "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_6" = 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.6";
       sha256 = "9cfa9df3472d3b96797d9835040c87a2450c866bb090d5f13dfe63bb9033d696";
       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_3" = 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.3";
       sha256 = "1ba06ef194db0decdd1994c83cded718699a7da3068d73ff94e4ccbd39eb016f";
       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-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;
     }) {};

  "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" = 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;
     }) {};

  "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 ];
       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 = "1";
       editedCabalFile = "2c662e0220aec5059849ac19f5ce4ad63330a4d8475332e59ad28204328cbbce";
       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";
       sha256 = "ccdf7a5c47baad82c9a9bdcaa848ec36de4818a9cd5ac063e2e1046ca6cfcc4a";
       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, base, bytestring, case-insensitive
     , containers, hashable, haskeline, mtl, network, old-locale, parsec
     , pcre, pipes, pipes-bytestring, pipes-concurrency, pipes-network
     , pureMD5, random, stm, stm-chans, text, time, transformers, unix
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "EtaMOO";
       version = "0.2.0.0";
       sha256 = "365169b4fa2eb1ff2422eedfdb32c0053b8c77cc6c605310c876b46f1ac1f86c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring case-insensitive containers hashable
         haskeline mtl network old-locale parsec pipes pipes-bytestring
         pipes-concurrency pipes-network pureMD5 random stm stm-chans text
         time transformers unix unordered-containers vector
       ];
       executableSystemDepends = [ 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" = 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;
     }) {};

  "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";
       libraryHaskellDepends = [ base OpenGLRaw ];
       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 = 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";
       libraryHaskellDepends = [ base OpenGLRaw ];
       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 = 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" = 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;
     }) {};

  "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 ];
       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, gtk3, process, temporary }:
     mkDerivation {
       pname = "Gifcurry";
       version = "0.1.0.0";
       sha256 = "b2b6eadd35889f996931887b21c85a9dbd397f988567981479266752e21537bf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gtk3 process temporary ];
       homepage = "https://github.com/lettier/gifcurry";
       description = "Create animated GIFs, overlaid with optional text, from movies";
       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, pandoc, process, random, text, time
     }:
     mkDerivation {
       pname = "Graphalyze";
       version = "0.14.1.1";
       sha256 = "9792207d74f5aff52b3e5b83378db480702b8b5e1b13e65113e2f32e7687ce9f";
       libraryHaskellDepends = [
         array base bktrees containers directory fgl filepath graphviz
         pandoc process random text time
       ];
       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-rc, text, vector
     }:
     mkDerivation {
       pname = "H";
       version = "0.7.0.0";
       sha256 = "52ee637c754b8629f209e5b15c7b19437cd7039f660f7bc32e5a83c548b8100e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs file-embed inline-r pretty process
         temporary-rc vector
       ];
       testHaskellDepends = [
         base bytestring directory inline-r process singletons tasty
         tasty-golden tasty-hunit text vector
       ];
       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;
     }) {};

  "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" = 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";
       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" = 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;
     }) {};

  "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
       ];
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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, containers, directory, filepath
     , FPretty, libgraph, mtl, process, RBTree, regex-posix
     , template-haskell, threepenny-gui
     }:
     mkDerivation {
       pname = "Hoed";
       version = "0.3.4";
       sha256 = "c82359deccc4de43e1e5215f2c28f2fc659e701d9e18bad70f9f5c54853e5f90";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base 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";
       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.6";
       sha256 = "19515ecd8501ae038f060a3b10d391c865d07391d240b1819a55a165340e35c2";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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";
     }) {};

  "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;
     }) {};

  "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
       ];
       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";
       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.3";
       sha256 = "2afdb1f3972f93619b236835680616bbfcd435ee52e097afad04a53f38c4c769";
       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, mmorph, monad-loops
     , monad-products, mtl, parallel, random, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "MonadCompose";
       version = "0.8.3.1";
       sha256 = "aa5bc8d00caea4fb9bce70e3a98bb7618bf567a1b0f383601a6330cec45f5b5a";
       libraryHaskellDepends = [
         base data-default ghc-prim mmorph monad-loops monad-products mtl
         parallel random transformers transformers-compat
       ];
       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
       ];
       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
       ];
       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
       ];
       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.2.0.1";
       sha256 = "2d0160f8f5cb58c93df9fcb93130fdfb946c7c978f527c935f26380d92047c14";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       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;
     }) {};

  "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;
     }) {};

  "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, cairo, Chart, Chart-cairo, containers
     , data-default-class, generic-accessors, glib, gtk, lens, text
     , time, vector
     }:
     mkDerivation {
       pname = "Plot-ho-matic";
       version = "0.8.0.0";
       sha256 = "2c2e2d1f793140df25afdd73965b42f3010b5060030c564cc7afcff9f3c711a2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo Chart Chart-cairo containers data-default-class
         generic-accessors glib gtk lens text time 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" = 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
       ];
       homepage = "https://github.com/nick8325/quickcheck";
       description = "Automatic testing of Haskell programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "QuickCheck_2_8_2" = 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
       ];
       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-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;
     }) {};

  "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 ];
       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
     }:
     mkDerivation {
       pname = "RFC1751";
       version = "0.3.0.1";
       sha256 = "6a6686ca05bcbf4fc24786b2cb7f33003b7b53705e2e631b7187fff20165878c";
       libraryHaskellDepends = [ base binary bytestring ];
       testHaskellDepends = [
         base binary bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       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" = 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;
     }) {};

  "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;
     }) {};

  "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 = "2";
       editedCabalFile = "87da94054ca27c85fc15cf5408bc1afb0354b9ed016348faf005ad44ae0917a2";
       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" = 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";
     }) {};

  "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
       ];
       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.1";
       sha256 = "6b3242a5ddba181659f9b8eb4786dfa929751aaf48a62b070040043a3e8e0613";
       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.0.0";
       sha256 = "c2bdbdd971e28ed4abb321280c3d77965ed425a848b3ef08ac66a6233c5d5328";
       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 = "1";
       editedCabalFile = "651b27c1cd2730cd0234cc1fb5860dd74728e5ecc6682b2a5e857fd42d41fe22";
       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;
     }) {};

  "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-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" = 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;
     }) {};

  "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 = "1";
       editedCabalFile = "c80517bdbd55afcbb06a535060f6be97e5619314ed1545181136f140544d4120";
       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
       ];
       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";
       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-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";
       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
       ];
       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
     , 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 = "1";
       editedCabalFile = "a6142a2f67fa6c7363339934a13aa920c1b20c5fcd9312932617470fba9b0328";
       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
       ];
       homepage = "https://github.com/phadej/aeson-extra#readme";
       description = "Extra goodies for aeson";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "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 ];
       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 = "1";
       editedCabalFile = "effc944d02b274ca2688671ac16fe1a8c87b6d036b0ba11d06dd404da47a8634";
       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.1";
       sha256 = "933a2111c21cc0f6e9869d6c4927b8201882a03c01de693e68d821f5d4484d49";
       libraryHaskellDepends = [
         aeson base-prelude mtl-prelude scientific success text
         unordered-containers vector
       ];
       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;
     }) {};

  "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, xhtml }:
     mkDerivation {
       pname = "agda-snippets";
       version = "2.4.2.4";
       sha256 = "c1bba563fe1c2ecceaa21545565ad2678675682ed97518c2c2bebde8692963c0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         Agda base containers mtl network-uri xhtml
       ];
       executableHaskellDepends = [ Agda base network-uri ];
       jailbreak = true;
       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
       ];
       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.1";
       sha256 = "bff0ea9f344eef7f90e54613e261c8b45e39b428e580eb56d3eab6f0c20b2584";
       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-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 = "3.0";
       sha256 = "3f34e384aacd8f463f2721209910bcde25e111f96e1c3a727fe19571d49f30ad";
       libraryHaskellDepends = [
         aivika array base containers mtl random vector
       ];
       homepage = "http://github.com/dsorokin/aivika-transformers";
       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.3";
       sha256 = "da7dc11ff1b703d1334d13705097ceddd7dd5c88c335486d3b1d34d84f880067";
       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.5";
       sha256 = "1238b1788228af07a15a76ab3768202d491aa1f7feef009355ff7109a91584d2";
       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 = "1";
       editedCabalFile = "982094590ae1e54131d4b1285eaec6d4160717a2864858f90a3511522fc591d6";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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";
     }) {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";
       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;
     }) {};

  "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" = 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
       ];
       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" = 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;
     }) {};

  "async_2_1_0" = 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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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.0";
       sha256 = "f4c2c8e42c64eae90b4daf9f0cb4432701129ed782490283278613986cddc69b";
       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";
     }) {};

  "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" = 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-api" = 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;
     }) {};

  "avers-server" = 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;
     }) {};

  "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;
     }) {};

  "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" = 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;
     }) {};

  "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_1_0" = callPackage
    ({ mkDerivation, ghc-prim, rts }:
     mkDerivation {
       pname = "base";
       version = "4.8.1.0";
       sha256 = "52c9afdc4fe1f59e67bfbe266edad57ee4294eae59bfd287fcd66e5808519e67";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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
       ];
       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";
       sha256 = "46e173dac5863a7b8404b44ab1ead2de94e743d24a2de571ff086cfb8748de14";
       libraryHaskellDepends = [
         base comonad containers semigroups tagged template-haskell
         transformers
       ];
       testHaskellDepends = [
         base hspec QuickCheck transformers transformers-compat
       ];
       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_0_0" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, HUnit, QuickCheck, random, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "binary";
       version = "0.8.0.0";
       sha256 = "a446ed06e0b3011716b09d129f25c8bab9bda60a5783bab1e778e7ffa30c7d8f";
       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
       ];
       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.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
       ];
       homepage = "https://github.com/phadej/binary-orphans#readme";
       description = "Orphan instances for binary";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-parser" = 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
       ];
       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
       ];
       description = "Binary and exponential searches";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {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;
     }) {};

  "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";
       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, directory, HaTeX, process, split
     , tagsoup, text
     }:
     mkDerivation {
       pname = "blatex";
       version = "0.1.0.4";
       sha256 = "cbf1adfa07407c66a1dc071fca663a709e2b7cd7787f07a82276b6c58451f236";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html 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" = 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;
     }) {};

  "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;
     }) {};

  "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;
     }) {};

  "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" = 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;};

  "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";
       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, deepseq, QuickCheck }:
     mkDerivation {
       pname = "bytestring-short";
       version = "0.0.1.0";
       sha256 = "9b23a18121366a02fcc49a6c63a453500f475a302eab6e5e255e27c2e1308c0c";
       libraryHaskellDepends = [ base bytestring deepseq ];
       testHaskellDepends = [ base bytestring QuickCheck ];
       jailbreak = true;
       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, tasty, tasty-hunit, tasty-quickcheck
     , tasty-smallcheck
     }:
     mkDerivation {
       pname = "bytestring-tree-builder";
       version = "0.2.2.1";
       sha256 = "7c63bedde6d0179d0c595fa14d0bfe46625e6fc089eb82675fe463ffa015286d";
       libraryHaskellDepends = [ base base-prelude bytestring ];
       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.15";
       sha256 = "8925fa275d5aec64ec2627e57e131a9f8bc7a9060e4693a0507bf569af4f5f3c";
       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-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" = 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";
       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" = 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;
     }) {};

  "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, attoparsec, base, bytestring, msgpack, mtl
     , template-haskell
     }:
     mkDerivation {
       pname = "call-haskell-from-anything";
       version = "0.1.0.2";
       sha256 = "a14b0b6bb050f7119337fae4136bbe45f12c55ce94659e088d340d7ffd245b41";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring msgpack mtl template-haskell
       ];
       executableHaskellDepends = [ base bytestring msgpack mtl ];
       jailbreak = true;
       homepage = "https://github.com/nh2/call-haskell-from-anything";
       description = "Python-to-Haskell function calls";
       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" = 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;
     }) {};

  "casadi-bindings" = callPackage
    ({ mkDerivation, base, binary, casadi, casadi-bindings-core
     , casadi-bindings-internal, cereal, containers, doctest, linear
     , vector, vector-binary-instances
     }:
     mkDerivation {
       pname = "casadi-bindings";
       version = "2.4.1.6";
       sha256 = "cc4e7f894581bf7847733dbffc0c2692c41235822e91459052ffd3b483319a48";
       libraryHaskellDepends = [
         base binary casadi-bindings-core casadi-bindings-internal cereal
         containers linear 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";
       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" = 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;
     }) {};

  "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
     }:
     mkDerivation {
       pname = "cassava-conduit";
       version = "0.2.1";
       sha256 = "3b75c027d9be6637b5ce550960995eedb4b9e3f7c8acdecdae36c350ba600c55";
       libraryHaskellDepends = [
         array base bifunctors bytestring cassava conduit conduit-extra
         containers mtl
       ];
       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.1.1.0";
       sha256 = "87ce8074aae24c510bde7d5d96068903e0056481f5316424e605a05425216121";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cassava io-streams vector
       ];
       testHaskellDepends = [
         base bytestring cassava io-streams QuickCheck tasty
         tasty-quickcheck vector
       ];
       jailbreak = true;
       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.5.13";
       sha256 = "03bc20b6879b379b1e22f1e09214d1519b7c7f5b82d7c79de3fd52200ba5550a";
       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" = 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;
     }) {};

  "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
       ];
       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
       ];
       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
       ];
       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
       ];
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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, containers }:
     mkDerivation {
       pname = "cli";
       version = "0.0.5";
       sha256 = "2d514d8c7b17566c4cd5b9ae8f50dfad4af81fa5a81f547becb5b20faed714b2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/NicolasDP/hs-cli";
       description = "Simple Command Line Interface Library";
       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;
     }) {};

  "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" = 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;
     }) {};

  "cmark_0_5_0" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, text }:
     mkDerivation {
       pname = "cmark";
       version = "0.5.0";
       sha256 = "a95dd6c5135159d0d1b797eb99bbad757a298f4a8fb580865323bff37cba2cb8";
       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;
     }) {};

  "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" = 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;
     }) {};

  "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, exceptions, mtl, semigroupoids
     , transformers, void
     }:
     mkDerivation {
       pname = "conceit";
       version = "0.3.2.0";
       sha256 = "2f3753f391c011eb71f39cf89c212e8c265612eaf43d51bd09bb58691b48f29a";
       libraryHaskellDepends = [
         base bifunctors exceptions mtl semigroupoids transformers void
       ];
       description = "Concurrent actions that may fail";
       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
       ];
       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.0";
       sha256 = "85c6050bc86f0a421e39ca6c7a9ac71fa2601d6b8be7792ac57d43fdddd95e4c";
       libraryHaskellDepends = [
         async base containers lifted-async machines monad-control
         semigroups time transformers transformers-base
       ];
       testHaskellDepends = [
         base machines tasty tasty-hunit time transformers
       ];
       jailbreak = true;
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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";
       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.0.8";
       sha256 = "7f56ae97d2d614c26b634ccbd1951b0c958eca20b20401d210027e2f1627cd9b";
       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.0.3";
       sha256 = "89faaa72131c56397b3603ac67d577b4cf7fc5607fc4369f3e0255b403d1fe88";
       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 = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "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.1";
       sha256 = "ba38eafffb5f9336e80d52435feb43cfa4186e6cc439e4c4499b7d5297a49432";
       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" = 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
       ];
       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 ];
       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 ];
       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
       ];
       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";
       sha256 = "40404a86c7dbe1766fe9fbbc0289b79c132aeff38946e177f49a0ffc7ff3c1f5";
       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, bytestring, cereal, containers, either, lens
     , mtl, safecopy, transformers, transformers-free, uuid
     }:
     mkDerivation {
       pname = "coroutine-object";
       version = "0.3";
       sha256 = "394cb02b87c8b53b4a89a1652954c0c215d302ae1ec0ae66acbcdf7818db1960";
       libraryHaskellDepends = [
         base bytestring cereal containers either lens mtl safecopy
         transformers transformers-free uuid
       ];
       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" = 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;
     }) {};

  "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.3";
       sha256 = "2ea9ea4f529fb99fde5d47814cf0ccf0450c70e03bbfb8275ce30a51f9f72830";
       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
       ];
       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.4";
       sha256 = "5d66f4f51b8600cdc48a3d4b999322ec8efa0f26fd8a41b4bb125412e3dea009";
       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" = 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;
     }) {};

  "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" = 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.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-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-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.0";
       sha256 = "8a0e678fabcadbe0aaec1058e4cc7d4632633646c30bc6851c6835db37d19169";
       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-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-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-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-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" = 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;
     }) {};

  "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-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, data-construction, lens }:
     mkDerivation {
       pname = "data-layer";
       version = "1.0.3";
       sha256 = "c8a19fd9c87b755957dfa092620e9c26395da12a1dfb2b06ba2fcc8df5438327";
       libraryHaskellDepends = [ base 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-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" = 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;
     }) {};

  "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-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" = 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;
     }) {};

  "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
       ];
       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.5";
       sha256 = "e898afe6cb88fb8caf9555b700a22021e84783d2cbe825d16cbb8cee461fae8c";
       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";
       sha256 = "baa2cb35066e37e8bb5ad831aa222b3b5fd8388a62cfc42903ebcb611a20c34d";
       libraryHaskellDepends = [
         base cairo diagrams-cairo diagrams-lib gtk
       ];
       jailbreak = true;
       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
       ];
       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, 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
       ];
       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
       ];
       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-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" = 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;
     }) {};

  "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-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" = 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;
     }) {};

  "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" = 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
       ];
       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_0" = callPackage
    ({ mkDerivation, base, filepath, time, unix }:
     mkDerivation {
       pname = "directory";
       version = "1.2.5.0";
       sha256 = "ac9d7fdd402c3281fab7ffad004229671f0ecfb7ddd70fd58b90b0a48c1ddef7";
       revision = "1";
       editedCabalFile = "1ae6631d1a4234329263792b1809c156f9f85a05753379e69fd6b2e93c61c6a0";
       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.4";
       sha256 = "98d53b95733cf40e4a59461c41cdec7f45f3b5810deacef8d7cdde1ea60f91b5";
       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.1.0.0";
       sha256 = "7c49a85015f428e55af318214de93ce8ab9257e627ad6ef8592b781324aac52e";
       libraryHaskellDepends = [
         base binary bytestring constraints template-haskell
       ];
       testHaskellDepends = [ base binary hspec QuickCheck ];
       jailbreak = true;
       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" = 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;
     }) {};

  "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.2";
       sha256 = "b1bfc3ee24be9c2ab1d45563f4d4bd46a05f61a8af4fe5c1ffeb4925bbc50feb";
       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.1";
       sha256 = "3659dcf407af66485cc01294af61655aef48fd6758191788596b1461eed41438";
       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
       ];
       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.1";
       sha256 = "2e450d510586384d325479d008a64254ad5c9883f8af6bfd99e7edc9ae26a68e";
       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
       ];
       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.1";
       sha256 = "32213a9077c0fc3b835b7b94d7d5e04262208e2ce0192675af8b5bf9efe8f911";
       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
       ];
       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.1.0.0";
       sha256 = "638112333b5bc20117396d673d46cc3786719fd545a7a76f9fb80957ee1a5a4e";
       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
       ];
       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
       ];
       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.1";
       sha256 = "9571f9870fb0591a09b8260e4b8b096547bf253a502a4a9347c9c30f19788931";
       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.1";
       sha256 = "0efd9566945f5927eff128d928baa094720ef29ceec213fd3799e36ae3bcf1b5";
       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.1";
       sha256 = "2e404f040d1a835b6dd77b4888b5d884f45dfda309dcdc04fcaa6988bf1a4786";
       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
       ];
       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.1";
       sha256 = "f8dc728ba039c85feae5fd795d22d51aa2c1b7031ad99a772facccad22ae5619";
       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
       ];
       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-tcp, random, rematch, stm
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "distributed-process-tests";
       version = "0.4.3.2";
       sha256 = "ee44041cdfca0712f45b279534ee646eb4a51a70f91a26484dd234d1b0ef4251";
       libraryHaskellDepends = [
         ansi-terminal base binary bytestring distributed-process
         distributed-static HUnit network network-transport random rematch
         stm test-framework test-framework-hunit
       ];
       testHaskellDepends = [
         base network network-transport network-transport-tcp test-framework
       ];
       jailbreak = true;
       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" = 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;
     }) {};

  "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.4";
       sha256 = "d4e99071e0c2f5b7922dad5a85c02abbbeed27f71e72d091f8a3a00ae8f97418";
       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.3";
       sha256 = "d6c2430d273d817947cfc87bdd120e5837a32f564b174f4ba13e53879454c227";
       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.6";
       sha256 = "a39510efe8256937ab06284be91c810d429205636b8150c9aaea11e7c340f3e5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory doctest filepath
       ];
       executableHaskellDepends = [
         aeson base bytestring directory doctest filepath
       ];
       testHaskellDepends = [ base doctest ];
       doHaddock = false;
       jailbreak = true;
       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";
       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;
     }) {};

  "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" = 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;
     }) {};

  "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" = callPackage
    ({ mkDerivation, base, binary, bytestring, hashable
     , unordered-containers
     }:
     mkDerivation {
       pname = "dynamic-state";
       version = "0.2.0.0";
       sha256 = "53a09c16380012b35079a7d41fca332fc94b55a0b0c929937af94cc9cad5e0b6";
       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";
       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";
       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";
       sha256 = "260b064cf097cbea4a3c83deef975aade9ef6a3a037b9e8119324938caaeedf4";
       libraryHaskellDepends = [ base bytestring crypto-api ];
       jailbreak = true;
       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";
       libraryHaskellDepends = [ base ghc-prim type-level-sets ];
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "elm-bridge" = 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;
     }) {};

  "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-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.1.1";
       sha256 = "6e5d8b45552e4629040efa8026d8c756db4e105a25a2f71e6d61a484b4f6e2aa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base base-unicode-symbols bytestring containers
         directory file-embed filepath process text time
       ];
       jailbreak = true;
       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
       ];
       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.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
       ];
       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";
       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";
       libraryHaskellDepends = [ base unix ];
       homepage = "http://github.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";
       sha256 = "90c5c2081472ec2fdf7d7b1ac3d89169479590af7679a071a05dd7cbf6a14250";
       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
       ];
       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.1";
       sha256 = "28002b14fd33135870ed8fad398aeef3c43f1cfb2501ad2e4d9d72f0a3bf19d3";
       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";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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.2";
       sha256 = "eb630b4a2cd295863a8d9f3f21904e012504cd4ebdb44453dea6a69dc7216cdb";
       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
     , network, stm, suspend, text, timers, websockets
     }:
     mkDerivation {
       pname = "eventloop";
       version = "0.6.0.0";
       sha256 = "2ec1e143de18418e3c031df78965b27710fd6195c19d348f959393d0ea054d6c";
       libraryHaskellDepends = [
         aeson base bytestring concurrent-utilities 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" = 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" ];
     }) {};

  "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" = 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;
     }) {};

  "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
       ];
       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;
     }) {};

  "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.0";
       sha256 = "e9d240fb2401da90539d48cce0eb29925290845dc591ab2e1d1609ec9fe9c891";
       libraryHaskellDepends = [
         base transformers transformers-base type-aligned void
       ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th void
       ];
       jailbreak = true;
       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 ];
       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" = 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;
     }) {};

  "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";
       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" = 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;
     }) {};

  "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.0";
       sha256 = "107701b470b86ef66be17fc76393995ad59e2912aa399bb4212bf63023152559";
       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;
     }) {};

  "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" = 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;
     }) {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.2";
       sha256 = "85ae076585fa58f4ec546287e74e8327e599c1ff686d15839294138e2f02dc35";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/strake/filtrable.hs";
       description = "Class of filtrable containers";
       license = "unknown";
     }) {};

  "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-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;
     }) {};

  "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, process
     }:
     mkDerivation {
       pname = "fltkhs";
       version = "0.4.0.0";
       sha256 = "7e975cca6e57dc947abdc776a90fb94cee9f30fc8a0f395570c9665d23e53644";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [
         base bytestring directory filepath mtl parsec process
       ];
       homepage = "http://github.com/deech/fltkhs";
       description = "FLTK bindings";
       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";
       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";
       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";
       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";
       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";
       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";
       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";
       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.4";
       sha256 = "6d6473970896924a7de1c4dd5777b9b094c28ac1a33f6c8b774c0bb82d936943";
       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_1_1_5" = 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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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.4.7.0";
       sha256 = "8836b026467a5940be86015d34f2dfca7f0b1787fd608d1bad81a8bd25cbc8e9";
       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.1.0.1";
       sha256 = "380616c9d8ef4997ad6793ae3ac9ddd699091cefabcfcff4c981279543bdb677";
       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, extensible-exceptions, hashtables
     , parsec, process, regex-compat, unix
     }:
     mkDerivation {
       pname = "fquery";
       version = "0.2.1.5";
       sha256 = "f124de95a18d2e177ed1fae3493ad093c8c365d513c0cc958227fc59f2ca38ec";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory extensible-exceptions 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 }:
     mkDerivation {
       pname = "free-vl";
       version = "0.1.3";
       sha256 = "866cb0695f3dca802dbef507246f7833cd5167c46da42abfba88000a1a8d8837";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       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, base, bytestring, curl, data-accessor
     , data-accessor-template, directory, mtl, xml
     }:
     mkDerivation {
       pname = "freesound";
       version = "0.1.0";
       sha256 = "9ebdb823d8bf3979cfc1904a31b167f51d01ad481f8fec702983492d0cc36428";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring curl data-accessor data-accessor-template directory
         mtl xml
       ];
       homepage = "http://code.haskell.org/~StefanKersten/code/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;
     }) {};

  "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;
     }) {};

  "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, clock
     , containers, data-default-class, feed, feed-collect
     , funbot-ext-events, HTTP, http-client, http-client-tls
     , http-listen, irc-fun-bot, irc-fun-color, 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.4.0.1";
       sha256 = "444da7bc772b17de0aa329292dbe1a3ad3134990f824d6f88d6355ff28c3537e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson auto-update base bytestring clock containers
         data-default-class feed feed-collect funbot-ext-events HTTP
         http-client http-client-tls http-listen irc-fun-bot irc-fun-color
         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.2.0.0";
       sha256 = "5224fee263e625708cc937356cdb5dfcf55f0cfd26bf61a8fcb9b2392aa37e26";
       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 ];
     }) {};

  "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 }:
     mkDerivation {
       pname = "functor-utils";
       version = "1.0";
       sha256 = "b7c38d1051bfaaebc564df205757bbc8d418e8b350fee711c51c44e5c7ebd4f6";
       libraryHaskellDepends = [ base ];
       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;
     }) {};

  "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, HUnit, lens, linear, QuickCheck
     , spatial-math, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "generic-accessors";
       version = "0.5.1.0";
       sha256 = "547a5b0ba3fac1e2d5f7de7f7248aef2b128b24714f4c0908b5191ebe5d39442";
       libraryHaskellDepends = [ base 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 = "3";
       editedCabalFile = "c360aa4138bfd4325a48f77b2bbebf11117bb8325b76e03d194c971d4f3446d4";
       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" = 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;
     }) {};

  "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";
       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, mockery, QuickCheck, shake
     }:
     mkDerivation {
       pname = "generics-eot";
       version = "0.1";
       sha256 = "f293d60d5c2a4aa3065f23e022fd74cf27d8f255e6e9cd44d75d7a44f3f2ab1a";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory doctest filepath hspec interpolate 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-eot_0_2" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, hspec
     , interpolate, mockery, QuickCheck, shake
     }:
     mkDerivation {
       pname = "generics-eot";
       version = "0.2";
       sha256 = "732db9692db812b178a7d0bf4b89321c4630722bfe719966023cc9d7fc00820f";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory doctest filepath hspec interpolate 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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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" = 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;
     }) {};

  "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.1.0.4";
       sha256 = "9167b8822b2aa59f24d12f3baa9c5c4f16e04e1c85f3d35af388922a17f51ec0";
       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, mtl
     , optparse-applicative, parsec, process, safe, syb, transformers
     }:
     mkDerivation {
       pname = "ghc-imported-from";
       version = "0.2.1.0";
       sha256 = "2c0af9dbfd887e0f32abd2ffa99acf5ce1344da18402e337eb4a39b59488982c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory filepath ghc ghc-mod ghc-paths
         ghc-syb-utils mtl optparse-applicative parsec process safe syb
         transformers
       ];
       executableHaskellDepends = [
         base Cabal containers directory filepath ghc ghc-mod ghc-paths
         ghc-syb-utils hspec mtl optparse-applicative parsec process safe
         syb transformers
       ];
       testHaskellDepends = [
         base Cabal containers directory filepath ghc ghc-mod ghc-paths
         ghc-syb-utils hspec 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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "ghc-vis" = callPackage
    ({ mkDerivation, base, cairo, containers, deepseq, fgl
     , ghc-heap-view, graphviz, gtk, mtl, svgcairo, text, transformers
     , xdot
     }:
     mkDerivation {
       pname = "ghc-vis";
       version = "0.7.2.9";
       sha256 = "e0ea3da85c0e32b446f682114de92df548fc230c24a33683c339f110632043ae";
       libraryHaskellDepends = [
         base cairo containers deepseq fgl ghc-heap-view graphviz gtk 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 = "1";
       editedCabalFile = "257b623b74af9d15e3b9539156fe411d3b13fb8da9fe6c6d8f84c1f7645d114f";
       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.10";
       sha256 = "e56f898c789959b310bd1fcdf9065155751c56ab5065fbf3adbac31ed542f14d";
       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.11";
       sha256 = "d5662b5f971eb756b57c6cf3699b40ee7489a91cf64ad73074514e2f7a1329b9";
       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.10";
       sha256 = "54c7eeb7d06fe03079aade5c415bb64753269add6195348c35c7dcdcb6ef018e";
       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.10";
       sha256 = "b174113ae61ede2035eaf67380edbd6a93270a6c5c9ac3dbc2633b102eca6d29";
       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.10";
       sha256 = "c37256afbbbf492c43ceef81c1fcb3be12ae165316a7576cb4054d10ccdeb6a0";
       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-glib" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib
     , haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-glib";
       version = "0.2.46.10";
       sha256 = "4a36df320fce4e7543cb9bd8ffb50a94c3b0a1ef738c69a376080312612ed7f7";
       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.10";
       sha256 = "0378e905abf11d90d13eb3bb645a2877d8f0885e158bb98758ba5a77a041c2bc";
       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.10";
       sha256 = "ad4879b4a216722ac53dc7f71afa64e338e65440a9fecf3179f3f6d431b81458";
       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.10";
       sha256 = "9bea9cfb0554d92c4320e04be53100cea142baec034be29306a80ce7037e9cb7";
       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.10";
       sha256 = "c338d32b953fdf73ffb41b959c7c7b2834c40b29f644da77c0c67f9c53aa8f50";
       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.10";
       sha256 = "05b759c4ecd61dfbd16d62e91541905aecd00b84761931911a88b484630cd6cd";
       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-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.10";
       sha256 = "7b680363b582d69a12d4c7da469530b821db2905bcad0c968f668b32edd663de";
       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.10";
       sha256 = "7ac367fb334d70eb852631ad12458682528c0080bd9592fd97377e8c865179ed";
       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.11";
       sha256 = "021835a251b1e9ddd2bf2910e0d3c17b4d6b940e9376a7000429f86a925a4013";
       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.10";
       sha256 = "03c8a0ba73dd1d1b942dd87d57560a8e7a50ec6684a32b07423aaf731feb9075";
       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;};

  "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
     , mtl, parsec, safe, scientific, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "ginger";
       version = "0.1.0.0";
       sha256 = "9b8f513b92c8e4ae179c75fe7f4fb675cf870dc53d3a02df51b5ec9336a39331";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring data-default filepath mtl parsec safe
         scientific text transformers unordered-containers 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" = 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;
     }) {};

  "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" = 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;
       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.0";
       sha256 = "b186502251e38f439a907eb54284ebb453b63003d91ec83c0c3b455f0da48568";
       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" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , byteable, bytestring, case-insensitive, conduit, containers
     , cryptohash, data-default, failure, hashable, hspec, HTTP
     , http-conduit, http-types, network, old-locale, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "github";
       version = "0.13.2";
       sha256 = "ffa08979a92ad3065982ede7e461939540ebe1a856baa15052b1ab3f219707c4";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring byteable bytestring
         case-insensitive conduit containers cryptohash data-default failure
         hashable HTTP http-conduit http-types network old-locale text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base16-bytestring byteable bytestring
         case-insensitive conduit containers cryptohash data-default failure
         hashable hspec HTTP http-conduit http-types network old-locale text
         time unordered-containers vector
       ];
       homepage = "https://github.com/jwiegley/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.20150807";
       sha256 = "52236cba75a6e9c2a71c77e62839d22d5a672bb3e4bf4bb61d32c3c64d38a8a7";
       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 ];
       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.0.1";
       sha256 = "552996f2624ed08cd21a73303d666292f08a1294416d2811f9d57293c9e89506";
       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
       ];
       jailbreak = true;
       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
     }:
     mkDerivation {
       pname = "gnss-converters";
       version = "0.1.2";
       sha256 = "8e43f583e7562c086bb8de1a88ef5b5e6bdca72a3ea4645e6d9f486861d07f0c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base basic-prelude conduit-extra lens rtcm sbp
       ];
       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";
       sha256 = "b05ac987c0abcac76edee80144090ae018b246f78155da2c6a5ecef8ee7da6e7";
       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;
     }) {};

  "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" = 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
       ];
       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, fgl, hspec
     , hspec-expectations, multiset, mwc-random, QuickCheck
     }:
     mkDerivation {
       pname = "graph-generators";
       version = "0.1.2.0";
       sha256 = "3ae508177ce01f86cfcc091421294a1a0736a56f9f8a34cd07cc67486b168247";
       libraryHaskellDepends = [
         base containers fgl multiset mwc-random
       ];
       testHaskellDepends = [
         base Cabal containers fgl hspec hspec-expectations multiset
         mwc-random QuickCheck
       ];
       jailbreak = true;
       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.7";
       sha256 = "2e0be0ffd95d245caa506f73553cf5d3d501b06e27de7188a1f281178ded2eef";
       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.5";
       sha256 = "1ece884c105a81479a57d215b50ff22e7d60a86d6b04ab072724192132fcd633";
       libraryHaskellDepends = [
         AC-Vector base base-unicode-symbols containers GLUT graph-rewriting
         graph-rewriting-layout OpenGL
       ];
       jailbreak = true;
       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.6";
       sha256 = "77efc3d0516306119c1e959a7bfb37428e9cfb67e6e34cc7bfb728216c159ee3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols GLUT graph-rewriting graph-rewriting-gl
         graph-rewriting-layout graph-rewriting-strategies IndentParser
         OpenGL parsec
       ];
       jailbreak = true;
       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.3";
       sha256 = "c5950e8c5714968e59203518335dad4f796191248a8f762c8676343b9567da25";
       libraryHaskellDepends = [
         AC-Vector base base-unicode-symbols graph-rewriting
       ];
       jailbreak = true;
       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.4";
       sha256 = "4409c3422694fa332cafb8cde7711d4442c3e0cd412daa401e9d1e413ee3ae49";
       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 = "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.3";
       sha256 = "59a6a16d6c4d51608a0e07dc611e89ee4dc376c4096488a460e9dabafab93556";
       libraryHaskellDepends = [
         base base-unicode-symbols containers graph-rewriting
       ];
       jailbreak = true;
       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.6";
       sha256 = "cf237b8faf13a36d5bb594a64b2768db0203a819b083c02ff45282ea07ab11ed";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols containers directory filepath GLUT
         graph-rewriting graph-rewriting-gl graph-rewriting-layout OpenGL
         uu-parsinglib
       ];
       jailbreak = true;
       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.4";
       sha256 = "5c6c65e3904c00c3ac62ebba5ef1ce64604101cb3f76e944a034e1127c2c3a99";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols GLUT graph-rewriting graph-rewriting-gl
         graph-rewriting-layout IndentParser OpenGL parsec
       ];
       jailbreak = true;
       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, containers, directory, dotgen, filepath
     , haskell-lexer
     }:
     mkDerivation {
       pname = "graphmod";
       version = "1.2.8";
       sha256 = "e4fe1c418f8c975581cbfaf2ada04ad69d6f70cc0ded8c3603e2179d03d3c2fc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base 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
       ];
       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;
     }) {};

  "grid" = callPackage
    ({ mkDerivation, base, cereal, containers, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "grid";
       version = "7.8.4";
       sha256 = "53ac474ffa42149d2a34ef40ff69b934d95fc03f2d920219c5611a1a521091c9";
       libraryHaskellDepends = [ base cereal containers ];
       testHaskellDepends = [
         base containers QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/mhwombat/grid";
       description = "Tools for working with regular grids (graphs, lattices)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "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" = 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";
       sha256 = "7c5ce3a314ac0172bc03e6ddca41a8508ab22e1c89ff1458642d56a942974386";
       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";
       libraryHaskellDepends = [
         base containers data-default epoll failure hack HTTP network unix
         utf8-string
       ];
       homepage = "http://github.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
       ];
       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, bytestring, containers, deepseq
     , directory, extensible-exceptions, filepath, HTTP, HUnit, MissingH
     , network, network-uri, old-locale, old-time, parsec, pretty
     , process, regex-compat, tar, time, unix, xml, zlib
     }:
     mkDerivation {
       pname = "hackport";
       version = "0.4.6";
       sha256 = "5b5cd178fbefe5363bd4f68ca98386fd2762df88ff24435e1999f28e80b1e14e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers deepseq directory
         extensible-exceptions filepath HTTP MissingH network network-uri
         old-locale old-time parsec pretty process regex-compat tar time
         unix xml zlib
       ];
       testHaskellDepends = [
         base 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;
     }) {};

  "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, 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
         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 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;
       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, 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
         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 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;
       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
       ];
       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-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.1.5";
       sha256 = "f838c308bd3f82ba0766078e1aac0d6593e0eac63403beb6453c77fee36c7929";
       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" = 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;
     }) {};

  "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
       ];
       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.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
       ];
       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.0";
       sha256 = "13fe072ff4fbad2d16c4e80749db3cfe56a90df8499e86e615c4afda38589143";
       libraryHaskellDepends = [
         array base bytestring constraints containers language-vhdl mtl
         operational-alacarte pretty syntactic
       ];
       jailbreak = true;
       homepage = "https://github.com/markus-git/hardware-edsl";
       description = "Deep embedding of hardware descriptions with code generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "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";
       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 }:
     mkDerivation {
       pname = "haskell-bcrypt";
       version = "0.3.1";
       sha256 = "ed281ee8520e24b7d0a818494d48ab1c57e8b06d47a76207e058805aefcd0cf1";
       libraryHaskellDepends = [ base bytestring ];
       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.11";
       sha256 = "b3843bc0375160280a24bf4f55b9d2c5a581dd3639e7fe7fa6c846831c04ef2b";
       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 ];
       jailbreak = true;
       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.11";
       sha256 = "b25c07cb1c4d40a4a2bedd38d0a91633f360dde4ab4b34c7011a281f79a7f880";
       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-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" = 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;
     }) {};

  "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 = "1.4.3";
       sha256 = "73b49427676a19a55bc8c86deee8b1864cdbd39f15b74d811d7b8cc8ac1f3d9b";
       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.7";
       sha256 = "5ebbd8bf1d5164a67c12d7f42e6c2cc4f3a0ea996fd5644651c0ea5f6e579a92";
       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
       ];
       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
       ];
       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.3.1";
       sha256 = "b31e66b2baecbc238e24e0914897bfbb6261124da17efe18e821eb52ec18d6e3";
       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_0_19_3_2" = 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.2";
       sha256 = "eabeb40cea7f430add6ed3b25bf3b079427b76e5f5f2a039c5709026ef253949";
       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
       ];
       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-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
       ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-backend";
       description = "API for backends of \"hasql\"";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hasql-pool" = callPackage
    ({ mkDerivation, base-prelude, hasql, resource-pool, time }:
     mkDerivation {
       pname = "hasql-pool";
       version = "0.3";
       sha256 = "7afb74396758b9df4e5a5c0b2d63de1253e7717011eaea6269f9740423f18428";
       libraryHaskellDepends = [ base-prelude hasql resource-pool time ];
       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
       ];
       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
       ];
       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
       ];
       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 = "3";
       editedCabalFile = "29ee2fa8aa0d428e48e444a4bc6f287ca4e8db25ae04db0a18d72af06129dd51";
       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.3";
       sha256 = "20e955b97d731aafc404bb1560d47050944530c655acd7eb80e1d4a8468dfcc7";
       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";
       libraryHaskellDepends = [
         aeson base blaze-markup bytestring cereal containers deepseq
         hashable path-pieces safecopy text unordered-containers uuid vector
       ];
       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;
     }) {};

  "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.0";
       sha256 = "7c1c4762af5bbd493841f291855e7de5ab4b12a5260e8fd95d1f6c9e5a012d7a";
       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.1";
       sha256 = "4d89022b55d139afd274318238706ef4c12fbcd22f3191af9008da4b78eb11c6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base random text ];
       executableHaskellDepends = [ base random text ];
       homepage = "http://github.com/i-amd3/hero-club-five-tenets";
       description = "Remember 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.1";
       sha256 = "1bf5c1e5b686af47739f8589134889812fd7313049777001acf74bae38011373";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal Diff directory filepath haskell-src-exts hindent hlint
         HUnit pipes pretty 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
       ];
       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
       ];
       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";
       sha256 = "819b990d61f1a42d7d7033950f785412a6dcdb8e62cb5ed1fbf82ff0428f746c";
       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";
       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";
       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";
       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.1";
       sha256 = "d1e36c8fe5dfd46819425877ca7fc6a5b422fce138de9787b7409850252decff";
       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, test-framework
     , test-framework-hunit, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hjsonpointer";
       version = "0.2.0.4";
       sha256 = "8ac317938cc885b01d1165f15671def24e6ceac971413bd494195e77fe0e45b0";
       libraryHaskellDepends = [
         aeson base text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base http-types HUnit test-framework test-framework-hunit
         text unordered-containers vector
       ];
       jailbreak = true;
       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
       ];
       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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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, filepath
     , haskell-src-exts, optparse-applicative, split
     }:
     mkDerivation {
       pname = "hothasktags";
       version = "0.3.4";
       sha256 = "be41b5109ba887eeea36c3a2141a0e0f2d7868af728e3ccb4d828a896707d75e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers cpphs filepath 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, text
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "hpack";
       version = "0.8.0";
       sha256 = "cd5f5cac842cfedb187f25b8932020e6f9e7c287d0477393330050af0d8e20db";
       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 text unordered-containers yaml
       ];
       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;
     }) {};

  "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;
     }) {b2 = null;};

  "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" = 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";
     }) {};

  "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-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
     }:
     mkDerivation {
       pname = "hsdev";
       version = "0.1.5.2";
       sha256 = "c60c0ff6283a3b3a043f63598440fe9a577409037bb252481171d1ce839df86f";
       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 = [
         async base containers data-default deepseq hformat lens mtl text
       ];
       jailbreak = true;
       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-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.0";
       sha256 = "ada2125507c42987735cfdb7bd13dd205958527788b44ca20c5b3f482865727e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers deepseq directory hsqml OddWord text
       ];
       jailbreak = true;
       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";
       libraryHaskellDepends = [ base haskell98 ];
       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
       ];
       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";
       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";
       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";
       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";
       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 = "2";
       editedCabalFile = "0370852e7250c2c2bb1575155286442cbfcdd03a7e494dcaa73305d4e84a6c76";
       libraryHaskellDepends = [
         base bytestring HTTP iconv mime mtl parsec text utf8-string zlib
       ];
       jailbreak = true;
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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" = 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
       ];
       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";
       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
       ];
       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
       ];
       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
       ];
       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";
       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
       ];
       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.0.0";
       sha256 = "d2db68091c07fa021dc9bde2468c0cbff950198481476f8e269e34f6ccc000a5";
       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";
       sha256 = "0faa50be5db638cdcd51c0e35fd418041204eff0173547a2d076995fa163b82f";
       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;
     }) {};

  "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;
     }) {};

  "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" = 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;
     }) {};

  "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";
     }) {};

  "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, vector }:
     mkDerivation {
       pname = "inf-interval";
       version = "0.1.0.0";
       sha256 = "817494d30f229c50dd47b501bfa832bf873f1b90ccdeba844cc50445f0c8791b";
       libraryHaskellDepends = [ array base deepseq 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, data-default-class
     , deepseq, directory, exceptions, filepath, ieee754, mtl, pretty
     , primitive, process, quickcheck-assertions, R, setenv, silently
     , singletons, strict, tasty, tasty-golden, tasty-hunit
     , tasty-quickcheck, template-haskell, temporary, text, th-lift
     , th-orphans, transformers, unix, vector
     }:
     mkDerivation {
       pname = "inline-r";
       version = "0.7.3.0";
       sha256 = "4de9508426ad48159502d7e2b3c241367643c8a2645f62b61d896e7b7535e329";
       libraryHaskellDepends = [
         aeson base bytestring data-default-class deepseq exceptions mtl
         pretty primitive process 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-golden
         tasty-hunit tasty-quickcheck template-haskell temporary text unix
         vector
       ];
       jailbreak = true;
       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";
       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_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" = 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";
       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, clock, containers
     , fast-logger, irc-fun-client, irc-fun-messages, json-state, time
     , time-interval, time-units, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "irc-fun-bot";
       version = "0.5.0.0";
       sha256 = "1104c508068dcfba3f8c60c39d5cc8ccb9b264af57097e8fa2b61e68e3754b51";
       libraryHaskellDepends = [
         aeson auto-update base clock containers fast-logger irc-fun-client
         irc-fun-messages json-state time time-interval time-units
         transformers unordered-containers
       ];
       jailbreak = true;
       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, fast-logger, irc-fun-messages
     , network, time, time-units, unordered-containers
     }:
     mkDerivation {
       pname = "irc-fun-client";
       version = "0.4.0.0";
       sha256 = "2567be16b259a37a4234a1716bef694d6f1ce6c3b7c9f553d9d0a12a0be65c33";
       libraryHaskellDepends = [
         auto-update base fast-logger irc-fun-messages network 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 }:
     mkDerivation {
       pname = "irc-fun-color";
       version = "0.1.0.1";
       sha256 = "8b87a8c9e6325f6185b42c213bc56aa8bee080f20ef1fdf53c1c8b26031bf088";
       revision = "1";
       editedCabalFile = "91737e98e11349079179790b93588c5c52a6ef31eb96bf4dfc99eb7672b96696";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       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, regex-applicative }:
     mkDerivation {
       pname = "irc-fun-messages";
       version = "0.2.0.1";
       sha256 = "b54ab9b8a259c49a495f111bc7a56c5cd50334c4708dea6e3f06b66534325198";
       libraryHaskellDepends = [ base regex-applicative ];
       homepage = "http://rel4tion.org/projects/irc-fun-messages/";
       description = "Types and functions for working with the IRC protocol";
       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";
       libraryHaskellDepends = [
         base binary containers directory haskell98 mtl parsec
       ];
       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";
       sha256 = "a2c36f5a4c69e8a1afdf92e0ebd4007f045f9509686d48d61d991cbcbe428ac4";
       revision = "2";
       editedCabalFile = "eb10d8166cc3a40e8d731ab1fba7d37ef57d155d6122c7234297ddbf776ec28a";
       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, glib, gtk3, hslogger, lens, template-haskell
     , text, transformers, webkitgtk3, webkitgtk3-javascriptcore
     }:
     mkDerivation {
       pname = "jsaddle";
       version = "0.2.1.0";
       sha256 = "3aebcb9422803265598a027f1e8a63f0f41176a0efdb436bf502d61102754513";
       libraryHaskellDepends = [
         base lens template-haskell text transformers webkitgtk3
         webkitgtk3-javascriptcore
       ];
       testHaskellDepends = [
         base glib gtk3 hslogger lens template-haskell text transformers
         webkitgtk3 webkitgtk3-javascriptcore
       ];
       jailbreak = true;
       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-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, base-prelude, bytestring
     , bytestring-tree-builder, contravariant, contravariant-extras
     , scientific, text
     }:
     mkDerivation {
       pname = "json-encoder";
       version = "0.1.3.1";
       sha256 = "0127462ef932a643adc948bbb1de89de78d705a464c2591aedafddcd8382fadc";
       libraryHaskellDepends = [
         base base-prelude bytestring bytestring-tree-builder contravariant
         contravariant-extras scientific text
       ];
       homepage = "https://github.com/sannsyn/json-encoder";
       description = "A very fast 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-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.0.2";
       sha256 = "e8187d8946735a2e6845ddcc4097181c99d750aea2b9c4563bf9765e86c3be82";
       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
       ];
       jailbreak = true;
       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.2.0";
       sha256 = "370fb8122243ada541060a4ea201d54f19d3031b7a524ec5176545a31be72740";
       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.2.0";
       sha256 = "49eefc830aa7164662ea2a6263e9ea5d2379ebe21de6c6eaa463847e4c4ce33c";
       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
       ];
       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";
       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.0";
       sha256 = "852fe9fd9fb43c281faff5a33854639bf34daee81cf9ce76bb14192bbefc29db";
       revision = "1";
       editedCabalFile = "8cc980c70a4afc20585413ec8894673f768b80911ec864386ef8c6c3c0d7505a";
       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, hspec
     , QuickCheck, quickcheck-unicode, scientific, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-stream";
       version = "0.4.0.0";
       sha256 = "10efbff41ba46c62b0f78f650275b3dcc1c5665edca7291143ddc9a7bbc8880a";
       libraryHaskellDepends = [
         aeson base bytestring scientific text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring directory 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.2.3";
       sha256 = "5032d97c798d038ab1991d8bb239c9c1c71ae88bcc396ad8944252b0c5019ca9";
       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, binary, bytestring, containers
     , directory, filepath, hashable, minisat, mtl, pretty, process
     , unordered-containers
     }:
     mkDerivation {
       pname = "jukebox";
       version = "0.1.6";
       sha256 = "1bde5dd2fadd0b598c11657199ee90bfe8f822807a394857ef902d2d8fec366a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath hashable
         minisat mtl pretty process unordered-containers
       ];
       libraryToolDepends = [ alex ];
       executableHaskellDepends = [
         array base binary bytestring containers directory filepath hashable
         minisat mtl pretty process unordered-containers
       ];
       executableToolDepends = [ alex ];
       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
       ];
       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;
     }) {};

  "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 = "1";
       editedCabalFile = "6f3238173ad5a0fbdd82c2b73e96b4c43f17fa45f76f7249e6e925ed7eef9a97";
       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;
     }) {};

  "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.1.0.0";
       sha256 = "0122f788610316c0dbb1be46796191c68ccf97b447897f8afdd31c2e83f86f09";
       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";
       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
       ];
       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-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, binary, bitmap, bytestring, bytestring-trie
     , containers, lambdacube-core, lambdacube-edsl, language-glsl, mtl
     , OpenGLRaw, prettyclass, vector
     }:
     mkDerivation {
       pname = "lambdacube-gl";
       version = "0.2.2";
       sha256 = "bee622839c09a05fdab01fb88c15680eb0cc0feda1a580ddb81fa2cbbefa1d28";
       libraryHaskellDepends = [
         base binary bitmap bytestring bytestring-trie containers
         lambdacube-core lambdacube-edsl language-glsl mtl OpenGLRaw
         prettyclass vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/LambdaCubeEngine";
       description = "OpenGL backend for LambdaCube graphics language (main package)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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
       ];
       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" = 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;
     }) {};

  "language-ecmascript-analysis" = callPackage
    ({ mkDerivation, base, containers, language-ecmascript, parsec
     , uniplate
     }:
     mkDerivation {
       pname = "language-ecmascript-analysis";
       version = "0.9.1";
       sha256 = "36f95a57347dfaa7d1b05a80469ba5be031870b1ea1c2694a61d124d791cec13";
       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, bifunctors, bytestring, case-insensitive
     , containers, cryptonite, Diff, directory, either, exceptions
     , filecache, formatting, Glob, hashable, hruby, hslogger, hslua
     , hspec, HUnit, lens, lens-aeson, megaparsec, memory, mtl
     , operational, optparse-applicative, parallel-io, parsec, parsers
     , 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.4.1";
       sha256 = "9081e2da9a4d046d034d59cc277bfb1bbf16b1fd6f925aef6d44674228423c97";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-wl-pprint attoparsec base base16-bytestring bifunctors
         bytestring case-insensitive containers cryptonite directory either
         exceptions filecache formatting hashable hruby hslogger hslua lens
         lens-aeson megaparsec memory mtl operational parsec parsers
         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 ansi-wl-pprint base bytestring containers Diff either Glob
         hslogger hspec lens megaparsec mtl 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
         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" = 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-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.4";
       sha256 = "f3a19de12610c6273138467bfc89795e98d7dddc1064f8e1a947b0d8c16fe93b";
       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
       ];
       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
       ];
       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";
       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
       ];
       homepage = "http://github.com/ekmett/lens/";
       description = "Lenses, Folds and Traversals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens_4_13_1" = 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.1";
       sha256 = "987137d11f189e08ceeb0e2e5c047c1456ad666642974067d2d8e11309ef6b7b";
       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 = "1";
       editedCabalFile = "806f94330f5b813192f1cfe62a0c07ecb43ecdb1f83b94e4aa704e7d2be017da";
       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";
       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 = "1";
       editedCabalFile = "13c96ddf2d410ec4e6671c8412710b7cdbbfc837ff5be1d09a6dbb9ecdb9285d";
       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.0";
       sha256 = "478377492a910492589771f0fbcbff25a7890a24672f1134005ff3893ae56b6f";
       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.8.0";
       sha256 = "2d7a645f25bd98f64e834fa0fe6b721730483efff395343ccd03814ad540435a";
       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
       ];
       jailbreak = true;
       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.9";
       sha256 = "621f0dbd1bfc57d7fbd593698ed31af9b1943ba65fc9ece31514d6caab58748a";
       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";
       sha256 = "77db9dacd191547300bd303555492f81cfbb00827d6364495f98fce053a627e1";
       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.0.0";
       sha256 = "4944ffa47d4758135c40f776634e1f7b542c8886ef62b61f224a973c143173cb";
       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" = 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;
     }) {};

  "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
       ];
       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
       ];
       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.0.9";
       sha256 = "6e84201625f8924da5f63eee8fe66b89bbf70bd5631509c9fd3eaef0f05c240f";
       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.0";
       sha256 = "7c6a6634abeb541c1fea59b34743dfb37b71f92359b0d481e50f962486f99da4";
       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
       ];
       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.0.0";
       sha256 = "612d2e40ea69da99940357d88098ef30f1eaf8eda18a2f084fc300f097a3d2f8";
       revision = "1";
       editedCabalFile = "64ab5cdad51aaff9fcb168afee8ef6602287e8ee24c156564adc1adfd7ad1119";
       libraryHaskellDepends = [
         base containers mtl parsec setenv template-haskell transformers
       ];
       testHaskellDepends = [
         base containers HUnit mtl QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       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.0";
       sha256 = "9c7deabf027c2e7bfc800b26f103b259e25ee9ef814ce53260df3950aa682e8f";
       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.3.0";
       sha256 = "fb42d26b521ccbad897271061e3df5ae1977051740d259757efcde2892b55f42";
       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;
     }) {};

  "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, constraints, containers
     , data-default, deepseq, MonadRandom, mtl, numeric-prelude
     , QuickCheck, random, reflection, repa, singletons, storable-record
     , storable-tuple, tagged-transformer, test-framework
     , test-framework-quickcheck2, th-desugar, time, transformers
     , type-natural, vector, vector-th-unbox
     }:
     mkDerivation {
       pname = "lol";
       version = "0.1.0.0";
       sha256 = "be1a72e80ca1f3471b1b630f0407fa6e152ce6410ea7aee86fabda002dff12d0";
       revision = "1";
       editedCabalFile = "f70d927711c82b11f9d38d398bf8d450788482693cdbde540331ca50674b8e68";
       libraryHaskellDepends = [
         arithmoi base constraints containers data-default deepseq
         MonadRandom mtl numeric-prelude QuickCheck random reflection repa
         singletons storable-record storable-tuple tagged-transformer
         th-desugar transformers type-natural vector vector-th-unbox
       ];
       testHaskellDepends = [
         base constraints MonadRandom QuickCheck repa test-framework
         test-framework-quickcheck2 time type-natural vector
       ];
       jailbreak = true;
       homepage = "https://github.com/cpeikert/Lol";
       description = "A library for lattice cryptography";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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
       ];
       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" = 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;
     }) {};

  "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;
     }) {};

  "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";
       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;
     }) {};

  "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;
     }) {};

  "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
       ];
       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
       ];
       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.2.0.0";
       sha256 = "79d4b6be4c6b85c8e365565a1fda18a295fa2998d475b05cf1af7f04df3e0c91";
       libraryHaskellDepends = [ base text time ];
       jailbreak = true;
       homepage = "http://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" = 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;
     }) {};

  "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.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;
     }) {};

  "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" = 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
       ];
       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.6.1";
       sha256 = "af2a9763a35ee85bb27a9ff14d7fe1f653407a96a35835f9d182cdfd532ef0c3";
       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" = callPackage
    ({ mkDerivation, base, hashable, microlens, microlens-ghc
     , microlens-mtl, microlens-th, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "microlens-platform";
       version = "0.2.1.0";
       sha256 = "2afd1e023a4bbbdd88e22d2cb706831af2809a099f183cbf04d24b19b6b32326";
       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";
       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" = callPackage
    ({ mkDerivation, base, containers, microlens, template-haskell }:
     mkDerivation {
       pname = "microlens-th";
       version = "0.3.0.0";
       sha256 = "951eaf33daf3b648082f754a6c091a8401bad39f5d5f659bad22252fe214d866";
       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, base, containers, directory, exceptions, filepath
     , formatting, haskeline, HCodecs, megaparsec, mtl
     , optparse-applicative, path, process, QuickCheck, random
     , temporary, test-framework, test-framework-quickcheck2, text
     , tf-random, transformers
     }:
     mkDerivation {
       pname = "mida";
       version = "0.4.6";
       sha256 = "453d24262084fbd34e5400599a739ae539f2601cefb9cd1aba0c462e9bf81838";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers exceptions haskeline HCodecs megaparsec mtl random
         text tf-random transformers
       ];
       executableHaskellDepends = [
         base containers directory exceptions filepath formatting haskeline
         HCodecs megaparsec mtl optparse-applicative path process random
         temporary text tf-random transformers
       ];
       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, containers, mtl, transformers }:
     mkDerivation {
       pname = "minilens";
       version = "0.1.1.1";
       sha256 = "99586ecf220ec1a16c71b03df6da0439b4c711e4ae6b8510cea85473aa12da80";
       libraryHaskellDepends = [ array base containers mtl 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" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "mmorph";
       version = "1.0.5";
       sha256 = "6ae92f8c9e0aa767ecce520833ac46d3cf293931050650dc8896be16fb16da9d";
       libraryHaskellDepends = [ base transformers ];
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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
       ];
       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.4";
       sha256 = "e984b7346af6d31b7ce918e1a0263075af8cbcf5440bc3df698d0354c90df61e";
       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" = 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
       ];
       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" = 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;
     }) {};

  "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
       ];
       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.0";
       sha256 = "9993e6590abe8cc69db34d8b11dec3ab2e13179cf3d162f2b79b86462c5becdd";
       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 = "1";
       editedCabalFile = "e576e7529ec57922cc6356c288f2ce5b80dbe7323e134fc5c268644c85385513";
       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 = "1";
       editedCabalFile = "0ee31ed93d111cf08f6b5323cd94f6f3a48388c53093ddc0731aeb8f0dad17ec";
       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 = "1";
       editedCabalFile = "28392123a8b245f7bc2c13bb63f5c3008118ed38e107cf0534be37461fb64daf";
       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 = "1";
       editedCabalFile = "ab0be6e2bbdc22be03cf722277972a7bd3c11732567fe33f7f12af56a09f533e";
       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 = "1";
       editedCabalFile = "021ce075d81cc8dbadfa395895ba0511fc35230f12e1ba409a553eded8c96d1f";
       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 = "1";
       editedCabalFile = "49283811dc1e565bdc4a3e7cfd2e3744866906e1267ffb018f3e271c05e2d169";
       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";
       sha256 = "a82e63352ed854319bca7d33e3aa13a42a18648e47d01109f8c306ee54b9418b";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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;
     }) {};

  "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;
     }) {};

  "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, mtl, tagged, transformers }:
     mkDerivation {
       pname = "multistate";
       version = "0.6.2.0";
       sha256 = "72ffe698f15b9eb3d678f488f1f62cc8addb6bf4e5b23d9a26e28831d6031d69";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl tagged transformers ];
       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
     , ja-base-extra, mtl, parsec, process, scientific, temporary, text
     , unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "mustache";
       version = "0.5.1.0";
       sha256 = "c6df193215b024b79bb34ec01d1c8c8fa7084887db2def231b943d47b851d882";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base-unicode-symbols bytestring containers directory
         either filepath ja-base-extra 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
       ];
       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" = 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;
     }) {};

  "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-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-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, base, bytestring, containers, microlens, text }:
     mkDerivation {
       pname = "nanq";
       version = "1.1.1";
       sha256 = "bdb90d5d32773f77401e89de6736ffb26d8c747a6eb3094c75629a9bc2386745";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers microlens text
       ];
       executableHaskellDepends = [
         base bytestring containers microlens 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.2";
       sha256 = "b771a07838f7932fc39cde8b2f7e8be00f637561f4320d0579aa4d729c5cafbb";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base containers quickcheck-instances tasty tasty-quickcheck
       ];
       jailbreak = true;
       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.5.1";
       sha256 = "009bc5cd0834329c4944768b86d69ef4cf2b87507263eb4415adf34a6c262820";
       libraryHaskellDepends = [ array base bytestring cereal text ];
       testHaskellDepends = [
         array base bytestring cereal HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text zlib
       ];
       jailbreak = true;
       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 ];
       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" = 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 ];
       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.0";
       sha256 = "65070ee005098819c3521be167182f5d22b5ab5687c066658ef226262f3314f4";
       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, base64-bytestring, blaze-builder
     , bytestring, composition-extra, containers, cookie, cryptonite
     , data-default, errors, hspec, hspec-wai, http-types, iso8601-time
     , lucid, memory, mtl, poly-arity, pred-trie, regex-compat
     , semigroups, stm, text, time, transformers, tries, utf8-string
     , wai-extra, wai-middleware-content-type, wai-middleware-verbs
     , wai-session, wai-transformers, warp
     }:
     mkDerivation {
       pname = "nested-routes";
       version = "6.1.0";
       sha256 = "9eddbc6ce2fa029a54f27c753bc28c7093f8a351a5ae6d4fec11b6ec6d4fd8b1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring composition-extra containers mtl
         poly-arity pred-trie regex-compat semigroups text transformers
         tries wai-middleware-content-type wai-middleware-verbs
         wai-transformers
       ];
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring
         composition-extra containers cookie cryptonite data-default errors
         http-types iso8601-time lucid memory mtl poly-arity pred-trie
         regex-compat semigroups stm text time transformers tries
         utf8-string wai-extra wai-middleware-content-type
         wai-middleware-verbs wai-session wai-transformers warp
       ];
       testHaskellDepends = [
         attoparsec base bytestring composition-extra containers hspec
         hspec-wai http-types mtl poly-arity pred-trie regex-compat
         semigroups text transformers tries 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" = 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;
     }) {};

  "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-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" = 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;
     }) {};

  "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
       ];
       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
       ];
       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;
     }) {};

  "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.2";
       sha256 = "b9b467e85efe2c0a2270fb0ceb64debf88b7147e4b3b21dbc8332cb1cd2a496e";
       libraryHaskellDepends = [
         base binary bmp bytestring cereal GLUT OpenGL OpenGLRaw
         spatial-math time vector vector-binary-instances
       ];
       jailbreak = true;
       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;
     }) {};

  "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;
     }) {};

  "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;
     }) {};

  "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
     , SafeSemaphore
     }:
     mkDerivation {
       pname = "oi";
       version = "0.3.1";
       sha256 = "57d8bf024deb1a4a46c580b89eaa80a394bc4c58fe33e898448c897caeaa0893";
       libraryHaskellDepends = [
         base comonad directory filepath parallel SafeSemaphore
       ];
       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;
     }) {};

  "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" = 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";
     }) {};

  "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
       ];
       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
       ];
       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;
     }) {};

  "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" = 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";
     }) {};

  "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" = 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;
     }) {};

  "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-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-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
       ];
       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-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-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
       ];
       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
       ];
       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-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
       ];
       doCheck = false;
       homepage = "http://pandoc.org";
       description = "Conversion between markup formats";
       license = "GPL";
     }) {};

  "pandoc_1_16_0_2" = 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
       ];
       jailbreak = true;
       homepage = "http://pandoc.org";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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" = 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;
     }) {};

  "pandoc-citeproc_0_9" = 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
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/jgm/pandoc-citeproc";
       description = "Supports using pandoc with citeproc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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-default, hspec
     , mtl, pandoc, pandoc-types, process, yaml
     }:
     mkDerivation {
       pname = "pandoc-crossref";
       version = "0.1.6.3";
       sha256 = "7ec41e6fa2acf6826889670e7636b209a6833872de3b65034891a402b7bd356b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-default mtl pandoc pandoc-types
         yaml
       ];
       executableHaskellDepends = [
         base bytestring containers data-default mtl pandoc pandoc-types
         yaml
       ];
       testHaskellDepends = [
         base bytestring containers 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.2";
       sha256 = "0818e8b8e88e98b162a4fb7a9369cf3e54a2108f428d3a88b0217c7b58a6d961";
       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 ];
       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" = 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;
     }) {};

  "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-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" = callPackage
    ({ mkDerivation, base, directory, exceptions, filepath, path, time
     , transformers
     }:
     mkDerivation {
       pname = "path-io";
       version = "0.1.1";
       sha256 = "252633966f9a2c76297260c517b5a4d45597ffe4b3b8f53dbd44a363a4eb55cc";
       libraryHaskellDepends = [
         base directory exceptions filepath path time transformers
       ];
       homepage = "https://github.com/mrkkrp/path-io";
       description = "Interface to ‘directory’ package for users of ‘path’";
       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-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" = 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;
     }) {};

  "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.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;
     }) {};

  "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.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;
     }) {};

  "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.3.0.0";
       sha256 = "9b9383f1dfa6d3c8b700fa4417a27538175143259a3410dfd72a39e5ac299b4f";
       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.1";
       sha256 = "4af95781aef9366894c7c7fde4700cac7d954c617ffe16374bd90bd5833bd887";
       libraryHaskellDepends = [
         base bytestring convertible HDBC persistable-record
         relational-query-HDBC text-postgresql
       ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "HDBC Convertible instances and HRR persistable 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.2.0";
       sha256 = "14f496b53ad8bf95d496e685e7d006f226b8cb579284ea2cd2d554590e6050d2";
       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;
     }) {};

  "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, random, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "pinboard";
       version = "0.9.2";
       sha256 = "a009de2327af08a929503482ffe60700348422807df3e22f2a7e6f98ac0aabda";
       libraryHaskellDepends = [
         aeson base bytestring containers either http-client http-client-tls
         http-types mtl network old-locale 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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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 ];
       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 ];
       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 ];
       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" = 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;
     }) {};

  "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
       ];
       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" = 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;
     }) {};

  "pipes-transduce" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, conceit, doctest
     , foldl, free, lens-family-core, 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.0.0";
       sha256 = "073c2ac2534fa8a29d65fb42b49ae1cff752513c69b3752145681b7a8d27c62b";
       libraryHaskellDepends = [
         base bifunctors bytestring conceit foldl free lens-family-core
         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;
     }) {};

  "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";
       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.3";
       sha256 = "f995b27e6388e5f6f037c175802f0bd65809e151b7130372f6300b6412a6c99c";
       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;
     }) {};

  "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";
     }) {};

  "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;
     }) {};

  "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";
       sha256 = "b43f5d60c7549bc22130219b34f4385265b9f8a386db1816d5982931b704f46c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base concurrent-split containers deepseq transformers unsafe
         utility-ht
       ];
       homepage = "http://code.haskell.org/~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" = 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
       ];
       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";
       libraryHaskellDepends = [
         aeson atto-lisp base bytestring data-default mtl semigroups text
       ];
       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;
     }) {};

  "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;
     }) {};

  "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_1_0" = callPackage
    ({ mkDerivation, base, deepseq, directory, filepath, unix }:
     mkDerivation {
       pname = "process";
       version = "1.4.1.0";
       sha256 = "26e6e28600b59e1553ad014d47aa0dff7749a5f146af7412c13f37f38e9c85ab";
       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" = 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;
     }) {};

  "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, contravariant, directory, doctest, exceptions
     , filepath, foldl, free, lens, pipes, pipes-attoparsec
     , pipes-bytestring, pipes-concurrency, pipes-group, pipes-parse
     , pipes-safe, pipes-text, process, semigroups, tasty, tasty-hunit
     , text, transformers, transformers-compat, void
     }:
     mkDerivation {
       pname = "process-streaming";
       version = "0.7.2.2";
       sha256 = "634d16c4444840d7a5264936b5d3b20cc277154a905f967872cbfedce4a1b04a";
       libraryHaskellDepends = [
         base bifunctors bytestring conceit containers contravariant foldl
         free pipes pipes-bytestring pipes-concurrency pipes-parse
         pipes-safe pipes-text process semigroups text transformers
         transformers-compat void
       ];
       testHaskellDepends = [
         attoparsec base bifunctors bytestring containers directory doctest
         exceptions filepath free lens pipes pipes-attoparsec
         pipes-bytestring pipes-concurrency pipes-group pipes-parse
         pipes-safe pipes-text 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.2.0.2";
       sha256 = "fe2d0a9a44785ee2fb7ea54ceb73088fab3f81179c1c1541cbb183ad188229e3";
       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, binary, cond, container, convert
     , data-default, data-layer, errors, functor-utils, lens, lens-utils
     , mtl, pretty-show, string-qq, text, transformers
     , transformers-base, tuple, vector
     }:
     mkDerivation {
       pname = "prologue";
       version = "1.0.6";
       sha256 = "c14e942d1021bc060ca4c8df14c0f487a0f03607c3b5afa65b1dd3d75e0c277f";
       libraryHaskellDepends = [
         base binary cond container convert data-default data-layer errors
         functor-utils lens lens-utils mtl pretty-show string-qq text
         transformers transformers-base tuple 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.3";
       sha256 = "8d83603d915fcce9ce109b70bd19499a94a70de6abc2a31ac2ebd892f76af683";
       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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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
       ];
       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.4.2";
       sha256 = "7a582411a33481d23b518dbf581acc71d00eb8bfcd086aa4658dcbbbf1d98bcf";
       libraryHaskellDepends = [ base containers parsec ];
       testHaskellDepends = [
         base Cabal containers hspec parsec QuickCheck
       ];
       jailbreak = true;
       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" = 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;
     }) {};

  "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-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" = 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;
     }) {};

  "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" = 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
       ];
       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-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;
     }) {};

  "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
       ];
       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;
       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
       ];
       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.1.0";
       sha256 = "0390684ce0d977c49b921ed477bcba5cb7c74e09130de843c53c93f4d4cee0ae";
       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" = 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;
     }) {};

  "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.3.2";
       sha256 = "55fae21380809137c5bdbde646479b01e36793f10523e44842eb35bc9c42f419";
       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, ref-tf, reflex, safe
     , semigroups, text, these, time, transformers, webkitgtk3
     , webkitgtk3-javascriptcore
     }:
     mkDerivation {
       pname = "reflex-dom";
       version = "0.2";
       sha256 = "fd350b5e6d4613802bf37ebf15362b083af7bfec9ec22a56d1245bc3d2af86dd";
       revision = "2";
       editedCabalFile = "2aa20b3cf39f41e8850a54ab28b95b000065ccc5b65e44f0710171821e72cbe6";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring containers data-default
         dependent-map dependent-sum dependent-sum-template directory
         exception-transformers ghcjs-dom glib gtk3 lens mtl ref-tf reflex
         safe semigroups text these time transformers webkitgtk3
         webkitgtk3-javascriptcore
       ];
       jailbreak = true;
       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";
       sha256 = "7bceed2b8347bdb8618e21d860a787d53187236a2253c83ab02bd51608a9236e";
       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
       ];
       jailbreak = true;
       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, reflex, transformers
     }:
     mkDerivation {
       pname = "reflex-gloss";
       version = "0.1.0.2";
       sha256 = "cfd9f09e0ff736d60fe00202295dc2ee24748003d09abcd76baa4fe37cc64ba3";
       libraryHaskellDepends = [
         base dependent-sum gloss reflex transformers
       ];
       jailbreak = true;
       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" = 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;
     }) {};

  "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
     }:
     mkDerivation {
       pname = "relational-postgresql8";
       version = "0.1.0.0";
       sha256 = "0efd30853afa6bab8138317dbd0166638f152d76a6175fa32ed92fb6f059afba";
       libraryHaskellDepends = [
         base containers HDBC names-th persistable-record relational-query
         relational-query-HDBC template-haskell time
       ];
       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.1";
       sha256 = "6484cb21a69e27c01edb4ecfe1155ed5780a7b7d608d42c5570eea402755e015";
       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.5.0.0";
       sha256 = "b6d3fb55175eab8d816b15628a24fcf401a768122a8d3db02141605f054ff789";
       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;
     }) {};

  "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";
       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;
       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 ];
       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 ];
       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 ];
       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";
       sha256 = "3b79d07199160c966c67a5300a51b7c8790dda7bed6c00e554a0062d03c9ab4d";
       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
       ];
       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
       ];
       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";
       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" = 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 = "1";
       editedCabalFile = "88d214458142c107f807581931c4d9e995b178d2d76801534f6b1239234aa3be";
       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;
     }) {};

  "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 ];
       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" = 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
       ];
       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";
       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";
       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 = "1";
       editedCabalFile = "a814dde006adf0a6f3b0c98956060b4e9759b47da046ca6faaa8eb0e3272e246";
       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 = "1";
       editedCabalFile = "d3f5642df902f6d3a393839b8e365481fb1b16f4ed945290f85e2c9cda253794";
       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 = "1";
       editedCabalFile = "66767f5908d25ffaeaf9f15ad093f57f88ed212638bbfb7ec23190ed77c133b4";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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, cereal, containers, data-default, either
     , errors, HUnit, lens, network, protobuf, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, time, transformers
     }:
     mkDerivation {
       pname = "riemann";
       version = "0.1.0.2";
       sha256 = "7399d2b85839ef9c44aab66ad3b2f3a35e6a893fd8f5ab1aa1626a0f04128708";
       libraryHaskellDepends = [
         base cereal containers data-default either errors lens network
         protobuf text time transformers
       ];
       testHaskellDepends = [
         base either errors HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/telser/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 = "0.1.0.0";
       sha256 = "f22b4fa41ff69462fbeb551a4bbc92faf26a1ab3910768a9fe75889d4f01ef69";
       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;
     }) {};

  "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";
       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" = 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;
     }) {};

  "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";
     }) {};

  "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" = 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
       ];
       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-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" = 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;
     }) {inherit (pkgs) openssl;};

  "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.2";
       sha256 = "8033fcd488494994f79bb129ffd70a6d2233d647e010a352a7e7dca8ce6072e6";
       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 = "secp256k1 bindings for Haskell";
       license = stdenv.lib.licenses.mit;
       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 ];
       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";
       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";
       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";
       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" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, hashable
     , tagged, text, unordered-containers
     }:
     mkDerivation {
       pname = "semigroups";
       version = "0.18.0.1";
       sha256 = "f6e787519acf261e823d529cc3e5d4fca019075f39f8986649f21891d06d3115";
       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;
     }) {};

  "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";
       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";
       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";
       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";
       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";
       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-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
       ];
       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
       ];
       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" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, hspec
     , http-media, lens, servant, swagger2, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "servant-swagger";
       version = "0.1";
       sha256 = "ee47a6f51afb029abe1add54a1f579340ec48e5b816b592d1b976d0bdfd8346e";
       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;
     }) {};

  "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";
       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-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;
     }) {};

  "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, aeson, aeson-pretty, base, bytestring, time-units
     , unordered-containers
     }:
     mkDerivation {
       pname = "settings";
       version = "0.2.2.0";
       sha256 = "8ca39518d7ed4d0575dbb3bce2064aca006c449765c842906d07484fecf0b831";
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring time-units 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.0";
       sha256 = "e784db96a9fdcf1fe5f48adfc62e8b4ef9795bf4558769c149f244ed5ef9415c";
       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, shakespeare
     , template-haskell
     }:
     mkDerivation {
       pname = "shakespeare-babel";
       version = "0.1.0.0";
       sha256 = "a072ca9cf9397f23b74920d395d880108a7268d63a93da3086ed5a40ee0c2035";
       libraryHaskellDepends = [
         base classy-prelude shakespeare template-haskell
       ];
       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
       ];
       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, base, containers, deepseq, directory, filepath
     , MonadCatchIO-transformers, mtl, SafeSemaphore, text, time
     , transformers
     }:
     mkDerivation {
       pname = "simple-log";
       version = "0.3.2";
       sha256 = "20cf6031d89388b2181a4b8b173893a286c781fd0c20920c98d3992bb6ec96da";
       libraryHaskellDepends = [
         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
       ];
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "slug_0_1_2" = 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
       ];
       jailbreak = true;
       homepage = "https://github.com/mrkkrp/slug";
       description = "Type-safe slugs for Yesod ecosystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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" = 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;
     }) {};

  "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
       ];
       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";
       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 = "1";
       editedCabalFile = "7e46253eccd3c819ebf3700a5398e9405ce21069bc5b8f92a29550cf8119e47a";
       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" = 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;
     }) {};

  "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.5";
       sha256 = "36250918961d51c7b4a3721cee264c8a8c678da07244100b8a0be2c954ff4ca6";
       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.5.0";
       sha256 = "3fbdac29649d0bba318766e271eab808732acd529667c4a9f064aab2858d3ef8";
       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.0.2";
       sha256 = "6933c99a6e0ce0bb540884c76542b9f2d3095ca43718a0ca9475502f33f9262a";
       revision = "1";
       editedCabalFile = "71fa7971fad8f2ce6d0eab96c2e817235822e5e0e048a844ac1288d35dee278f";
       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 = "1";
       editedCabalFile = "d789ed4dceed4c226571d0f5f5e6d2d5602a6b36b7f4579b78352d330934e3ab";
       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-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
       ];
       doCheck = false;
       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" = 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-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
       ];
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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-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
       ];
       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" = 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;
     }) {};

  "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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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-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" = 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;
     }) {};

  "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";
       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, 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";
       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;
     }) {};

  "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.4";
       sha256 = "7700c1ded7d11945b9de3d6e5651fcef3ef5d39317dc332ad7c87b37ceb76b90";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-accessor explicit-exception
         transformers utility-ht 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" = 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;
     }) {};

  "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.1.0.0";
       sha256 = "5d31398c2780363254d7593b3b3ece476e6114cc92a811aab7bb38b3301080f0";
       revision = "2";
       editedCabalFile = "da217c59c330c63984c85be6a669d1c5c990985fa8911ea537087823a45bb8cf";
       libraryHaskellDepends = [
         base exceptions mmorph mtl transformers
       ];
       homepage = "https://github.com/trskop/tagged-exception";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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
       ];
       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
       ];
       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
       ];
       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
       ];
       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
       ];
       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
       ];
       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.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";
     }) {};

  "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.1.0";
       sha256 = "632eafe17cc8ea54571dbae82e85e14ded973f28772c82432e5025f68b4dde5f";
       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 = "1";
       editedCabalFile = "7009bf56e8594ddf59fcc5ac896d56f3928ba06eebfaf9e456c5298471138e5a";
       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" = 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 = "1";
       editedCabalFile = "3fc10600ed0d309c095024b4d320ace8d39dd883e4e8d109d182930c2b35fc9c";
       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
       ];
       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, 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 = "2.1";
       sha256 = "d8941910e88ad921a6337dd635356203137b85e5153a460b0b6bb3ebb0fd51b0";
       revision = "2";
       editedCabalFile = "f7407e5c0227a4fae2090ae9a10d4f4b62b869c56432a9ecb8bc8daf453a6cf8";
       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
         ghc-prim haskeline hoopl hpc hspec old-locale old-time pretty
         QuickCheck quickcheck-instances random semigroups tagged
         template-haskell terminfo 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;
     }) {};

  "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";
       libraryHaskellDepends = [ base containers syb template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       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";
       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.0";
       sha256 = "6d48e9007275c6ff3ce01c35f89a106110878e65c67c654f3432c3c3d6b9e02f";
       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.4";
       sha256 = "e334bcdb0a09c590b161df6cfe8e79bfd3b5f798711e83705e9d7c6e9dd1eaad";
       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, process
     , text, time, transformers, websockets
     }:
     mkDerivation {
       pname = "tidal";
       version = "0.6";
       sha256 = "c82a1b123f9fb831d086642f10ecd06b57e29eab4597077de8d1b82766012b67";
       libraryHaskellDepends = [
         base binary bytestring colour containers hashable hmt hosc
         mersenne-random-pure64 mtl parsec process 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;
     }) {};

  "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";
       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, heaps, HUnit, intern, loop, mtl, multiset, OptDir
     , parse-dimacs, parsec, prettyclass, primes, process
     , pseudo-boolean, queue, QuickCheck, random, sign, stm, tasty
     , tasty-hunit, tasty-quickcheck, tasty-th, temporary, time
     , type-level-numbers, unbounded-delays, unordered-containers
     , vector-space
     }:
     mkDerivation {
       pname = "toysolver";
       version = "0.3.0";
       sha256 = "28afe735180a12234c7e675f321fdf33dd7336f9c771be2ffe7201f1ebc13007";
       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 OptDir parse-dimacs parsec prettyclass primes process
         pseudo-boolean queue random sign stm temporary time
         type-level-numbers unbounded-delays unordered-containers
         vector-space
       ];
       executableHaskellDepends = [
         array base bytestring containers data-default-class filepath OptDir
         parse-dimacs parsec process pseudo-boolean random time
         unbounded-delays vector-space
       ];
       testHaskellDepends = [
         array base containers data-interval finite-field HUnit mtl OptDir
         prettyclass QuickCheck random stm tasty tasty-hunit
         tasty-quickcheck tasty-th vector-space
       ];
       jailbreak = true;
       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_1_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "transformers";
       version = "0.5.1.0";
       sha256 = "d1bd8fefc1bb73ac3bad35ade9af0919bed2be6d6734cdf959d9a31ba1e70cdd";
       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" = 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;
     }) {};

  "transformers-compat_0_5_1_4" = 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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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-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.3.0.0";
       sha256 = "7ef4f1f6892aacb43cb3539f20c661d9b11e47dc8b8d0ea9e3457a131517873a";
       revision = "1";
       editedCabalFile = "c2fb0af78c16b340f5dfeb5bf5935250a7f70b72b9b5c07416aee2c8b9138b4b";
       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" = 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;
     }) {};

  "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 ];
       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.1";
       sha256 = "be748f0f9678027b28808461ed8b69d2dea6bee67354c5f696ed843c1eaf7b3b";
       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" = 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;
     }) {};

  "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-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.0";
       sha256 = "52688cdc72f387baa0a39ca4e8cb020ec3018fab03c9da25ae1fb9693d32a1d3";
       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.0";
       sha256 = "246e8b50dbcebb5bf2c71c8827c66dc740a2e717dac4210da86308c7946c620d";
       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, base, containers, directory, file-embed, filepath
     , gitrev, mtl, optparse-applicative, parsec, text
     }:
     mkDerivation {
       pname = "typed-wire";
       version = "0.2.1.3";
       sha256 = "733ca272fee3a4e36c35e92fd34628a0db6076ea371724ce8046f8389f2cdcdc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory file-embed filepath mtl parsec text
       ];
       executableHaskellDepends = [
         base directory filepath gitrev optparse-applicative text
       ];
       homepage = "http://github.com/agrafix/typed-wire#readme";
       description = "WIP: 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 }:
     mkDerivation {
       pname = "typelevel";
       version = "1.0.2";
       sha256 = "f8d150bbf6f946dbf51e14817225b519d5c31d6bcc1a1f21d48a9418b9c2c4fa";
       libraryHaskellDepends = [ base ];
       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.2";
       sha256 = "f77b28c6e49fd36bb5369714283d72d37b8dc2f90b444e5789a5503e864d0ee7";
       revision = "1";
       editedCabalFile = "9281e38cd36593fbdd779caa5c3e678b4d4f967f496b5d3df5d55b1cd5a8a85f";
       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
       ];
       jailbreak = true;
       homepage = "https://github.com/UU-ComputerScience/uhc";
       description = "Part of UHC packaged as cabal/hackage installable library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uhc-util" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, fclabels, fgl, hashable, mtl, process, syb, time
     , time-compat, uulib
     }:
     mkDerivation {
       pname = "uhc-util";
       version = "0.1.6.3";
       sha256 = "6d64396e186a2a05a5f3a0ace58b768e83e9655b22ab3fde42d0154152358046";
       revision = "1";
       editedCabalFile = "eedc35cfdb41a84edc0a70661797a7ea98684f7b30a506309d40975370f55c0a";
       libraryHaskellDepends = [
         array base binary bytestring containers directory fclabels fgl
         hashable mtl process syb time time-compat uulib
       ];
       jailbreak = true;
       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";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-lexing deepseq network network-uri
       ];
       executableHaskellDepends = [
         async base bytestring bytestring-lexing deepseq network
         optparse-applicative
       ];
       jailbreak = true;
       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-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.9";
       sha256 = "10670c5aa26cf1c1555aa0c8f21e3edf1eca7577c9bc205c159dbf7edd6063fa";
       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";
       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" = 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;
     }) {};

  "unordered-containers_0_2_6_0" = callPackage
    ({ mkDerivation, base, ChasingBottoms, containers, deepseq
     , hashable, HUnit, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "unordered-containers";
       version = "0.2.6.0";
       sha256 = "5f9fbba5f616344bd3b1b633d45f820cf9c840ad101e1110e698abc77d9de3f3";
       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-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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "users-persistent" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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.3";
       sha256 = "12451700f85e3f7c21265698b5a799802e3a24ced34dadeecd949e2f507b4259";
       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, time, transformers }:
     mkDerivation {
       pname = "varying";
       version = "0.3.0.1";
       sha256 = "1678e5e71eb18228acba06d7b62220edd3102af620ca19107896ef65855c2aec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base time transformers ];
       executableHaskellDepends = [ base 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" = 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;
     }) {};

  "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.1.0.0";
       sha256 = "578cceeed56d13410a33663987268c85f3c54693759cb6dc4e008b3953217961";
       revision = "1";
       editedCabalFile = "c43fff776c16fd1de7f9a9c1464de4ed773634ff0ca48a6eb5e008d07f292357";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "vector-space-map" = callPackage
    ({ mkDerivation, base, containers, vector-space }:
     mkDerivation {
       pname = "vector-space-map";
       version = "0.1.0.1";
       sha256 = "0be56ed053c67ed18583f581585392aeb5161fce5b318ced882af045db81b0e8";
       libraryHaskellDepends = [ base containers vector-space ];
       jailbreak = true;
       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" = 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;
     }) {};

  "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, stm, streaming-commons, system-filepath
     , text, time, transformers, wai, warp, websockets
     }:
     mkDerivation {
       pname = "wai-devel";
       version = "0.0.0.2";
       sha256 = "2783d78ed3b5b76000182b1f51f9d2772de0460e09e02eb6be6d69127081cf9d";
       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 stm streaming-commons
         system-filepath text time transformers wai warp websockets
       ];
       executableHaskellDepends = [
         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 stm streaming-commons
         system-filepath text time transformers wai warp websockets
       ];
       testHaskellDepends = [ base hspec stm ];
       jailbreak = true;
       homepage = "https://github.com/urbanslug/wai-devel";
       description = "A web server for the development of WAI compliant web applications";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "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.3.0";
       sha256 = "2fadb84ee1f8a25d3e3d4f07bb8c92056eccf8bd3c0dabadb0a860653407f7c4";
       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 = "Route to different middlewares based on the incoming Accept header";
       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
       ];
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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, text
     , unordered-containers, uri-bytestring
     }:
     mkDerivation {
       pname = "webfinger-client";
       version = "0.1.0.0";
       sha256 = "e3b1a231ebe4bc957eddcf24a19ee5d90134b9a95984a75a945c8dc4b17a56e0";
       libraryHaskellDepends = [
         aeson base bytestring data-default-class hashable http-client
         http-client-tls http-types 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.3.3.2";
       sha256 = "828d060f58e92ce91f22e9b732abe5f8058a0592e701d4baf2abdd207b475440";
       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 mtl optparse-applicative
         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;
     }) {wlc = null;};

  "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.0";
       sha256 = "bbf461d30db337ba3e8c7519aa752d470088932189342325ca877919cb94cba1";
       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.0";
       sha256 = "6cfa37a5d13d326fadd838939df457412eb752e81877e6f128b75b8e101b50db";
       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, gtk, mtl, polyparse, text
     }:
     mkDerivation {
       pname = "xdot";
       version = "0.2.4.9";
       sha256 = "a2ace6970b425d1721b06b054422eef097837e31555579deee3fe532c11a0cda";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo graphviz gtk mtl polyparse text
       ];
       executableHaskellDepends = [ base cairo graphviz gtk text ];
       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;
     }) {};

  "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" = 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;
     }) {};

  "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 ];
       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
       ];
       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
       ];
       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";
       sha256 = "57c9f55cc7ec3450b6ae1ee4d7e8411e9ce1da147ff104fc8cc66f0e4c6924c6";
       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" = 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;
     }) {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" = 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;
     }) {};

  "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.2";
       sha256 = "867cb1a9bbbeff69bb8ae35659f780bcf057cb44a2b1f6c8e424d280a55a0fbb";
       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.18.2";
       sha256 = "298088fbccd63a323a5bab689464848cacd014ea73ef845969c898a59c022d64";
       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.10.0";
       sha256 = "f1039ae939be04bdb9480206e5029f73c95f686bdda07f81e43a218ddc653959";
       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" = 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;
     }) {};

  "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" = 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;
     }) {};

  "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;
     }) {};

  "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
       ];
       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";
       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";
       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" = callPackage
    ({ mkDerivation, base, bytestring, profunctors, zlib }:
     mkDerivation {
       pname = "zlib-lens";
       version = "0.1.2";
       sha256 = "1649c2d05f8a720804b0d380f51b854fdeea4ce9bcfe682d2e335e9faa16a1ee";
       revision = "1";
       editedCabalFile = "353e3ef6e0281894cd494b95563bb93a30ec0ff96e309a173c36bddfc4069e66";
       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;
     }) {};

}
