initial-packages.nix

  inline-c = self.callPackage (./pkgs/inline-c.nix) { };

  insert-ordered-containers = self.callPackage (./pkgs/insert-ordered-containers.nix) { };

  inspection-testing = self.callPackage (./pkgs/inspection-testing.nix) { };

  int-cast = self.callPackage (./pkgs/int-cast.nix) { };

  integer-logarithms = self.callPackage (./pkgs/integer-logarithms.nix) { };

  integration = self.callPackage (./pkgs/integration.nix) { };

  interpolate = self.callPackage (./pkgs/interpolate.nix) { };

  intervals = self.callPackage (./pkgs/intervals.nix) { };

  invariant = self.callPackage (./pkgs/invariant.nix) { };

  io-streams = self.callPackage (./pkgs/io-streams.nix) { };

  io-streams-haproxy = self.callPackage (./pkgs/io-streams-haproxy.nix) { };

  iproute = self.callPackage (./pkgs/iproute.nix) { };

  ipynb = self.callPackage (./pkgs/ipynb.nix) { };

  iso8601-time = self.callPackage (./pkgs/iso8601-time.nix) { };

  isomorphism-class = self.callPackage (./pkgs/isomorphism-class.nix) { };

  iwlib = self.callPackage (./pkgs/iwlib.nix) { };

  jailbreak-cabal = self.callPackage (./pkgs/jailbreak-cabal.nix) { };

  jira-wiki-markup = self.callPackage (./pkgs/jira-wiki-markup.nix) { };

  jose = self.callPackage (./pkgs/jose.nix) { };

  js-chart = self.callPackage (./pkgs/js-chart.nix) { };

  js-dgtable = self.callPackage (./pkgs/js-dgtable.nix) { };

  js-flot = self.callPackage (./pkgs/js-flot.nix) { };

  js-jquery = self.callPackage (./pkgs/js-jquery.nix) { };

  kan-extensions = self.callPackage (./pkgs/kan-extensions.nix) { };

  katip = self.callPackage (./pkgs/katip.nix) { };

  keys = self.callPackage (./pkgs/keys.nix) { };

  kvstore-effectful = self.callPackage (./pkgs/kvstore-effectful.nix) { };

  kvstore-effectful-cache = self.callPackage (./pkgs/kvstore-effectful-cache.nix) { };

  kvstore-effectful-spec = self.callPackage (./pkgs/kvstore-effectful-spec.nix) { };

  kvstore-effectful-statemap = self.callPackage (./pkgs/kvstore-effectful-statemap.nix) { };

  language-c = self.callPackage (./pkgs/language-c.nix) { };

  language-haskell-extract = self.callPackage (./pkgs/language-haskell-extract.nix) { };

  language-nix = self.callPackage (./pkgs/language-nix.nix) { };

  lazy-search = self.callPackage (./pkgs/lazy-search.nix) { };

  lazysmallcheck = self.callPackage (./pkgs/lazysmallcheck.nix) { };

  lens = self.callPackage (./pkgs/lens.nix) { };

  lens-aeson = self.callPackage (./pkgs/lens-aeson.nix) { };

  lens-family = self.callPackage (./pkgs/lens-family.nix) { };

  lens-family-core = self.callPackage (./pkgs/lens-family-core.nix) { };

  lens-family-th = self.callPackage (./pkgs/lens-family-th.nix) { };

  libsodium = self.callPackage (./pkgs/libsodium.nix) { };

  libsystemd-journal = self.callPackage (./pkgs/libsystemd-journal.nix) { };

  libxml = self.callPackage (./pkgs/libxml.nix) { };

  libyaml = self.callPackage (./pkgs/libyaml.nix) { };

  lift-type = self.callPackage (./pkgs/lift-type.nix) { };

  lifted-async = self.callPackage (./pkgs/lifted-async.nix) { };

  lifted-base = self.callPackage (./pkgs/lifted-base.nix) { };

  linear = self.callPackage (./pkgs/linear.nix) { };

  linear-base = self.callPackage (./pkgs/linear-base.nix) { };

  linear-generics = self.callPackage (./pkgs/linear-generics.nix) { };

  list-t = self.callPackage (./pkgs/list-t.nix) { };

  list-transformer = self.callPackage (./pkgs/list-transformer.nix) { };

  lockfree-queue = self.callPackage (./pkgs/lockfree-queue.nix) { };

  log-base = self.callPackage (./pkgs/log-base.nix) { };

  log-effectful = self.callPackage (./pkgs/log-effectful.nix) { };

  logging-facade = self.callPackage (./pkgs/logging-facade.nix) { };

  logict = self.callPackage (./pkgs/logict.nix) { };

  loop = self.callPackage (./pkgs/loop.nix) { };

  lpeg = self.callPackage (./pkgs/lpeg.nix) { };

  lrucache = self.callPackage (./pkgs/lrucache.nix) { };

  lsp = self.callPackage (./pkgs/lsp.nix) { };

  lsp-test = self.callPackage (./pkgs/lsp-test.nix) { };

  lsp-types = self.callPackage (./pkgs/lsp-types.nix) { };

  lua = self.callPackage (./pkgs/lua.nix) { };

  lua-arbitrary = self.callPackage (./pkgs/lua-arbitrary.nix) { };

  lucid = self.callPackage (./pkgs/lucid.nix) { };

  lucid-alpine = self.callPackage (./pkgs/lucid-alpine.nix) { };

  lucid-aria = self.callPackage (./pkgs/lucid-aria.nix) { };

  lucid-svg = self.callPackage (./pkgs/lucid-svg.nix) { };

  lukko = self.callPackage (./pkgs/lukko.nix) { };

  lvar = self.callPackage (./pkgs/lvar.nix) { };

  lzma = self.callPackage (./pkgs/lzma.nix) { };

  managed = self.callPackage (./pkgs/managed.nix) { };

  markdown = self.callPackage (./pkgs/markdown.nix) { };

  markdown-unlit = self.callPackage (./pkgs/markdown-unlit.nix) { };

  markov-chain-usage-model = self.callPackage (./pkgs/markov-chain-usage-model.nix) { };

  math-functions = self.callPackage (./pkgs/math-functions.nix) { };

  matrices = self.callPackage (./pkgs/matrices.nix) { };

  matrix = self.callPackage (./pkgs/matrix.nix) { };

  megaparsec = self.callPackage (./pkgs/megaparsec.nix) { };

  memory = self.callPackage (./pkgs/memory.nix) { };

  mersenne-random = self.callPackage (./pkgs/mersenne-random.nix) { };

  mersenne-random-pure64 = self.callPackage (./pkgs/mersenne-random-pure64.nix) { };

  mfsolve = self.callPackage (./pkgs/mfsolve.nix) { };

  microlens = self.callPackage (./pkgs/microlens.nix) { };

  microlens-aeson = self.callPackage (./pkgs/microlens-aeson.nix) { };

  microlens-ghc = self.callPackage (./pkgs/microlens-ghc.nix) { };

  microlens-mtl = self.callPackage (./pkgs/microlens-mtl.nix) { };

  microlens-platform = self.callPackage (./pkgs/microlens-platform.nix) { };

  microlens-th = self.callPackage (./pkgs/microlens-th.nix) { };

  microspec = self.callPackage (./pkgs/microspec.nix) { };

  microstache = self.callPackage (./pkgs/microstache.nix) { };

  mime-mail = self.callPackage (./pkgs/mime-mail.nix) { };

  mime-types = self.callPackage (./pkgs/mime-types.nix) { };

  mmap = self.callPackage (./pkgs/mmap.nix) { };

  mmark = self.callPackage (./pkgs/mmark.nix) { };

  mmorph = self.callPackage (./pkgs/mmorph.nix) { };

  mockery = self.callPackage (./pkgs/mockery.nix) { };

  mod = self.callPackage (./pkgs/mod.nix) { };

  modern-uri = self.callPackage (./pkgs/modern-uri.nix) { };

  monad-control = self.callPackage (./pkgs/monad-control.nix) { };

  monad-logger = self.callPackage (./pkgs/monad-logger.nix) { };

  monad-logger-extras = self.callPackage (./pkgs/monad-logger-extras.nix) { };

  monad-loops = self.callPackage (./pkgs/monad-loops.nix) { };

  monad-par = self.callPackage (./pkgs/monad-par.nix) { };

  monad-par-extras = self.callPackage (./pkgs/monad-par-extras.nix) { };

  monad-parallel = self.callPackage (./pkgs/monad-parallel.nix) { };

  monad-peel = self.callPackage (./pkgs/monad-peel.nix) { };

  monad-primitive = self.callPackage (./pkgs/monad-primitive.nix) { };

  monad-time = self.callPackage (./pkgs/monad-time.nix) { };

  monadlist = self.callPackage (./pkgs/monadlist.nix) { };

  monads-tf = self.callPackage (./pkgs/monads-tf.nix) { };

  mono-traversable = self.callPackage (./pkgs/mono-traversable.nix) { };

  monoid-extras = self.callPackage (./pkgs/monoid-extras.nix) { };

  monoid-subclasses = self.callPackage (./pkgs/monoid-subclasses.nix) { };

  mtl-compat = self.callPackage (./pkgs/mtl-compat.nix) { };

  mtl-prelude = self.callPackage (./pkgs/mtl-prelude.nix) { };

  multiset = self.callPackage (./pkgs/multiset.nix) { };

  mwc-random = self.callPackage (./pkgs/mwc-random.nix) { };

  mwc-random-monad = self.callPackage (./pkgs/mwc-random-monad.nix) { };

  nanospec = self.callPackage (./pkgs/nanospec.nix) { };

  nats = self.callPackage (./pkgs/nats.nix) { };

  natural-arithmetic = self.callPackage (./pkgs/natural-arithmetic.nix) { };

  natural-transformation = self.callPackage (./pkgs/natural-transformation.nix) { };

  neat-interpolation = self.callPackage (./pkgs/neat-interpolation.nix) { };

  net-mqtt = self.callPackage (./pkgs/net-mqtt.nix) { };

  network = self.callPackage (./pkgs/network.nix) { };

  network-bsd = self.callPackage (./pkgs/network-bsd.nix) { };

  network-byte-order = self.callPackage (./pkgs/network-byte-order.nix) { };

  network-conduit-tls = self.callPackage (./pkgs/network-conduit-tls.nix) { };

  network-info = self.callPackage (./pkgs/network-info.nix) { };

  network-run = self.callPackage (./pkgs/network-run.nix) { };

  network-uri = self.callPackage (./pkgs/network-uri.nix) { };

  newtype = self.callPackage (./pkgs/newtype.nix) { };

  newtype-generics = self.callPackage (./pkgs/newtype-generics.nix) { };

  nix-derivation = self.callPackage (./pkgs/nix-derivation.nix) { };

  non-negative = self.callPackage (./pkgs/non-negative.nix) { };

  nonempty-vector = self.callPackage (./pkgs/nonempty-vector.nix) { };

  nothunks = self.callPackage (./pkgs/nothunks.nix) { };

  numeric-extras = self.callPackage (./pkgs/numeric-extras.nix) { };

  numeric-prelude = self.callPackage (./pkgs/numeric-prelude.nix) { };

  numtype-dk = self.callPackage (./pkgs/numtype-dk.nix) { };

  odd-jobs = self.callPackage (./pkgs/odd-jobs.nix) { };

  old-locale = self.callPackage (./pkgs/old-locale.nix) { };

  old-time = self.callPackage (./pkgs/old-time.nix) { };

  one-liner = self.callPackage (./pkgs/one-liner.nix) { };

  openapi3 = self.callPackage (./pkgs/openapi3.nix) { };

  openssl-streams = self.callPackage (./pkgs/openssl-streams.nix) { };

  opentelemetry = self.callPackage (./pkgs/opentelemetry.nix) { };

  operational = self.callPackage (./pkgs/operational.nix) { };

  optics = self.callPackage (./pkgs/optics.nix) { };

  optics-core = self.callPackage (./pkgs/optics-core.nix) { };

  optics-extra = self.callPackage (./pkgs/optics-extra.nix) { };

  optics-th = self.callPackage (./pkgs/optics-th.nix) { };

  optional-args = self.callPackage (./pkgs/optional-args.nix) { };

  options = self.callPackage (./pkgs/options.nix) { };

  optparse-applicative = self.callPackage (./pkgs/optparse-applicative.nix) { };

  optparse-generic = self.callPackage (./pkgs/optparse-generic.nix) { };

  optparse-simple = self.callPackage (./pkgs/optparse-simple.nix) { };

  ordered-containers = self.callPackage (./pkgs/ordered-containers.nix) { };

  pager = self.callPackage (./pkgs/pager.nix) { };

  pandoc = self.callPackage (./pkgs/pandoc.nix) { };

  pandoc-lua-marshal = self.callPackage (./pkgs/pandoc-lua-marshal.nix) { };

  pandoc-types = self.callPackage (./pkgs/pandoc-types.nix) { };

  parallel = self.callPackage (./pkgs/parallel.nix) { };

  parsec = self.callPackage (./pkgs/parsec.nix) { };

  parsec-class = self.callPackage (./pkgs/parsec-class.nix) { };

  parsec-numbers = self.callPackage (./pkgs/parsec-numbers.nix) { };

  parsec1 = self.callPackage (./pkgs/parsec1.nix) { };

  parser-combinators = self.callPackage (./pkgs/parser-combinators.nix) { };

  parsers = self.callPackage (./pkgs/parsers.nix) { };

  parsers-megaparsec = self.callPackage (./pkgs/parsers-megaparsec.nix) { };

  partial-order = self.callPackage (./pkgs/partial-order.nix) { };

  password = self.callPackage (./pkgs/password.nix) { };

  password-types = self.callPackage (./pkgs/password-types.nix) { };

  path = self.callPackage (./pkgs/path.nix) { };

  path-dhall-instance = self.callPackage (./pkgs/path-dhall-instance.nix) { };

  path-io = self.callPackage (./pkgs/path-io.nix) { };

  path-pieces = self.callPackage (./pkgs/path-pieces.nix) { };

  patience = self.callPackage (./pkgs/patience.nix) { };

  pcg-random = self.callPackage (./pkgs/pcg-random.nix) { };

  pcre-heavy = self.callPackage (./pkgs/pcre-heavy.nix) { };

  pcre-light = self.callPackage (./pkgs/pcre-light.nix) { };

  pcre2 = self.callPackage (./pkgs/pcre2.nix) { };

  pem = self.callPackage (./pkgs/pem.nix) { };

  persistent = self.callPackage (./pkgs/persistent.nix) { };

  persistent-postgresql = self.callPackage (./pkgs/persistent-postgresql.nix) { };

  persistent-qq = self.callPackage (./pkgs/persistent-qq.nix) { };

  persistent-sqlite = self.callPackage (./pkgs/persistent-sqlite.nix) { };

  persistent-template = self.callPackage (./pkgs/persistent-template.nix) { };

  persistent-test = self.callPackage (./pkgs/persistent-test.nix) { };

  pg-entity = self.callPackage (./pkgs/pg-entity.nix) { };

  pg-transact = self.callPackage (./pkgs/pg-transact.nix) { };

  pg-transact-effectful = self.callPackage (./pkgs/pg-transact-effectful.nix) { };

  pgp-wordlist = self.callPackage (./pkgs/pgp-wordlist.nix) { };

  pipes = self.callPackage (./pkgs/pipes.nix) { };

  pipes-safe = self.callPackage (./pkgs/pipes-safe.nix) { };

  pointed = self.callPackage (./pkgs/pointed.nix) { };

  polyparse = self.callPackage (./pkgs/polyparse.nix) { };

  polysemy = self.callPackage (./pkgs/polysemy.nix) { };

  polysemy-extra = self.callPackage (./pkgs/polysemy-extra.nix) { };

  polysemy-kvstore = self.callPackage (./pkgs/polysemy-kvstore.nix) { };

  polysemy-methodology = self.callPackage (./pkgs/polysemy-methodology.nix) { };

  polysemy-path = self.callPackage (./pkgs/polysemy-path.nix) { };

  polysemy-plugin = self.callPackage (./pkgs/polysemy-plugin.nix) { };

  polysemy-several = self.callPackage (./pkgs/polysemy-several.nix) { };

  polysemy-test = self.callPackage (./pkgs/polysemy-test.nix) { };

  polysemy-time = self.callPackage (./pkgs/polysemy-time.nix) { };

  polysemy-vinyl = self.callPackage (./pkgs/polysemy-vinyl.nix) { };

  polysemy-zoo = self.callPackage (./pkgs/polysemy-zoo.nix) { };

  port-utils = self.callPackage (./pkgs/port-utils.nix) { };

  postgres-options = self.callPackage (./pkgs/postgres-options.nix) { };

  postgresql-libpq = self.callPackage (./pkgs/postgresql-libpq.nix) { };

  postgresql-migration = self.callPackage (./pkgs/postgresql-migration.nix) { };

  postgresql-simple = self.callPackage (./pkgs/postgresql-simple.nix) { };

  postgresql-simple-migration = self.callPackage (./pkgs/postgresql-simple-migration.nix) { };

  pqueue = self.callPackage (./pkgs/pqueue.nix) { };

  pretty-hex = self.callPackage (./pkgs/pretty-hex.nix) { };

  pretty-relative-time = self.callPackage (./pkgs/pretty-relative-time.nix) { };

  pretty-show = self.callPackage (./pkgs/pretty-show.nix) { };

  pretty-simple = self.callPackage (./pkgs/pretty-simple.nix) { };

  prettyprinter = self.callPackage (./pkgs/prettyprinter.nix) { };

  prettyprinter-ansi-terminal = self.callPackage (./pkgs/prettyprinter-ansi-terminal.nix) { };

  primes = self.callPackage (./pkgs/primes.nix) { };

  primitive = self.callPackage (./pkgs/primitive.nix) { };

  primitive-addr = self.callPackage (./pkgs/primitive-addr.nix) { };

  primitive-extras = self.callPackage (./pkgs/primitive-extras.nix) { };

  primitive-offset = self.callPackage (./pkgs/primitive-offset.nix) { };

  primitive-unlifted = self.callPackage (./pkgs/primitive-unlifted.nix) { };

  process-extras = self.callPackage (./pkgs/process-extras.nix) { };

  procex = self.callPackage (./pkgs/procex.nix) { };

  profunctors = self.callPackage (./pkgs/profunctors.nix) { };

  prometheus-client = self.callPackage (./pkgs/prometheus-client.nix) { };

  prometheus-metrics-ghc = self.callPackage (./pkgs/prometheus-metrics-ghc.nix) { };

  prometheus-proc = self.callPackage (./pkgs/prometheus-proc.nix) { };

  proteaaudio-sdl = self.callPackage (./pkgs/proteaaudio-sdl.nix) { };

  protolude = self.callPackage (./pkgs/protolude.nix) { };

  psqueues = self.callPackage (./pkgs/psqueues.nix) { };

  pureMD5 = self.callPackage (./pkgs/pureMD5.nix) { };

  quickcheck-arbitrary-adt = self.callPackage (./pkgs/quickcheck-arbitrary-adt.nix) { };

  quickcheck-assertions = self.callPackage (./pkgs/quickcheck-assertions.nix) { };

  quickcheck-classes = self.callPackage (./pkgs/quickcheck-classes.nix) { };

  quickcheck-classes-base = self.callPackage (./pkgs/quickcheck-classes-base.nix) { };

  quickcheck-instances = self.callPackage (./pkgs/quickcheck-instances.nix) { };

  quickcheck-io = self.callPackage (./pkgs/quickcheck-io.nix) { };

  quickcheck-text = self.callPackage (./pkgs/quickcheck-text.nix) { };

  quickcheck-unicode = self.callPackage (./pkgs/quickcheck-unicode.nix) { };

  quiet = self.callPackage (./pkgs/quiet.nix) { };

  ral = self.callPackage (./pkgs/ral.nix) { };

  random = self.callPackage (./pkgs/random.nix) { };

  random-bytestring = self.callPackage (./pkgs/random-bytestring.nix) { };

  random-fu = self.callPackage (./pkgs/random-fu.nix) { };

  random-shuffle = self.callPackage (./pkgs/random-shuffle.nix) { };

  raven-haskell = self.callPackage (./pkgs/raven-haskell.nix) { };

  raw-strings-qq = self.callPackage (./pkgs/raw-strings-qq.nix) { };

  rdtsc = self.callPackage (./pkgs/rdtsc.nix) { };

  readable = self.callPackage (./pkgs/readable.nix) { };

  rebase = self.callPackage (./pkgs/rebase.nix) { };

  recursion-schemes = self.callPackage (./pkgs/recursion-schemes.nix) { };

  recv = self.callPackage (./pkgs/recv.nix) { };

  reducers = self.callPackage (./pkgs/reducers.nix) { };

  ref-tf = self.callPackage (./pkgs/ref-tf.nix) { };

  refact = self.callPackage (./pkgs/refact.nix) { };

  refined = self.callPackage (./pkgs/refined.nix) { };

  reflection = self.callPackage (./pkgs/reflection.nix) { };

  regex-applicative = self.callPackage (./pkgs/regex-applicative.nix) { };

  regex-base = self.callPackage (./pkgs/regex-base.nix) { };

  regex-compat = self.callPackage (./pkgs/regex-compat.nix) { };

  regex-pcre-builtin = self.callPackage (./pkgs/regex-pcre-builtin.nix) { };

  regex-posix = self.callPackage (./pkgs/regex-posix.nix) { };

  regex-tdfa = self.callPackage (./pkgs/regex-tdfa.nix) { };

  relude = self.callPackage (./pkgs/relude.nix) { };

  replace-megaparsec = self.callPackage (./pkgs/replace-megaparsec.nix) { };

  repline = self.callPackage (./pkgs/repline.nix) { };

  rere = self.callPackage (./pkgs/rere.nix) { };

  rerebase = self.callPackage (./pkgs/rerebase.nix) { };

  resolv = self.callPackage (./pkgs/resolv.nix) { };

  resource-pool = self.callPackage (./pkgs/resource-pool.nix) { };

  resourcet = self.callPackage (./pkgs/resourcet.nix) { };

  retrie = self.callPackage (./pkgs/retrie.nix) { };

  retry = self.callPackage (./pkgs/retry.nix) { };

  rope-utf16-splay = self.callPackage (./pkgs/rope-utf16-splay.nix) { };

  row-types = self.callPackage (./pkgs/row-types.nix) { };

  rvar = self.callPackage (./pkgs/rvar.nix) { };

  safe = self.callPackage (./pkgs/safe.nix) { };

  safe-coloured-text = self.callPackage (./pkgs/safe-coloured-text.nix) { };

  safe-coloured-text-layout = self.callPackage (./pkgs/safe-coloured-text-layout.nix) { };

  safe-coloured-text-terminfo = self.callPackage (./pkgs/safe-coloured-text-terminfo.nix) { };

  safe-exceptions = self.callPackage (./pkgs/safe-exceptions.nix) { };

  saltine = self.callPackage (./pkgs/saltine.nix) { };

  sandwich = self.callPackage (./pkgs/sandwich.nix) { };

  say = self.callPackage (./pkgs/say.nix) { };

  scientific = self.callPackage (./pkgs/scientific.nix) { };

  scotty = self.callPackage (./pkgs/scotty.nix) { };

  sdl2 = self.callPackage (./pkgs/sdl2.nix) { };

  sdl2-gfx = self.callPackage (./pkgs/sdl2-gfx.nix) { };

  sdl2-image = self.callPackage (./pkgs/sdl2-image.nix) { };

  sdl2-mixer = self.callPackage (./pkgs/sdl2-mixer.nix) { };

  sdl2-ttf = self.callPackage (./pkgs/sdl2-ttf.nix) { };

  selective = self.callPackage (./pkgs/selective.nix) { };

  semialign = self.callPackage (./pkgs/semialign.nix) { };

  semigroupoids = self.callPackage (./pkgs/semigroupoids.nix) { };

  semigroups = self.callPackage (./pkgs/semigroups.nix) { };

  semirings = self.callPackage (./pkgs/semirings.nix) { };

  semver = self.callPackage (./pkgs/semver.nix) { };

  serialise = self.callPackage (./pkgs/serialise.nix) { };

  servant = self.callPackage (./pkgs/servant.nix) { };

  servant-auth = self.callPackage (./pkgs/servant-auth.nix) { };

  servant-auth-client = self.callPackage (./pkgs/servant-auth-client.nix) { };

  servant-auth-server = self.callPackage (./pkgs/servant-auth-server.nix) { };

  servant-blaze = self.callPackage (./pkgs/servant-blaze.nix) { };

  servant-client = self.callPackage (./pkgs/servant-client.nix) { };

  servant-client-core = self.callPackage (./pkgs/servant-client-core.nix) { };

  servant-docs = self.callPackage (./pkgs/servant-docs.nix) { };

  servant-effectful = self.callPackage (./pkgs/servant-effectful.nix) { };

  servant-foreign = self.callPackage (./pkgs/servant-foreign.nix) { };

  servant-lucid = self.callPackage (./pkgs/servant-lucid.nix) { };

  servant-multipart = self.callPackage (./pkgs/servant-multipart.nix) { };

  servant-multipart-api = self.callPackage (./pkgs/servant-multipart-api.nix) { };

  servant-openapi3 = self.callPackage (./pkgs/servant-openapi3.nix) { };

  servant-server = self.callPackage (./pkgs/servant-server.nix) { };

  servant-static-th = self.callPackage (./pkgs/servant-static-th.nix) { };

  servant-swagger = self.callPackage (./pkgs/servant-swagger.nix) { };

  servant-swagger-ui = self.callPackage (./pkgs/servant-swagger-ui.nix) { };

  servant-swagger-ui-core = self.callPackage (./pkgs/servant-swagger-ui-core.nix) { };

  servant-websockets = self.callPackage (./pkgs/servant-websockets.nix) { };

  setenv = self.callPackage (./pkgs/setenv.nix) { };

  setlocale = self.callPackage (./pkgs/setlocale.nix) { };

  shake = self.callPackage (./pkgs/shake.nix) { };

  shake-bench = self.callPackage (./pkgs/shake-bench.nix) { };

  shakespeare = self.callPackage (./pkgs/shakespeare.nix) { };

  shelly = self.callPackage (./pkgs/shelly.nix) { };

  shh = self.callPackage (./pkgs/shh.nix) { };

  should-not-typecheck = self.callPackage (./pkgs/should-not-typecheck.nix) { };

  show-combinators = self.callPackage (./pkgs/show-combinators.nix) { };

  silently = self.callPackage (./pkgs/silently.nix) { };

  simple-reflect = self.callPackage (./pkgs/simple-reflect.nix) { };

  simple-sendfile = self.callPackage (./pkgs/simple-sendfile.nix) { };

  singleton-bool = self.callPackage (./pkgs/singleton-bool.nix) { };

  singletons = self.callPackage (./pkgs/singletons.nix) { };

  size-based = self.callPackage (./pkgs/size-based.nix) { };

  skylighting = self.callPackage (./pkgs/skylighting.nix) { };

  skylighting-core = self.callPackage (./pkgs/skylighting-core.nix) { };

  skylighting-format-ansi = self.callPackage (./pkgs/skylighting-format-ansi.nix) { };

  skylighting-format-blaze-html = self.callPackage (./pkgs/skylighting-format-blaze-html.nix) { };

  skylighting-format-context = self.callPackage (./pkgs/skylighting-format-context.nix) { };

  skylighting-format-latex = self.callPackage (./pkgs/skylighting-format-latex.nix) { };

  slugify = self.callPackage (./pkgs/slugify.nix) { };

  smallcheck = self.callPackage (./pkgs/smallcheck.nix) { };

  snap-core = self.callPackage (./pkgs/snap-core.nix) { };

  snap-server = self.callPackage (./pkgs/snap-server.nix) { };

  socks = self.callPackage (./pkgs/socks.nix) { };

  some = self.callPackage (./pkgs/some.nix) { };

  sop-core = self.callPackage (./pkgs/sop-core.nix) { };

  sort = self.callPackage (./pkgs/sort.nix) { };

  sorted-list = self.callPackage (./pkgs/sorted-list.nix) { };

  souffle-haskell = self.callPackage (./pkgs/souffle-haskell.nix) { };

  special-values = self.callPackage (./pkgs/special-values.nix) { };

  split = self.callPackage (./pkgs/split.nix) { };

  splitmix = self.callPackage (./pkgs/splitmix.nix) { };

  spoon = self.callPackage (./pkgs/spoon.nix) { };

  sqlite-simple = self.callPackage (./pkgs/sqlite-simple.nix) { };

  statestack = self.callPackage (./pkgs/statestack.nix) { };

  statistics = self.callPackage (./pkgs/statistics.nix) { };

  statistics-linreg = self.callPackage (./pkgs/statistics-linreg.nix) { };

  stm-chans = self.callPackage (./pkgs/stm-chans.nix) { };

  stm-containers = self.callPackage (./pkgs/stm-containers.nix) { };

  stm-hamt = self.callPackage (./pkgs/stm-hamt.nix) { };

  storable-record = self.callPackage (./pkgs/storable-record.nix) { };

  storable-tuple = self.callPackage (./pkgs/storable-tuple.nix) { };

  store = self.callPackage (./pkgs/store.nix) { };

  store-core = self.callPackage (./pkgs/store-core.nix) { };

  streaming = self.callPackage (./pkgs/streaming.nix) { };

  streaming-binary = self.callPackage (./pkgs/streaming-binary.nix) { };

  streaming-bytestring = self.callPackage (./pkgs/streaming-bytestring.nix) { };

  streaming-commons = self.callPackage (./pkgs/streaming-commons.nix) { };

  streamly = self.callPackage (./pkgs/streamly.nix) { };

  streamly-core = self.callPackage (./pkgs/streamly-core.nix) { };

  strict = self.callPackage (./pkgs/strict.nix) { };

  strict-list = self.callPackage (./pkgs/strict-list.nix) { };

  string-conv = self.callPackage (./pkgs/string-conv.nix) { };

  string-conversions = self.callPackage (./pkgs/string-conversions.nix) { };

  string-interpolate = self.callPackage (./pkgs/string-interpolate.nix) { };

  string-qq = self.callPackage (./pkgs/string-qq.nix) { };

  stringbuilder = self.callPackage (./pkgs/stringbuilder.nix) { };

  stringsearch = self.callPackage (./pkgs/stringsearch.nix) { };

  sundown = self.callPackage (./pkgs/sundown.nix) { };

  svg-builder = self.callPackage (./pkgs/svg-builder.nix) { };

  swagger2 = self.callPackage (./pkgs/swagger2.nix) { };

  syb = self.callPackage (./pkgs/syb.nix) { };

  sydtest = self.callPackage (./pkgs/sydtest.nix) { };

  sydtest-discover = self.callPackage (./pkgs/sydtest-discover.nix) { };

  system-fileio = self.callPackage (./pkgs/system-fileio.nix) { };

  system-filepath = self.callPackage (./pkgs/system-filepath.nix) { };

  tabular = self.callPackage (./pkgs/tabular.nix) { };

  tagged = self.callPackage (./pkgs/tagged.nix) { };

  tagsoup = self.callPackage (./pkgs/tagsoup.nix) { };

  tar = self.callPackage (./pkgs/tar.nix) { };

  tasty = self.callPackage (./pkgs/tasty.nix) { };

  tasty-bench = self.callPackage (./pkgs/tasty-bench.nix) { };

  tasty-discover = self.callPackage (./pkgs/tasty-discover.nix) { };

  tasty-expected-failure = self.callPackage (./pkgs/tasty-expected-failure.nix) { };

  tasty-golden = self.callPackage (./pkgs/tasty-golden.nix) { };

  tasty-hedgehog = self.callPackage (./pkgs/tasty-hedgehog.nix) { };

  tasty-hslua = self.callPackage (./pkgs/tasty-hslua.nix) { };

  tasty-hspec = self.callPackage (./pkgs/tasty-hspec.nix) { };

  tasty-hunit = self.callPackage (./pkgs/tasty-hunit.nix) { };

  tasty-inspection-testing = self.callPackage (./pkgs/tasty-inspection-testing.nix) { };

  tasty-kat = self.callPackage (./pkgs/tasty-kat.nix) { };

  tasty-lua = self.callPackage (./pkgs/tasty-lua.nix) { };

  tasty-quickcheck = self.callPackage (./pkgs/tasty-quickcheck.nix) { };

  tasty-rerun = self.callPackage (./pkgs/tasty-rerun.nix) { };

  tasty-silver = self.callPackage (./pkgs/tasty-silver.nix) { };

  tasty-smallcheck = self.callPackage (./pkgs/tasty-smallcheck.nix) { };

  tasty-th = self.callPackage (./pkgs/tasty-th.nix) { };

  tasty-wai = self.callPackage (./pkgs/tasty-wai.nix) { };

  tdigest = self.callPackage (./pkgs/tdigest.nix) { };

  temporary = self.callPackage (./pkgs/temporary.nix) { };

  terminal-size = self.callPackage (./pkgs/terminal-size.nix) { };

  test-framework = self.callPackage (./pkgs/test-framework.nix) { };

  test-framework-hunit = self.callPackage (./pkgs/test-framework-hunit.nix) { };

  test-framework-quickcheck2 = self.callPackage (./pkgs/test-framework-quickcheck2.nix) { };

  test-framework-smallcheck = self.callPackage (./pkgs/test-framework-smallcheck.nix) { };

  test-framework-th = self.callPackage (./pkgs/test-framework-th.nix) { };

  testing-feat = self.callPackage (./pkgs/testing-feat.nix) { };

  testing-type-modifiers = self.callPackage (./pkgs/testing-type-modifiers.nix) { };

  texmath = self.callPackage (./pkgs/texmath.nix) { };

  text-ansi = self.callPackage (./pkgs/text-ansi.nix) { };

  text-builder = self.callPackage (./pkgs/text-builder.nix) { };

  text-builder-dev = self.callPackage (./pkgs/text-builder-dev.nix) { };

  text-conversions = self.callPackage (./pkgs/text-conversions.nix) { };

  text-display = self.callPackage (./pkgs/text-display.nix) { };

  text-icu = self.callPackage (./pkgs/text-icu.nix) { };

  text-manipulate = self.callPackage (./pkgs/text-manipulate.nix) { };

  text-metrics = self.callPackage (./pkgs/text-metrics.nix) { };

  text-rope = self.callPackage (./pkgs/text-rope.nix) { };

  text-short = self.callPackage (./pkgs/text-short.nix) { };

  text-zipper = self.callPackage (./pkgs/text-zipper.nix) { };

  tf-random = self.callPackage (./pkgs/tf-random.nix) { };

  th-abstraction = self.callPackage (./pkgs/th-abstraction.nix) { };

  th-compat = self.callPackage (./pkgs/th-compat.nix) { };

  th-desugar = self.callPackage (./pkgs/th-desugar.nix) { };

  th-env = self.callPackage (./pkgs/th-env.nix) { };

  th-expand-syns = self.callPackage (./pkgs/th-expand-syns.nix) { };

  th-extras = self.callPackage (./pkgs/th-extras.nix) { };

  th-lift = self.callPackage (./pkgs/th-lift.nix) { };

  th-lift-instances = self.callPackage (./pkgs/th-lift-instances.nix) { };

  th-orphans = self.callPackage (./pkgs/th-orphans.nix) { };

  th-reify-many = self.callPackage (./pkgs/th-reify-many.nix) { };

  th-utilities = self.callPackage (./pkgs/th-utilities.nix) { };

  these = self.callPackage (./pkgs/these.nix) { };

  these-skinny = self.callPackage (./pkgs/these-skinny.nix) { };

  threads = self.callPackage (./pkgs/threads.nix) { };

  tidal = self.callPackage (./pkgs/tidal.nix) { };

  tidal-link = self.callPackage (./pkgs/tidal-link.nix) { };

  time-compat = self.callPackage (./pkgs/time-compat.nix) { };

  time-effectful = self.callPackage (./pkgs/time-effectful.nix) { };

  time-locale-compat = self.callPackage (./pkgs/time-locale-compat.nix) { };

  time-manager = self.callPackage (./pkgs/time-manager.nix) { };

  time-units = self.callPackage (./pkgs/time-units.nix) { };

  timeit = self.callPackage (./pkgs/timeit.nix) { };

  timing-convenience = self.callPackage (./pkgs/timing-convenience.nix) { };

  tls = self.callPackage (./pkgs/tls.nix) { };

  tls-session-manager = self.callPackage (./pkgs/tls-session-manager.nix) { };

  tmp-postgres = self.callPackage (./pkgs/tmp-postgres.nix) { };

  torsor = self.callPackage (./pkgs/torsor.nix) { };

  transformers-base = self.callPackage (./pkgs/transformers-base.nix) { };

  transformers-compat = self.callPackage (./pkgs/transformers-compat.nix) { };

  transformers-except = self.callPackage (./pkgs/transformers-except.nix) { };

  tree-diff = self.callPackage (./pkgs/tree-diff.nix) { };

  trifecta = self.callPackage (./pkgs/trifecta.nix) { };

  tuple = self.callPackage (./pkgs/tuple.nix) { };

  turtle = self.callPackage (./pkgs/turtle.nix) { };

  type-equality = self.callPackage (./pkgs/type-equality.nix) { };

  type-errors = self.callPackage (./pkgs/type-errors.nix) { };

  type-errors-pretty = self.callPackage (./pkgs/type-errors-pretty.nix) { };

  typed-process = self.callPackage (./pkgs/typed-process.nix) { };

  typerep-map = self.callPackage (./pkgs/typerep-map.nix) { };

  uglymemo = self.callPackage (./pkgs/uglymemo.nix) { };

  unagi-chan = self.callPackage (./pkgs/unagi-chan.nix) { };

  unbounded-delays = self.callPackage (./pkgs/unbounded-delays.nix) { };

  unicode-collation = self.callPackage (./pkgs/unicode-collation.nix) { };

  unicode-data = self.callPackage (./pkgs/unicode-data.nix) { };

  unicode-transforms = self.callPackage (./pkgs/unicode-transforms.nix) { };

  uniplate = self.callPackage (./pkgs/uniplate.nix) { };

  universe-base = self.callPackage (./pkgs/universe-base.nix) { };

  universe-reverse-instances = self.callPackage (./pkgs/universe-reverse-instances.nix) { };

  unix-bytestring = self.callPackage (./pkgs/unix-bytestring.nix) { };

  unix-compat = self.callPackage (./pkgs/unix-compat.nix) { };

  unix-memory = self.callPackage (./pkgs/unix-memory.nix) { };

  unix-time = self.callPackage (./pkgs/unix-time.nix) { };

  unliftio = self.callPackage (./pkgs/unliftio.nix) { };

  unliftio-core = self.callPackage (./pkgs/unliftio-core.nix) { };

  unordered-containers = self.callPackage (./pkgs/unordered-containers.nix) { };

  uri-bytestring = self.callPackage (./pkgs/uri-bytestring.nix) { };

  uri-encode = self.callPackage (./pkgs/uri-encode.nix) { };

  url-slug = self.callPackage (./pkgs/url-slug.nix) { };

  utf8-string = self.callPackage (./pkgs/utf8-string.nix) { };

  utility-ht = self.callPackage (./pkgs/utility-ht.nix) { };

  uuid = self.callPackage (./pkgs/uuid.nix) { };