diff --git a/CHANGES.markdown b/CHANGES.markdown
--- a/CHANGES.markdown
+++ b/CHANGES.markdown
@@ -1,3 +1,103 @@
+## Changes in 0.9.4 [2026.01.10]
+ - Allow building with MicroHs.
+
+## Changes in 0.9.3 [2024.12.06]
+ - Backport new instances from GHC 9.12/`base-4.21`:
+   * `MonadFix` instance for `(,) a`
+   * `Eq1`, `Ord1`, `Read1`, and `Show1` instances for basic `GHC.Generics`
+     representation types
+   * `Show` instance for `UAddr`
+ - Drop support for pre-8.0 versions of GHC.
+
+## Changes in 0.9.2 [2024.04.30]
+ - Backport new instances from GHC 9.10/`base-4.20`:
+   * `Fractional`, `RealFrac`, `Floating`, and `RealFloat` instances for `Compose`
+
+## Changes in 0.9.1 [2023.10.11]
+ - Backport new instances from GHC 9.8/`base-4.19`:
+   * `Eq` and `Ord` instances for `SChar`, `SNat`, and `SSymbol`
+   * `Enum`, `Bounded`, `Num`, `Real`, and `Integral` instances for `Compose`
+
+## Changes in 0.9.0 [2023.03.05]
+ - Adapt to recent changes to `Down` instances:
+   * The `Bounded` instance for `Down` was changed in `base-4.15.0.0` to swap
+     the values of `minBound` and `maxBound` for the underlying type. This
+     change has now been propagated to `base-orphans`.
+   * The `Enum` instance for `Down` was removed in `base-4.15.0.0`, but a
+     different version of the instance was added back in `base-4.18.0.0`, where
+     `succ` and `pred` are swapped. We have changed the backported version of
+     this instance in `base-orphans` to match the behavior of the instance
+     added in `base-4.18.0.0`.
+   * The `Integral` instance for `Down` was removed from `base` entirely in
+     `base-4.15.0.0`. We have finally removed it from `base-orphans` in this
+     release, as it actively makes it more difficult to define the
+     aforementioned `Enum` instance.
+
+## Changes in 0.8.8.1 [2023.03.05]
+ - Fix GHC 9.4 build error that was accidentally introduced in
+   `base-orphans-0.8.8`.
+
+## Changes in 0.8.8 [2023.03.05]
+ - Backport new instances from GHC 9.6.1/`base-4.18.0.0`:
+   * `Functor` instances for the `(,,,,) a b c d`, `(,,,,,) a b c d e`, and
+     `(,,,,,) a b c d e f` tuple types.
+   * `Eq` and `Ord` instances for `Generically1`
+
+## Changes in 0.8.7 [2022.08.11]
+ - Backport new instances from GHC 9.2.2/`base-4.16.1.0`:
+   * `Ix` instances for various integral types in `Foreign.C.Types`,
+     `Foreign.Ptr`, and `System.Posix.Types`. For a complete list of such types,
+     see https://gitlab.haskell.org/ghc/ghc/-/merge_requests/7385.
+ - Backport a bugfix for the `Ord1 Down` instance from GHC 9.4/`base-4.17` such
+   that it now uses reverse sort order.
+
+## Changes in 0.8.6 [2021.10.29]
+ - Backport `Eq`, `Ord`, `Bounded`, `Enum`, and `Ix` instances for `Solo`,
+   introduced in GHC 9.2/`base-4.16`
+ - Remove the backported `Eq1` and `Ord1` instances for `Fixed` that were
+   introduced in `base-orphans-0.8.5`. While these briefly appeared in a
+   release candidate version of GHC 9.2.1, they were ultimately removed from
+   the final 9.2.1 release. This release of `base-orphans` synchronizes with
+   that change.
+
+## Changes in 0.8.5 [2021.08.29]
+ - Backport new instances from GHC 9.2/`base-4.16`
+   * `Eq1`, `Read1`, and `Show1` instances for `Complex`
+   * `Eq1` and `Ord1` instances for `Fixed`
+   * `Eq{1,2}`, `Ord{1,2}`, `Show{1,2}`, and `Read{1,2}` instances for `(,,)`
+      and `(,,,)`
+   * `Semigroup` and `Monoid` instances for `Data.Functor.Product` and
+     `Data.Functor.Compose`
+
+## Changes in 0.8.4 [2020.12.09]
+ - Backport the `Ord` instances for `TyCon` and `TypeRep` to be available on
+   GHC 7.0.
+
+## Changes in 0.8.3 [2020.09.30]
+ - Backport new instances from GHC 9.0/`base-4.15`
+   * `MonadFix` and `MonadZip` instances for `Complex`
+   * `Ix` instances for tuples of size 6 through 15
+
+## Changes in 0.8.2 [2020.01.27]
+ - Backport new instances from GHC 8.10/`base-4.14`
+   * `Bits`, `Bounded`, `Enum`, `FiniteBits`, `Floating`, `Fractional`,
+     `Integral`, `Ix`, `Real`, `RealFrac`, `RealFloat` and `Storable` instances
+     for `Data.Ord.Down`
+   * `Functor`, `Applicative`, `Monad`, `Alternative`, and `MonadPlus` instances
+     for `Kleisli`
+   * `Functor`, `Applicative`, and `Monad` instances for
+     `(,,) a b` and `(,,,) a b c`
+   * `Data` instances for `WrappedArrow` and `WrappedMonad`
+   * `Data` and `IsList` instances for `ZipList`
+   * `TestEquality` instance for `Compose`
+ - Backport the `Typeable (() :: Constraint)` instance to be available on
+   GHC 7.8.
+
+## Changes in 0.8.1 [2019.03.25]
+ - Ensure that the test suite passes non-negative numbers to `Bits` methods
+   that require them, such as `bit`, `setBit`, `clearBit`, `complementBit`,
+   and `testBit`.
+
 ## Changes in 0.8 [2018.07.02]
  - Backported new instance from GHC 8.6/`base-4.12`
    * Data types in `GHC.Generics`:
diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -3,7 +3,7 @@
 [![Hackage Dependencies](https://img.shields.io/hackage-deps/v/base-orphans.svg)](http://packdeps.haskellers.com/reverse/base-orphans)
 [![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)][Haskell.org]
 [![BSD3 License](http://img.shields.io/badge/license-MIT-brightgreen.svg)][tl;dr Legal: MIT]
-[![Build](https://img.shields.io/travis/haskell-compat/base-orphans.svg)](https://travis-ci.org/haskell-compat/base-orphans)
+[![Build Status](https://github.com/haskell-compat/base-orphans/workflows/Haskell-CI/badge.svg)](https://github.com/haskell-compat/base-orphans/actions?query=workflow%3AHaskell-CI)
 
 [Hackage: base-orphans]:
   http://hackage.haskell.org/package/base-orphans
@@ -35,9 +35,11 @@
  * `Alternative`, `Applicative`, `Bounded`, `Data`, `Enum`, `Foldable`, `Functor`, `Ix`, `Monad`, `MonadFix`, `MonadPlus`, `MonadZip`, and `Traversable` instances for data types in `GHC.Generics`
  * `Alternative`, `Eq`, `Ord`, `Read`, `Show`, `Foldable`, and `Traversable` instances for `ZipList`
  * `Applicative` instance for `K1` from `GHC.Generics`
- * `Applicative`, `Data`, `Eq1`, `Foldable`, `Functor`, `Ord1`, `Monad`,
-   `MonadFix`, `MonadZip`, `Monoid`, `Num`, `Read`, `Read1`, `Semigroup`,
-   `Show`, `Show1`, and `Traversable` instances for `Down`
+ * `Applicative`, `Bits`, `Bounded`, `Data`, `Enum`, `Eq1`, `FiniteBits`,
+   `Floating`, `Foldable`, `Fractional`, `Functor`, `Ix`, `Ord1`,
+   `Monad`, `MonadFix`, `MonadZip`, `Monoid`, `Num`, `Read`, `Read1`, `Real`,
+   `RealFloat`, `RealFrac`, `Semigroup`, `Show`, `Show1`, `Storable`, and
+   `Traversable` instances for `Down`
  * `Applicative` and `Alternative` instances for `ReadP` and `ReadPrec`
  * `Applicative` instance for strict and lazy `ST`
  * `Applicative`, `Foldable`, `Functor`, `Monad`, and `Traversable` instances for `Complex`,
@@ -45,20 +47,38 @@
  * `Bits` instance for `Bool`
  * `Bits`, `Bounded`, and `Integral` instances for `CDev`
  * `Bits`, `Bounded`, `Enum`, `FiniteBits`, `Floating`, `Fractional`, `Integral`, `IsString`, `Ix`, `Num`, `Real`, `RealFloat`, `RealFrac`, and `Storable` instances for `Const` and `Identity`
- * `Data` instances for `All`, `Any`, and `Const`, `IntPtr`, and `WordPtr`
+ * `Data` instances for `All`, `Any`, and `Const`, `IntPtr`, `WordPtr`,
+   `WrappedArrow` and `WrappedMonad`
  * `Data`, `MonadFix` and `MonadZip` instances for `Alt`, `Dual`, `First`, `Last`,
    `Product`, and `Sum`
- * `Data` and `IsList` instances for `Version`
+ * `Data` and `IsList` instances for `Version` and `ZipList`
+ * `Eq{1,2}`, `Ord{1,2}`, `Show{1,2}`, and `Read{1,2}` instances for `(,,)` and `(,,,)`
  * `Eq` and `Ord` instances for `Control.Exception.ErrorCall`
  * `Eq`, `Ord`, `Read`, and `Show` instances for data types in `GHC.Generics`
+ * `Eq`, `Ord`, `Bounded`, `Enum`, and `Ix` instances for `Solo`
+ * `Eq` and `Ord` instances for `Generically1`
+ * `Eq` and `Ord` instances for `SChar`, `SNat`, and `SSymbol`
+ * `Eq1`, `Read1`, and `Show1` instances for `Complex`
  * `Eq1`, `Ord1`, `Read1`, and `Show1` instances for `NonEmpty`
+ * `Eq1`, `Ord1`, `Read1`, and `Show1` instances for basic `GHC.Generics` representation types
+ * `Enum`, `Bounded`, `Num`, `Real`, `Integral`, `Fractional`, `RealFrac`, `Floating`, and `RealFloat` instances for `Compose`
  * `Foldable` instance for `Either`, `(,)` and `Const`
  * `Foldable` and `Traversable` instances for `Alt` from `Data.Monoid`
+ * `Functor`, `Applicative`, and `Monad` instances for
+   `(,,) a b` and `(,,,) a b c`
+ * `Functor` instances for `(,,,,) a b c d`, `(,,,,,) a b c d e`, and
+   `(,,,,,) a b c d e f`
  * `Functor` instance for `Handler`, `ArgOrder`, `OptDescr`, and `ArgDescr`
  * `Functor`, `Applicative`, `Alternative`, and `MonadPlus` instances for `ArrowMonad`
+ * `Functor`, `Applicative`, `Monad`, `Alternative`, and `MonadPlus` instances
+   for `Kleisli`
+ * `Ix` instances for tuples of size 6 through 15
+ * `Ix` instances for integral types in `Foreign.C.Types`, `Foreign.Ptr`, and `System.Posix.Types`
  * `Monad` instance for `(,)`
  * `Monad` instance for `WrappedMonad`
  * `MonadFail`, `Monoid`, and `Semigroup` instances for strict `ST`
+ * `MonadFix` instance for `(,) a`
+ * `MonadFix` and `MonadZip` instances for `Complex`
  * `MonadZip` instance for `Maybe`
  * `Monoid`, `Eq`, `Ord`, `Read`, and `Show` instances for `Const`
  * `Monoid` instances for `Identity` and `IO`
@@ -67,9 +87,13 @@
  * `Semigroup` instances for `IO`, `Event` and `Lifetime`
  * `Semigroup` instances for `V1`, `U1`, `Par1`, `Rec1`, `K1`, `M1`, `(:*:)`, and `(:.:)` from `GHC.Generics`.
    `Monoid` instances for the same types (except `V1`).
+ * `Semigroup` and `Monoid` instances for `Data.Functor.Product` and `Data.Functor.Compose`
  * `Show` instance for `Fingerprint`
+ * `Show` instance for `UAddr`
  * `Storable` instance for `()`, `Complex`, and `Ratio`
+ * `TestEquality` instance for `Compose`
  * `Traversable` instance for `Either`, `(,)` and `Const`
+ * `Ord` instance for `TyCon` and `TypeRep`.
  * `Typeable` instance for most data types, typeclasses, and promoted data constructors (when possible)
 
 ## What is not covered
@@ -85,32 +109,19 @@
 
 ## Supported versions of GHC/`base`
 
- * `ghc-8.6.1`  / `base-4.12.0.0`
- * `ghc-8.4.3`  / `base-4.11.1.0`
- * `ghc-8.4.2`  / `base-4.11.1.0`
- * `ghc-8.4.1`  / `base-4.11.0.0`
- * `ghc-8.2.2`  / `base-4.10.1.0`
- * `ghc-8.2.1`  / `base-4.10.0.0`
- * `ghc-8.0.2`  / `base-4.9.1.0`
- * `ghc-8.0.1`  / `base-4.9.0.0`
- * `ghc-7.10.3` / `base-4.8.2.0`
- * `ghc-7.10.2` / `base-4.8.1.0`
- * `ghc-7.10.1` / `base-4.8.0.0`
- * `ghc-7.8.4`  / `base-4.7.0.2`
- * `ghc-7.8.3`  / `base-4.7.0.1`
- * `ghc-7.8.2`  / `base-4.7.0.0`
- * `ghc-7.8.1`  / `base-4.7.0.0`
- * `ghc-7.6.3`  / `base-4.6.0.1`
- * `ghc-7.6.2`  / `base-4.6.0.1`
- * `ghc-7.6.1`  / `base-4.6.0.0`
- * `ghc-7.4.2`  / `base-4.5.1.0`
- * `ghc-7.4.1`  / `base-4.5.0.0`
- * `ghc-7.2.2`  / `base-4.4.1.0`
- * `ghc-7.2.1`  / `base-4.4.0.0`
- * `ghc-7.0.4`  / `base-4.3.1.0`
- * `ghc-7.0.3`  / `base-4.3.1.0`
- * `ghc-7.0.2`  / `base-4.3.1.0`
- * `ghc-7.0.1`  / `base-4.3.0.0`
+ * `ghc-9.12.*` / `base-4.21.*`
+ * `ghc-9.10.*` / `base-4.20.*`
+ * `ghc-9.8.*`  / `base-4.19.*`
+ * `ghc-9.6.*`  / `base-4.18.*`
+ * `ghc-9.4.*`  / `base-4.17.*`
+ * `ghc-9.2.*`  / `base-4.16.*`
+ * `ghc-9.0.*`  / `base-4.15.*`
+ * `ghc-8.10.*` / `base-4.14.*`
+ * `ghc-8.8.*`  / `base-4.13.*`
+ * `ghc-8.6.*`  / `base-4.12.*`
+ * `ghc-8.4.*`  / `base-4.11.*`
+ * `ghc-8.2.*`  / `base-4.10.*`
+ * `ghc-8.0.*`  / `base-4.9.*`
 
 We also make an attempt to keep `base-orphans` building with GHC HEAD, but due
 to its volatility, it may not work at any given point in time. If it doesn't,
diff --git a/base-orphans.cabal b/base-orphans.cabal
--- a/base-orphans.cabal
+++ b/base-orphans.cabal
@@ -1,14 +1,25 @@
--- This file has been generated from package.yaml by hpack version 0.28.2.
+cabal-version: 1.12
+
+-- This file has been generated from package.yaml by hpack version 0.39.1.
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: f7b54386bbe16442a11779267f4a728967659e625e63acc7a4a4a9d07cfd302f
+-- hash: 459819c97f970a9f10f930c19a33ad7c14c34c1056852f4b0c57fa8e8487e8ca
 
 name:                base-orphans
-version:             0.8
+version:             0.9.4
 synopsis:            Backwards-compatible orphan instances for base
-description:         @base-orphans@ defines orphan instances that mimic instances available in later versions of @base@ to a wider (older) range of compilers. @base-orphans@ does not export anything except the orphan instances themselves and complements @<http://hackage.haskell.org/package/base-compat base-compat>@.
-                     See the README for what instances are covered: <https://github.com/haskell-compat/base-orphans#readme>. See also the <https://github.com/haskell-compat/base-orphans#what-is-not-covered what is not covered> section.
+description:         @base-orphans@ defines orphan instances that mimic instances available in
+                     later versions of @base@ to a wider (older) range of compilers.
+                     @base-orphans@ does not export anything except the orphan instances
+                     themselves and complements @<http://hackage.haskell.org/package/base-compat
+                     base-compat>@.
+                     .
+                     See the README for what instances are covered:
+                     <https://github.com/haskell-compat/base-orphans#readme>.
+                     See also the
+                     <https://github.com/haskell-compat/base-orphans#what-is-not-covered what is not covered>
+                     section.
 category:            Compatibility
 homepage:            https://github.com/haskell-compat/base-orphans#readme
 bug-reports:         https://github.com/haskell-compat/base-orphans/issues
@@ -24,8 +35,8 @@
 license:             MIT
 license-file:        LICENSE
 build-type:          Simple
-cabal-version:       >= 1.10
-tested-with:         GHC == 7.0.1,  GHC == 7.0.2,  GHC == 7.0.3,  GHC == 7.0.4 , GHC == 7.2.1,  GHC == 7.2.2 , GHC == 7.4.1,  GHC == 7.4.2 , GHC == 7.6.1,  GHC == 7.6.2,  GHC == 7.6.3 , GHC == 7.8.1,  GHC == 7.8.2,  GHC == 7.8.3,  GHC == 7.8.4 , GHC == 7.10.1, GHC == 7.10.2, GHC == 7.10.3 , GHC == 8.0.1,  GHC == 8.0.2 , GHC == 8.2.1,  GHC == 8.2.2 , GHC == 8.4.1,  GHC == 8.4.2,  GHC == 8.4.3 , GHC == 8.6.1
+tested-with:
+    GHC == 8.0.2 , GHC == 8.2.2 , GHC == 8.4.4 , GHC == 8.6.5 , GHC == 8.8.4 , GHC == 8.10.7 , GHC == 9.0.2 , GHC == 9.2.8 , GHC == 9.4.8 , GHC == 9.6.7 , GHC == 9.8.4 , GHC == 9.10.3 , GHC == 9.12.2 , GHC == 9.14.1
 extra-source-files:
     CHANGES.markdown
     README.markdown
@@ -39,13 +50,15 @@
       src
   ghc-options: -Wall
   build-depends:
-      base >=4.3 && <5
-    , ghc-prim
+      base >=4.9 && <5
   exposed-modules:
       Data.Orphans
   other-modules:
       Data.Orphans.Prelude
   default-language: Haskell2010
+  if impl(ghc >= 9.0) && !impl(ghc >= 9.2)
+    build-depends:
+        ghc-prim
 
 test-suite spec
   type: exitcode-stdio-1.0
@@ -55,7 +68,7 @@
   ghc-options: -Wall
   build-depends:
       QuickCheck
-    , base >=4.3 && <5
+    , base >=4.9 && <5
     , base-orphans
     , hspec ==2.*
   build-tool-depends: hspec-discover:hspec-discover == 2.*
diff --git a/src/Data/Orphans.hs b/src/Data/Orphans.hs
--- a/src/Data/Orphans.hs
+++ b/src/Data/Orphans.hs
@@ -1,1710 +1,1523 @@
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE DeriveDataTypeable #-}
-{-# LANGUAGE DeriveFoldable #-}
-{-# LANGUAGE DeriveFunctor #-}
-{-# LANGUAGE DeriveTraversable #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE KindSignatures #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE TypeOperators #-}
-
-#if __GLASGOW_HASKELL__ >= 702
-{-# LANGUAGE Trustworthy #-}
-#endif
-
-#if __GLASGOW_HASKELL__ >= 706
-{-# LANGUAGE PolyKinds #-}
-#endif
-
-#if __GLASGOW_HASKELL__ >= 708 && __GLASGOW_HASKELL__ < 710
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE NullaryTypeClasses #-}
-#endif
-
-#if __GLASGOW_HASKELL__ >= 800
-{-# LANGUAGE TypeInType #-}
-#endif
-
-{-# OPTIONS_GHC -fno-warn-deprecations #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-{-|
-Exports orphan instances that mimic instances available in later versions of @base@.
-To use them, simply @import Data.Orphans ()@.
--}
-module Data.Orphans () where
-
-#if __GLASGOW_HASKELL__ >= 701 && !(MIN_VERSION_base(4,12,0))
-import           GHC.Generics as Generics
-#endif
-
-#if !(MIN_VERSION_base(4,6,0))
-import           Control.Monad.Instances ()
-#endif
-
-#if !(MIN_VERSION_base(4,9,0))
-import qualified Data.Monoid as Monoid
-import           Text.ParserCombinators.ReadPrec as ReadPrec
-import           Text.Read as Read
-#endif
-
-#if MIN_VERSION_base(4,9,0) && !(MIN_VERSION_base(4,11,0))
-import qualified Control.Monad.Fail as Fail (MonadFail(..))
-#endif
-
-#if !(MIN_VERSION_base(4,10,0))
-import           Data.Data as Data
-#endif
-
-#if !(MIN_VERSION_base(4,11,0))
-import           Control.Monad.ST as Strict
-#endif
-
-#if !(MIN_VERSION_base(4,12,0))
-import qualified Data.Foldable as F (Foldable(..))
-import qualified Data.Traversable as T (Traversable(..))
-#endif
-
-#if __GLASGOW_HASKELL__ < 710
-import           Control.Exception as Exception
-import           Control.Monad.ST.Lazy as Lazy
-import           GHC.Exts as Exts
-import           GHC.IO.Exception as Exception
-import           Text.ParserCombinators.ReadP as ReadP
-
-# if defined(mingw32_HOST_OS)
-import           GHC.ConsoleHandler as Console
-# endif
-#endif
-
-#if !(MIN_VERSION_base(4,12,0))
-import           Data.Orphans.Prelude
-#endif
-
-#include "HsBaseConfig.h"
-
--------------------------------------------------------------------------------
-
-#if MIN_VERSION_base(4,4,0) && !(MIN_VERSION_base(4,7,0))
-instance Show Fingerprint where
-    show (Fingerprint w1 w2) = hex16 w1 ++ hex16 w2
-      where
-        -- Formats a 64 bit number as 16 digits hex.
-        hex16 :: Word64 -> String
-        hex16 i = let hex = showHex i ""
-                   in replicate (16 - length hex) '0' ++ hex
-#endif
-
-#if !(MIN_VERSION_base(4,4,0))
-instance HasResolution a => Read (Fixed a) where
-    readsPrec _ = readsFixed
-
-readsFixed :: (HasResolution a) => ReadS (Fixed a)
-readsFixed = readsSigned
-    where readsSigned ('-' : xs) = [ (negate x, rest)
-                                   | (x, rest) <- readsUnsigned xs ]
-          readsSigned xs = readsUnsigned xs
-          readsUnsigned xs = case span isDigit xs of
-                             ([], _) -> []
-                             (is, xs') ->
-                                 let i = fromInteger (read is)
-                                 in case xs' of
-                                    '.' : xs'' ->
-                                        case span isDigit xs'' of
-                                        ([], _) -> []
-                                        (js, xs''') ->
-                                            let j = fromInteger (read js)
-                                                l = genericLength js :: Integer
-                                            in [(i + (j / (10 ^ l)), xs''')]
-                                    _ -> [(i, xs')]
-
-deriving instance Typeable1 SampleVar
-
-instance Applicative (Strict.ST s) where
-    pure  = return
-    (<*>) = ap
-
-instance Applicative (Lazy.ST s) where
-    pure  = return
-    (<*>) = ap
-#endif
-
--- These instances are only valid if Bits isn't a subclass of Num (as Bool is
--- not a Num instance), which is only true as of base-4.6.0.0 and later.
-#if MIN_VERSION_base(4,6,0) && !(MIN_VERSION_base(4,7,0))
-instance Bits Bool where
-    (.&.) = (&&)
-
-    (.|.) = (||)
-
-    xor = (/=)
-
-    complement = not
-
-    shift x 0 = x
-    shift _ _ = False
-
-    rotate x _ = x
-
-    bit 0 = True
-    bit _ = False
-
-    testBit x 0 = x
-    testBit _ _ = False
-
-    bitSize _ = 1
-
-    isSigned _ = False
-
-    popCount False = 0
-    popCount True  = 1
-#endif
-
-#if !(MIN_VERSION_base(4,6,0))
-# if defined(HTYPE_DEV_T)
-#  if MIN_VERSION_base(4,5,0)
-deriving instance Bits CDev
-deriving instance Bounded CDev
-deriving instance Integral CDev
-#  else
-type HDev = HTYPE_DEV_T
-
-instance Bits CDev where
-    (.&.)         = unsafeCoerce ((.&.)         :: HDev -> HDev -> HDev)
-    (.|.)         = unsafeCoerce ((.|.)         :: HDev -> HDev -> HDev)
-    xor           = unsafeCoerce (xor           :: HDev -> HDev -> HDev)
-    shift         = unsafeCoerce (shift         :: HDev -> Int  -> HDev)
-    rotate        = unsafeCoerce (rotate        :: HDev -> Int  -> HDev)
-    setBit        = unsafeCoerce (setBit        :: HDev -> Int  -> HDev)
-    clearBit      = unsafeCoerce (clearBit      :: HDev -> Int  -> HDev)
-    complementBit = unsafeCoerce (complementBit :: HDev -> Int  -> HDev)
-    testBit       = unsafeCoerce (testBit       :: HDev -> Int  -> Bool)
-    complement    = unsafeCoerce (complement    :: HDev -> HDev)
-    bit           = unsafeCoerce (bit           :: Int  -> HDev)
-    bitSize       = unsafeCoerce (bitSize       :: HDev -> Int)
-    isSigned      = unsafeCoerce (isSigned      :: HDev -> Bool)
-
-instance Bounded CDev where
-    minBound = unsafeCoerce (minBound :: HDev)
-    maxBound = unsafeCoerce (maxBound :: HDev)
-
-instance Integral CDev where
-    quot      = unsafeCoerce (quot      :: HDev -> HDev -> HDev)
-    rem       = unsafeCoerce (rem       :: HDev -> HDev -> HDev)
-    div       = unsafeCoerce (div       :: HDev -> HDev -> HDev)
-    mod       = unsafeCoerce (mod       :: HDev -> HDev -> HDev)
-    quotRem   = unsafeCoerce (quotRem   :: HDev -> HDev -> (HDev, HDev))
-    divMod    = unsafeCoerce (divMod    :: HDev -> HDev -> (HDev, HDev))
-    toInteger = unsafeCoerce (toInteger :: HDev -> Integer)
-#  endif
-# endif
-
-instance Applicative ReadP where
-    pure  = return
-    (<*>) = ap
-
-instance Alternative ReadP where
-    empty = mzero
-    (<|>) = mplus
-
-instance Applicative ReadPrec where
-    pure  = return
-    (<*>) = ap
-
-instance Alternative ReadPrec where
-    empty = mzero
-    (<|>) = mplus
-
-instance Functor Exception.Handler where
-     fmap f (Exception.Handler h) = Exception.Handler (fmap f . h)
-
-instance
-# if MIN_VERSION_base(4,4,0)
-  Arrow a
-# else
-  ArrowApply a
-# endif
-  => Functor (ArrowMonad a) where
-    fmap f (ArrowMonad m) = ArrowMonad $ m >>> arr f
-
-instance
-# if MIN_VERSION_base(4,4,0)
-  Arrow a
-# else
-  ArrowApply a
-# endif
-  => Applicative (ArrowMonad a) where
-   pure x = ArrowMonad (arr (const x))
-   ArrowMonad f <*> ArrowMonad x = ArrowMonad (f &&& x >>> arr (uncurry id))
-
-instance
-# if MIN_VERSION_base(4,4,0)
-  ArrowPlus a
-# else
-  (ArrowApply a, ArrowPlus a)
-# endif
-  => Alternative (ArrowMonad a) where
-   empty = ArrowMonad zeroArrow
-   ArrowMonad x <|> ArrowMonad y = ArrowMonad (x <+> y)
-
-instance (ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) where
-   mzero = ArrowMonad zeroArrow
-   ArrowMonad x `mplus` ArrowMonad y = ArrowMonad (x <+> y)
-#endif
-
-#if !(MIN_VERSION_base(4,7,0))
-deriving instance F.Foldable (Const m)
-deriving instance F.Foldable (Either a)
-deriving instance T.Traversable (Const m)
-deriving instance T.Traversable (Either a)
-
-instance F.Foldable ((,) a) where
-    foldMap f (_, y) = f y
-
-    foldr f z (_, y) = f y z
-
-instance T.Traversable ((,) a) where
-    traverse f (x, y) = (,) x <$> f y
-
-deriving instance Monoid a => Monoid (Const a b)
-deriving instance Read a => Read (Down a)
-deriving instance Show a => Show (Down a)
-deriving instance Eq ErrorCall
-deriving instance Ord ErrorCall
-deriving instance Num a => Num (Sum a)
-deriving instance Num a => Num (Product a)
-deriving instance Data Version
--- GHC Trac #8218
-deriving instance Monad m => Monad (WrappedMonad m)
-deriving instance Eq a => Eq (ZipList a)
-deriving instance Ord a => Ord (ZipList a)
-deriving instance Read a => Read (ZipList a)
-deriving instance Show a => Show (ZipList a)
-deriving instance Functor ArgOrder
-deriving instance Functor OptDescr
-deriving instance Functor ArgDescr
-#endif
-
-#if __GLASGOW_HASKELL__ >= 701 && !(MIN_VERSION_base(4,7,0))
-deriving instance Eq (U1 p)
-deriving instance Ord (U1 p)
-deriving instance Read (U1 p)
-deriving instance Show (U1 p)
-
-deriving instance Eq p => Eq (Par1 p)
-deriving instance Ord p => Ord (Par1 p)
-deriving instance Read p => Read (Par1 p)
-deriving instance Show p => Show (Par1 p)
-
-deriving instance Eq (f p) => Eq (Rec1 f p)
-deriving instance Ord (f p) => Ord (Rec1 f p)
-deriving instance Read (f p) => Read (Rec1 f p)
-deriving instance Show (f p) => Show (Rec1 f p)
-
-deriving instance Eq c => Eq (K1 i c p)
-deriving instance Ord c => Ord (K1 i c p)
-deriving instance Read c => Read (K1 i c p)
-deriving instance Show c => Show (K1 i c p)
-
-deriving instance Eq (f p) => Eq (M1 i c f p)
-deriving instance Ord (f p) => Ord (M1 i c f p)
-deriving instance Read (f p) => Read (M1 i c f p)
-deriving instance Show (f p) => Show (M1 i c f p)
-
-deriving instance (Eq (f p), Eq (g p)) => Eq ((f :+: g) p)
-deriving instance (Ord (f p), Ord (g p)) => Ord ((f :+: g) p)
-deriving instance (Read (f p), Read (g p)) => Read ((f :+: g) p)
-deriving instance (Show (f p), Show (g p)) => Show ((f :+: g) p)
-
-deriving instance (Eq (f p), Eq (g p)) => Eq ((f :*: g) p)
-deriving instance (Ord (f p), Ord (g p)) => Ord ((f :*: g) p)
--- Due to a GHC bug (https://ghc.haskell.org/trac/ghc/ticket/9830), the derived
--- Read and Show instances for infix data constructors will use the wrong
--- precedence (prior to GHC 7.10).
--- We'll manually derive Read :*: and Show :*: instances to avoid this.
-instance (Read (f p), Read (g p)) => Read ((f :*: g) p) where
-    readPrec = parens . ReadPrec.prec 6 $ do
-        fp <- ReadPrec.step readPrec
-        Symbol ":*:" <- lexP
-        gp <- ReadPrec.step readPrec
-        return $ fp :*: gp
-    readListPrec = readListPrecDefault
-instance (Show (f p), Show (g p)) => Show ((f :*: g) p) where
-     showsPrec p (l :*: r) = showParen (p > sixPrec) $
-            showsPrec (sixPrec + 1) l
-         . showString " :*: "
-         . showsPrec (sixPrec + 1) r
-       where sixPrec = 6
-
-deriving instance Eq (f (g p)) => Eq ((f :.: g) p)
-deriving instance Ord (f (g p)) => Ord ((f :.: g) p)
-deriving instance Read (f (g p)) => Read ((f :.: g) p)
-deriving instance Show (f (g p)) => Show ((f :.: g) p)
-#endif
-
-#if MIN_VERSION_base(4,7,0) && !(MIN_VERSION_base(4,8,0))
--- | Construct tag-less 'Version'
---
--- /Since: 4.8.0.0/
-makeVersion :: [Int] -> Version
-makeVersion b = Version b []
-
--- | /Since: 4.8.0.0/
-instance IsList Version where
-  type (Item Version) = Int
-  fromList = makeVersion
-  toList = versionBranch
-#endif
-
-#if !(MIN_VERSION_base(4,8,0))
-deriving instance Eq a => Eq (Const a b)
-deriving instance Ord a => Ord (Const a b)
-
-instance Read a => Read (Const a b) where
-    readsPrec d = readParen (d > 10)
-        $ \r -> [(Const x,t) | ("Const", s) <- lex r, (x, t) <- readsPrec 11 s]
-
-instance Show a => Show (Const a b) where
-    showsPrec d (Const x) = showParen (d > 10) $
-                            showString "Const " . showsPrec 11 x
-
-deriving instance Functor First
-deriving instance Applicative First
-deriving instance Monad First
-deriving instance Functor Last
-deriving instance Applicative Last
-deriving instance Monad Last
-
--- In base-4.3 and earlier, pattern matching on a Complex value invokes a
--- RealFloat constraint due to the use of the DatatypeContexts extension.
-# if MIN_VERSION_base(4,4,0)
-instance Storable a
-# else
-instance (Storable a, RealFloat a)
-# endif
-  => Storable (Complex a) where
-    sizeOf a       = 2 * sizeOf (realPart a)
-    alignment a    = alignment (realPart a)
-    peek p           = do
-                        q <- return $ castPtr p
-                        r <- peek q
-                        i <- peekElemOff q 1
-                        return (r :+ i)
-    poke p (r :+ i)  = do
-                        q <-return $  (castPtr p)
-                        poke q r
-                        pokeElemOff q 1 i
-
-instance (Storable a, Integral a) => Storable (Ratio a) where
-    sizeOf _    = 2 * sizeOf (undefined :: a)
-    alignment _ = alignment (undefined :: a )
-    peek p           = do
-                        q <- return $ castPtr p
-                        r <- peek q
-                        i <- peekElemOff q 1
-                        return (r % i)
-    poke p (r :% i)  = do
-                        q <-return $  (castPtr p)
-                        poke q r
-                        pokeElemOff q 1 i
-#endif
-
-#if !(MIN_VERSION_base(4,9,0))
-instance Storable () where
-  sizeOf _ = 0
-  alignment _ = 1
-  peek _ = return ()
-  poke _ _ = return ()
-
-deriving instance Bits a       => Bits (Const a b)
-deriving instance Bounded a    => Bounded (Const a b)
-deriving instance Enum a       => Enum (Const a b)
-deriving instance Floating a   => Floating (Const a b)
-deriving instance Fractional a => Fractional (Const a b)
-deriving instance Integral a   => Integral (Const a b)
-deriving instance IsString a   => IsString (Const a b)
-deriving instance Ix a         => Ix (Const a b)
-deriving instance Num a        => Num (Const a b)
-deriving instance Real a       => Real (Const a b)
-deriving instance RealFloat a  => RealFloat (Const a b)
-deriving instance RealFrac a   => RealFrac (Const a b)
-deriving instance Storable a   => Storable (Const a b)
-
-deriving instance           Data All
-deriving instance           Data Monoid.Any
-deriving instance Data a => Data (Dual a)
-deriving instance Data a => Data (First a)
-deriving instance Data a => Data (Last a)
-deriving instance Data a => Data (Product a)
-deriving instance Data a => Data (Sum a)
-
-instance F.Foldable Dual where
-    foldMap            = coerce
-
-    foldl              = coerce
-    foldl1 _           = getDual
-    foldr f z (Dual x) = f x z
-    foldr1 _           = getDual
-# if MIN_VERSION_base(4,6,0)
-    foldl'             = coerce
-    foldr'             = F.foldr
-# endif
-# if MIN_VERSION_base(4,8,0)
-    elem               = (. getDual) #. (==)
-    length _           = 1
-    maximum            = getDual
-    minimum            = getDual
-    null _             = False
-    product            = getDual
-    sum                = getDual
-    toList (Dual x)    = [x]
-# endif
-
-instance F.Foldable Sum where
-    foldMap            = coerce
-
-    foldl              = coerce
-    foldl1 _           = getSum
-    foldr f z (Sum x)  = f x z
-    foldr1 _           = getSum
-# if MIN_VERSION_base(4,6,0)
-    foldl'                = coerce
-    foldr'                = F.foldr
-# endif
-# if MIN_VERSION_base(4,8,0)
-    elem               = (. getSum) #. (==)
-    length _           = 1
-    maximum            = getSum
-    minimum            = getSum
-    null _             = False
-    product            = getSum
-    sum                = getSum
-    toList (Sum x)     = [x]
-# endif
-
-instance F.Foldable Product where
-    foldMap               = coerce
-
-    foldl                 = coerce
-    foldl1 _              = getProduct
-    foldr f z (Product x) = f x z
-    foldr1 _              = getProduct
-# if MIN_VERSION_base(4,6,0)
-    foldl'                = coerce
-    foldr'                = F.foldr
-# endif
-# if MIN_VERSION_base(4,8,0)
-    elem                  = (. getProduct) #. (==)
-    length _              = 1
-    maximum               = getProduct
-    minimum               = getProduct
-    null _                = False
-    product               = getProduct
-    sum                   = getProduct
-    toList (Product x)    = [x]
-# endif
-
-# if MIN_VERSION_base(4,8,0)
-(#.)   :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c)
-(#.) _f = coerce
-# endif
-
-# if !(MIN_VERSION_base(4,7,0))
-coerce ::                  a -> b
-coerce = unsafeCoerce
-# endif
-
-instance Functor Dual where
-    fmap     = coerce
-
-instance Applicative Dual where
-    pure     = Dual
-    (<*>)    = coerce
-
-instance Monad Dual where
-    return   = Dual
-    m >>= k  = k (getDual m)
-
-instance Functor Sum where
-    fmap     = coerce
-
-instance Applicative Sum where
-    pure     = Sum
-    (<*>)    = coerce
-
-instance Monad Sum where
-    return   = Sum
-    m >>= k  = k (getSum m)
-
-instance Functor Product where
-    fmap     = coerce
-
-instance Applicative Product where
-    pure     = Product
-    (<*>)    = coerce
-
-instance Monad Product where
-    return   = Product
-    m >>= k  = k (getProduct m)
-
-instance F.Foldable First where
-    foldMap f = F.foldMap f . getFirst
-
-instance F.Foldable Last where
-    foldMap f = F.foldMap f . getLast
-
-instance Monoid a => Monoid (IO a) where
-    mempty = pure mempty
-    mappend = liftA2 mappend
-
--- see: #10190 https://git.haskell.org/ghc.git/commitdiff/9db005a444722e31aca1956b058e069bcf3cacbd
-instance Monoid a => Monad ((,) a) where
-    return x = (mempty, x)
-    (u, a) >>= k = case k a of (v, b) -> (u `mappend` v, b)
-
-instance MonadFix Dual where
-    mfix f   = Dual (fix (getDual . f))
-
-instance MonadFix Sum where
-    mfix f   = Sum (fix (getSum . f))
-
-instance MonadFix Product where
-    mfix f   = Product (fix (getProduct . f))
-
-instance MonadFix First where
-    mfix f   = First (mfix (getFirst . f))
-
-instance MonadFix Last where
-    mfix f   = Last (mfix (getLast . f))
-
-instance T.Traversable Dual where
-    traverse f (Dual x) = Dual <$> f x
-
-instance T.Traversable Sum where
-    traverse f (Sum x) = Sum <$> f x
-
-instance T.Traversable Product where
-    traverse f (Product x) = Product <$> f x
-
-instance T.Traversable First where
-    traverse f (First x) = First <$> T.traverse f x
-
-instance T.Traversable Last where
-    traverse f (Last x) = Last <$> T.traverse f x
-
-deriving instance F.Foldable    ZipList
-deriving instance T.Traversable ZipList
-
-# if MIN_VERSION_base(4,4,0)
-deriving instance Functor     Complex
-deriving instance F.Foldable    Complex
-deriving instance T.Traversable Complex
-
-instance Applicative Complex where
-  pure a = a :+ a
-  f :+ g <*> a :+ b = f a :+ g b
-
-instance Monad Complex where
-  return a = a :+ a
-  a :+ b >>= f = realPart (f a) :+ imagPart (f b)
-
-instance MonadZip Dual where
-    -- Cannot use coerce, it's unsafe
-    mzipWith = liftM2
-
-instance MonadZip Sum where
-    mzipWith = liftM2
-
-instance MonadZip Product where
-    mzipWith = liftM2
-
-instance MonadZip Maybe where
-    mzipWith = liftM2
-
-instance MonadZip First where
-    mzipWith = liftM2
-
-instance MonadZip Last where
-    mzipWith = liftM2
-# endif
-
-# if MIN_VERSION_base(4,7,0)
-instance Alternative Proxy where
-    empty = Proxy
-    {-# INLINE empty #-}
-    _ <|> _ = Proxy
-    {-# INLINE (<|>) #-}
-
-instance MonadPlus Proxy where
-#  if !(MIN_VERSION_base(4,8,0))
-    mzero = Proxy
-    {-# INLINE mzero #-}
-    mplus _ _ = Proxy
-    {-# INLINE mplus #-}
-#  endif
-
-instance MonadZip Proxy where
-    mzipWith _ _ _ = Proxy
-    {-# INLINE mzipWith #-}
-
-deriving instance FiniteBits a => FiniteBits (Const a b)
-# endif
-
-# if MIN_VERSION_base(4,8,0)
-deriving instance (Data (f a), Typeable f, Typeable a)
-    => Data (Alt (f :: * -> *) (a :: *))
-
-instance MonadFix f => MonadFix (Alt f) where
-    mfix f   = Alt (mfix (getAlt . f))
-
-instance MonadZip f => MonadZip (Alt f) where
-    mzipWith f (Alt ma) (Alt mb) = Alt (mzipWith f ma mb)
-
-deriving instance Bits a       => Bits (Identity a)
-deriving instance Bounded a    => Bounded (Identity a)
-deriving instance Enum a       => Enum (Identity a)
-deriving instance FiniteBits a => FiniteBits (Identity a)
-deriving instance Floating a   => Floating (Identity a)
-deriving instance Fractional a => Fractional (Identity a)
-deriving instance Integral a   => Integral (Identity a)
-deriving instance IsString a   => IsString (Identity a)
-deriving instance Ix a         => Ix (Identity a)
-deriving instance Monoid a     => Monoid (Identity a)
-deriving instance Num a        => Num (Identity a)
-deriving instance Real a       => Real (Identity a)
-deriving instance RealFloat a  => RealFloat (Identity a)
-deriving instance RealFrac a   => RealFrac (Identity a)
-deriving instance Storable a   => Storable (Identity a)
-# endif
-
-# if __GLASGOW_HASKELL__ >= 701
-deriving instance Data p => Data (V1 p)
-deriving instance Data p => Data (U1 p)
-deriving instance Data p => Data (Par1 p)
-deriving instance (Typeable i, Data p, Data c) => Data (K1 i c p)
-deriving instance Data Generics.Fixity
-deriving instance Data Associativity
-
-deriving instance                                 F.Foldable V1
-deriving instance                                 F.Foldable Par1
-deriving instance F.Foldable f                 => F.Foldable (Rec1 f)
-deriving instance                                 F.Foldable (K1 i c)
-deriving instance F.Foldable f                 => F.Foldable (M1 i c f)
-deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :+: g)
-deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :*: g)
-deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :.: g)
-
-deriving instance                           Functor V1
-deriving instance                           Functor Par1
-deriving instance Functor f              => Functor (Rec1 f)
-deriving instance                           Functor (K1 i c)
-deriving instance Functor f              => Functor (M1 i c f)
-deriving instance (Functor f, Functor g) => Functor (f :+: g)
-deriving instance (Functor f, Functor g) => Functor (f :*: g)
-deriving instance (Functor f, Functor g) => Functor (f :.: g)
-
-instance MonadFix Par1 where
-    mfix f = Par1 (fix (unPar1 . f))
-
-instance MonadFix f => MonadFix (Rec1 f) where
-    mfix f = Rec1 (mfix (unRec1 . f))
-
-instance MonadFix f => MonadFix (M1 i c f) where
-    mfix f = M1 (mfix (unM1. f))
-
-instance (MonadFix f, MonadFix g) => MonadFix (f :*: g) where
-    mfix f = (mfix (fstP . f)) :*: (mfix (sndP . f))
-      where
-        fstP (a :*: _) = a
-        sndP (_ :*: b) = b
-
-instance MonadZip U1 where
-    mzipWith _ _ _ = U1
-
-instance MonadZip Par1 where
-    mzipWith = liftM2
-
-instance MonadZip f => MonadZip (Rec1 f) where
-    mzipWith f (Rec1 fa) (Rec1 fb) = Rec1 (mzipWith f fa fb)
-
-instance MonadZip f => MonadZip (M1 i c f) where
-    mzipWith f (M1 fa) (M1 fb) = M1 (mzipWith f fa fb)
-
-instance (MonadZip f, MonadZip g) => MonadZip (f :*: g) where
-    mzipWith f (x1 :*: y1) (x2 :*: y2) = mzipWith f x1 x2 :*: mzipWith f y1 y2
-
-deriving instance                                       T.Traversable V1
-deriving instance                                       T.Traversable Par1
-deriving instance T.Traversable f                    => T.Traversable (Rec1 f)
-deriving instance                                       T.Traversable (K1 i c)
-deriving instance T.Traversable f                    => T.Traversable (M1 i c f)
-deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :+: g)
-deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :*: g)
-deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :.: g)
-
-deriving instance Bounded Associativity
-deriving instance Enum    Associativity
-deriving instance Ix      Associativity
-
-deriving instance Eq   (V1 p)
-deriving instance Ord  (V1 p)
--- Implement Read instance manually to get around an old GHC bug
--- (Trac #7931)
-instance Read (V1 p) where
-    readPrec     = parens ReadPrec.pfail
-    readList     = readListDefault
-    readListPrec = readListPrecDefault
-deriving instance Show (V1 p)
-
-instance Functor U1 where
-  fmap _ _ = U1
-
-instance Applicative U1 where
-  pure _ = U1
-  _ <*> _ = U1
-
-instance Alternative U1 where
-  empty = U1
-  _ <|> _ = U1
-
-instance Monad U1 where
-#  if !(MIN_VERSION_base(4,8,0))
-  return _ = U1
-#  endif
-  _ >>= _ = U1
-
-instance MonadPlus U1 where
-#  if !(MIN_VERSION_base(4,8,0))
-  mzero = U1
-  mplus _ _ = U1
-#  endif
-
-instance F.Foldable U1 where
-    foldMap _ _ = mempty
-    {-# INLINE foldMap #-}
-    fold _ = mempty
-    {-# INLINE fold #-}
-    foldr _ z _ = z
-    {-# INLINE foldr #-}
-    foldl _ z _ = z
-    {-# INLINE foldl #-}
-    foldl1 _ _ = error "foldl1: U1"
-    foldr1 _ _ = error "foldr1: U1"
-#  if MIN_VERSION_base(4,8,0)
-    length _   = 0
-    null _     = True
-    elem _ _   = False
-    sum _      = 0
-    product _  = 1
-#  endif
-
-instance T.Traversable U1 where
-    traverse _ _ = pure U1
-    {-# INLINE traverse #-}
-    sequenceA _ = pure U1
-    {-# INLINE sequenceA #-}
-    mapM _ _ = return U1
-    {-# INLINE mapM #-}
-    sequence _ = return U1
-    {-# INLINE sequence #-}
-
-instance Applicative Par1 where
-  pure a = Par1 a
-  Par1 f <*> Par1 x = Par1 (f x)
-
-instance Monad Par1 where
-#  if !(MIN_VERSION_base(4,8,0))
-  return a = Par1 a
-#  endif
-  Par1 x >>= f = f x
-
-instance Applicative f => Applicative (Rec1 f) where
-  pure a = Rec1 (pure a)
-  Rec1 f <*> Rec1 x = Rec1 (f <*> x)
-
-instance Alternative f => Alternative (Rec1 f) where
-  empty = Rec1 empty
-  Rec1 l <|> Rec1 r = Rec1 (l <|> r)
-
-instance Monad f => Monad (Rec1 f) where
-#  if !(MIN_VERSION_base(4,8,0))
-  return a = Rec1 (return a)
-#  endif
-  Rec1 x >>= f = Rec1 (x >>= \a -> unRec1 (f a))
-
-instance MonadPlus f => MonadPlus (Rec1 f) where
-#  if !(MIN_VERSION_base(4,8,0))
-  mzero = Rec1 mzero
-  mplus (Rec1 a) (Rec1 b) = Rec1 (mplus a b)
-#  endif
-
-instance Applicative f => Applicative (M1 i c f) where
-  pure a = M1 (pure a)
-  M1 f <*> M1 x = M1 (f <*> x)
-
-instance Alternative f => Alternative (M1 i c f) where
-  empty = M1 empty
-  M1 l <|> M1 r = M1 (l <|> r)
-
-instance Monad f => Monad (M1 i c f) where
-#  if !(MIN_VERSION_base(4,8,0))
-  return a = M1 (return a)
-#  endif
-  M1 x >>= f = M1 (x >>= \a -> unM1 (f a))
-
-instance MonadPlus f => MonadPlus (M1 i c f) where
-#  if !(MIN_VERSION_base(4,8,0))
-  mzero = M1 mzero
-  mplus (M1 a) (M1 b) = M1 (mplus a b)
-#  endif
-
-instance (Applicative f, Applicative g) => Applicative (f :*: g) where
-  pure a = pure a :*: pure a
-  (f :*: g) <*> (x :*: y) = (f <*> x) :*: (g <*> y)
-
-instance (Alternative f, Alternative g) => Alternative (f :*: g) where
-  empty = empty :*: empty
-  (x1 :*: y1) <|> (x2 :*: y2) = (x1 <|> x2) :*: (y1 <|> y2)
-
-instance (Monad f, Monad g) => Monad (f :*: g) where
-#  if !(MIN_VERSION_base(4,8,0))
-  return a = return a :*: return a
-#  endif
-  (m :*: n) >>= f = (m >>= \a -> fstP (f a)) :*: (n >>= \a -> sndP (f a))
-    where
-      fstP (a :*: _) = a
-      sndP (_ :*: b) = b
-
-instance (MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) where
-#  if !(MIN_VERSION_base(4,8,0))
-  mzero = mzero :*: mzero
-  (x1 :*: y1) `mplus` (x2 :*: y2) =  (x1 `mplus` x2) :*: (y1 `mplus` y2)
-#  endif
-
-instance (Applicative f, Applicative g) => Applicative (f :.: g) where
-  pure x = Comp1 (pure (pure x))
-  Comp1 f <*> Comp1 x = Comp1 (fmap (<*>) f <*> x)
-
-instance (Alternative f, Applicative g) => Alternative (f :.: g) where
-  empty = Comp1 empty
-  Comp1 x <|> Comp1 y = Comp1 (x <|> y)
-
-deriving instance (Data (f p), Typeable1 f, Data p) => Data (Rec1 f p)
-deriving instance (Data p, Data (f p), Typeable c, Typeable i, Typeable1 f)
-  => Data (M1 i c f p)
-deriving instance (Typeable1 f, Typeable1 g, Data p, Data (f p), Data (g p))
-  => Data ((f :+: g) p)
-deriving instance (Typeable1 f, Typeable1 g, Data p, Data (f p), Data (g p))
-  => Data ((f :*: g) p)
-deriving instance (Typeable1 f, Typeable1 g, Data p, Data (f (g p)))
-  => Data ((f :.: g) p)
-
-#  if MIN_VERSION_base(4,8,0)
-instance Bifunctor (K1 i) where
-    bimap f _ (K1 c) = K1 (f c)
-#  endif
-# endif
-#endif
-
-#if !(MIN_VERSION_base(4,10,0))
-# if MIN_VERSION_base(4,9,0)
-deriving instance (Typeable k, Data a, Typeable (b :: k)) => Data (Const a b)
-# else
-deriving instance (Data a, Data b) => Data (Const a b)
-# endif
-
-# if MIN_VERSION_base(4,9,0)
-instance Eq1 NonEmpty where
-  liftEq eq (a :| as) (b :| bs) = eq a b && liftEq eq as bs
-
-instance Ord1 NonEmpty where
-  liftCompare cmp (a :| as) (b :| bs) = cmp a b <> liftCompare cmp as bs
-
-instance Read1 NonEmpty where
-  liftReadsPrec rdP rdL p s = readParen (p > 5) (\s' -> do
-    (a, s'') <- rdP 6 s'
-    (":|", s''') <- lex s''
-    (as, s'''') <- rdL s'''
-    return (a :| as, s'''')) s
-
-instance Show1 NonEmpty where
-  liftShowsPrec shwP shwL p (a :| as) = showParen (p > 5) $
-    shwP 6 a . showString " :| " . shwL as
-
-instance Semigroup a => Semigroup (IO a) where
-    (<>) = liftA2 (<>)
-
-#  if !defined(mingw32_HOST_OS) && !defined(ghcjs_HOST_OS)
-instance Semigroup Event where
-    (<>) = mappend
-    stimes = stimesMonoid
-
-instance Semigroup Lifetime where
-    (<>) = mappend
-    stimes = stimesMonoid
-#  endif
-# endif
-#endif
-
-#if !(MIN_VERSION_base(4,11,0))
-instance Alternative ZipList where
-  empty = ZipList []
-  ZipList xs <|> ZipList ys = ZipList (xs ++ drop (length xs) ys)
-
-deriving instance Monoid a => Monoid (Down a)
-deriving instance Num a => Num (Down a)
-
-instance Functor Down where
-    fmap = coerce
-
-instance Applicative Down where
-    pure = Down
-    (<*>) = coerce
-
-instance Monad Down where
-    return = Down
-    Down a >>= k = k a
-
-instance Monoid a => Monoid (Strict.ST s a) where
-    mempty = pure mempty
-    mappend = liftA2 mappend
-
-# if MIN_VERSION_base(4,9,0)
-instance Fail.MonadFail (Strict.ST s) where
-    fail s = errorWithoutStackTrace s
-
-deriving instance Semigroup a => Semigroup (Down a)
-
-instance Semigroup a => Semigroup (Strict.ST s a) where
-    (<>) = liftA2 (<>)
-# endif
-
-# if MIN_VERSION_base(4,10,0)
-deriving instance Data IntPtr
-deriving instance Data WordPtr
-# else
--- The constructors for IntPtr and WordPtr aren't exposed on older versions
--- of base, so we're forced to hand-roll the Data instances here
-instance Data IntPtr where
-  gfoldl k z iptr = z intPtr `k` unIntPtr iptr
-  gunfold k z _ = k (z intPtr)
-  toConstr !_ = cIntPtr
-  dataTypeOf _ = tIntPtr
-
-intPtr :: Int -> IntPtr
-intPtr = unsafeCoerce
-
-unIntPtr :: IntPtr -> Int
-unIntPtr = unsafeCoerce
-
-tIntPtr :: DataType
-tIntPtr = mkDataType "IntPtr" [cIntPtr]
-
-cIntPtr :: Constr
-cIntPtr = mkConstr tIntPtr "IntPtr" [] Data.Prefix
-
-instance Data WordPtr where
-  gfoldl k z wptr = z wordPtr `k` unWordPtr wptr
-  gunfold k z _ = k (z wordPtr)
-  toConstr !_ = cWordPtr
-  dataTypeOf _ = tWordPtr
-
-wordPtr :: Word -> WordPtr
-wordPtr = unsafeCoerce
-
-unWordPtr :: WordPtr -> Word
-unWordPtr = unsafeCoerce
-
-tWordPtr :: DataType
-tWordPtr = mkDataType "WordPtr" [cWordPtr]
-
-cWordPtr :: Constr
-cWordPtr = mkConstr tWordPtr "WordPtr" [] Data.Prefix
-# endif
-#endif
-
-#if !(MIN_VERSION_base(4,12,0))
-instance MonadFix Down where
-    mfix f = Down (fix (getDown . f))
-      where getDown (Down x) = x
-deriving instance Data a => Data (Down a)
-deriving instance F.Foldable Down
-deriving instance T.Traversable Down
-# if MIN_VERSION_base(4,4,0)
-instance MonadZip Down where
-    mzipWith = liftM2
-# endif
-# if MIN_VERSION_base(4,9,0)
-instance Eq1 Down where
-    liftEq eq (Down x) (Down y) = eq x y
-instance Ord1 Down where
-    liftCompare comp (Down x) (Down y) = comp x y
-instance Read1 Down where
-    liftReadsPrec rp _ = readsData $
-         readsUnaryWith rp "Down" Down
-instance Show1 Down where
-    liftShowsPrec sp _ d (Down x) = showsUnaryWith sp "Down" d x
-# endif
-
-# if __GLASGOW_HASKELL__ >= 701
-instance Monoid c => Applicative (K1 i c) where
-  pure _ = K1 mempty
-  (<*>) = coerce (mappend :: c -> c -> c)
-#  if MIN_VERSION_base(4,10,0)
-  liftA2 = \_ -> coerce (mappend :: c -> c -> c)
-#  endif
-
-instance Monoid (U1 p) where
-  mempty = U1
-#  if !(MIN_VERSION_base(4,11,0))
-  _ `mappend` _ = U1
-#  endif
-deriving instance Monoid p => Monoid (Par1 p)
-deriving instance Monoid (f p) => Monoid (Rec1 f p)
-deriving instance Monoid c => Monoid (K1 i c p)
-deriving instance Monoid (f p) => Monoid (M1 i c f p)
-instance (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) where
-  mempty = mempty :*: mempty
-#  if !(MIN_VERSION_base(4,11,0))
-  (x1 :*: y1) `mappend` (x2 :*: y2) = (x1 `mappend` x2) :*: (y1 `mappend` y2)
-#  endif
-deriving instance Monoid (f (g p)) => Monoid ((f :.: g) p)
-
-#  if MIN_VERSION_base(4,9,0)
-instance Semigroup (V1 p) where
-  v <> _ = v
-instance Semigroup (U1 p) where
-  _ <> _ = U1
-deriving instance Semigroup p => Semigroup (Par1 p)
-deriving instance Semigroup (f p) => Semigroup (Rec1 f p)
-deriving instance Semigroup c => Semigroup (K1 i c p)
-deriving instance Semigroup (f p) => Semigroup (M1 i c f p)
-instance (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) where
-  (x1 :*: y1) <> (x2 :*: y2) = (x1 <> x2) :*: (y1 <> y2)
-deriving instance Semigroup (f (g p)) => Semigroup ((f :.: g) p)
-#  endif
-# endif
-
-# if MIN_VERSION_base(4,8,0)
-deriving instance Foldable f => Foldable (Alt f)
-deriving instance Traversable f => Traversable (Alt f)
-# endif
-#endif
-
-#if __GLASGOW_HASKELL__ < 710
-deriving instance Typeable  All
-deriving instance Typeable  AnnotationWrapper
-deriving instance Typeable  Monoid.Any
-deriving instance Typeable1 ArgDescr
-deriving instance Typeable1 ArgOrder
-deriving instance Typeable  BlockReason
-deriving instance Typeable1 Buffer
-deriving instance Typeable3 BufferCodec
-deriving instance Typeable1 BufferList
-deriving instance Typeable  BufferMode
-deriving instance Typeable  BufferState
-deriving instance Typeable  CFile
-deriving instance Typeable  CFpos
-deriving instance Typeable  CJmpBuf
-deriving instance Typeable2 Const
-deriving instance Typeable  Constr
-deriving instance Typeable  ConstrRep
-deriving instance Typeable  DataRep
-deriving instance Typeable  DataType
-deriving instance Typeable1 Down
-deriving instance Typeable1 Dual
-deriving instance Typeable1 Endo
-deriving instance Typeable  Errno
-deriving instance Typeable1 First
-deriving instance Typeable  Data.Fixity
-deriving instance Typeable  GeneralCategory
-deriving instance Typeable  HandlePosn
-deriving instance Typeable1 Exception.Handler
-deriving instance Typeable  HandleType
-deriving instance Typeable  IODeviceType
-deriving instance Typeable  IOErrorType
-deriving instance Typeable  IOMode
-deriving instance Typeable1 Last
-deriving instance Typeable  Lexeme
-deriving instance Typeable  Newline
-deriving instance Typeable  NewlineMode
-deriving instance Typeable  Opaque
-deriving instance Typeable1 OptDescr
-deriving instance Typeable  Pool
-deriving instance Typeable1 Product
-deriving instance Typeable1 ReadP
-deriving instance Typeable1 ReadPrec
-deriving instance Typeable  SeekMode
-deriving instance Typeable2 Lazy.ST
-deriving instance Typeable2 STret
-deriving instance Typeable1 Sum
-deriving instance Typeable  TextEncoding
-deriving instance Typeable  ThreadStatus
-deriving instance Typeable1 ZipList
-
-# if defined(mingw32_HOST_OS)
-deriving instance Typeable  CodePageArrays
-deriving instance Typeable2 CompactArray
-deriving instance Typeable1 ConvArray
-deriving instance Typeable  Console.Handler
-# endif
-
-# if MIN_VERSION_base(4,3,0)
-deriving instance Typeable  MaskingState
-# endif
-
-# if MIN_VERSION_base(4,4,0)
-deriving instance Typeable  CodingFailureMode
-deriving instance Typeable  CodingProgress
-deriving instance Typeable  Fingerprint
-
-#  if !defined(mingw32_HOST_OS) && !defined(__GHCJS__)
-deriving instance Typeable  Event
-deriving instance Typeable  EventManager
-deriving instance Typeable  FdKey
-deriving instance Typeable  TimeoutKey
-#  endif
-# endif
-
-# if __GLASGOW_HASKELL__ >= 701
-deriving instance Typeable  Arity
-deriving instance Typeable  Associativity
-deriving instance Typeable  C
-deriving instance Typeable  D
-deriving instance Typeable  Generics.Fixity
-deriving instance Typeable3 K1
-deriving instance Typeable  NoSelector
-deriving instance Typeable  P
-deriving instance Typeable1 Par1
-deriving instance Typeable  R
-deriving instance Typeable  S
-deriving instance Typeable1 U1
-deriving instance Typeable1 V1
-
-#  if __GLASGOW_HASKELL__ >= 708
--- Data types which use poly-kinded Typeable...
-deriving instance Typeable (:+:)
-deriving instance Typeable (:*:)
-deriving instance Typeable (:.:)
-deriving instance Typeable M1
-deriving instance Typeable Rec1
-#  else
--- ...but we can hack around that if need be.
-instance (Typeable1 f, Typeable1 g) => Typeable1 (f :+: g) where
-  typeOf1 t = mkTyConApp conSumTyCon [typeOf1 (f t), typeOf1 (g t)]
-    where
-      f :: (f :+: g) p -> f p
-      f = undefined
-
-      g :: (f :+: g) p -> g p
-      g = undefined
-
-conSumTyCon :: TyCon
-conSumTyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" ":+:"
-
-instance (Typeable1 f, Typeable1 g) => Typeable1 (f :*: g) where
-  typeOf1 t = mkTyConApp conProductTyCon [typeOf1 (f t), typeOf1 (g t)]
-    where
-      f :: (f :*: g) p -> f p
-      f = undefined
-
-      g :: (f :*: g) p -> g p
-      g = undefined
-
-conProductTyCon :: TyCon
-conProductTyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" ":*:"
-
-instance (Typeable1 f, Typeable1 g) => Typeable1 (f :.: g) where
-  typeOf1 t = mkTyConApp conComposeTyCon [typeOf1 (f t), typeOf1 (g t)]
-    where
-      f :: (f :.: g) p -> f p
-      f = undefined
-
-      g :: (f :.: g) p -> g p
-      g = undefined
-
-conComposeTyCon :: TyCon
-conComposeTyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" ":.:"
-
-instance (Typeable i, Typeable c, Typeable1 f) => Typeable1 (M1 i c f) where
-  typeOf1 t = mkTyConApp m1TyCon [typeOf (i t), typeOf (c t), typeOf1 (f t)]
-    where
-      i :: M1 i c f p -> i
-      i = undefined
-
-      c :: M1 i c f p -> c
-      c = undefined
-
-      f :: M1 i c f p -> f p
-      f = undefined
-
-m1TyCon :: TyCon
-m1TyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" "M1"
-
-instance Typeable1 f => Typeable1 (Rec1 f) where
-  typeOf1 t = mkTyConApp rec1TyCon [typeOf1 (f t)]
-    where
-      f :: Rec1 f a -> f a
-      f = undefined
-
-rec1TyCon :: TyCon
-rec1TyCon = mkTyCon3 ghcGenericsPackage "GHC.Generics" "Rec1"
-
-ghcGenericsPackage :: String
-#   if MIN_VERSION_base(4,6,0)
-ghcGenericsPackage = "base"
-#   else
-ghcGenericsPackage = "ghc-prim"
-#   endif
-#  endif
-# endif
-
-# if MIN_VERSION_base(4,5,0)
-deriving instance Typeable  CostCentre
-deriving instance Typeable  CostCentreStack
-deriving instance Typeable  GCStats
-# endif
-
-# if MIN_VERSION_base(4,6,0)
-deriving instance Typeable  CSigset
-deriving instance Typeable  ForeignPtrContents
-deriving instance Typeable  Nat
-deriving instance Typeable1 NoIO
-deriving instance Typeable  Symbol
-# endif
-
-# if MIN_VERSION_ghc_prim(0,3,1)
-deriving instance Typeable  SPEC
-# endif
-
-# if MIN_VERSION_base(4,7,0)
-deriving instance Typeable FieldFormat
-deriving instance Typeable FormatAdjustment
-deriving instance Typeable FormatParse
-deriving instance Typeable FormatSign
-deriving instance Typeable KProxy
-deriving instance Typeable Number
-deriving instance Typeable SomeNat
-deriving instance Typeable SomeSymbol
-deriving instance Typeable QSem -- This instance seems to have been removed
-                                -- (accidentally?) in base-4.7.0.0
-# endif
-
-# if __GLASGOW_HASKELL__ >= 708
--- Data types which use poly-kinded Typeable...
-deriving instance Typeable ArrowMonad
-deriving instance Typeable Kleisli
-deriving instance Typeable WrappedArrow
-deriving instance Typeable WrappedMonad
-deriving instance Typeable Exts.Any
-# else
--- ...but we can hack around that if need be.
-instance Typeable2 a => Typeable1 (ArrowMonad a) where
-  typeOf1 t = mkTyConApp arrowMonadTyCon [typeOf2 (a t)]
-    where
-      a :: ArrowMonad a b -> a () b
-      a = undefined
-
-arrowMonadTyCon :: TyCon
-#  if MIN_VERSION_base(4,4,0)
-arrowMonadTyCon = mkTyCon3 "base" "Control.Arrow" "ArrowMonad"
-#  else
-arrowMonadTyCon = mkTyCon "Control.Arrow.ArrowMonad"
-#  endif
-
-instance Typeable1 m => Typeable2 (Kleisli m) where
-  typeOf2 t = mkTyConApp kleisliTyCon [typeOf1 (m t)]
-    where
-      m :: Kleisli m a b -> m b
-      m = undefined
-
-kleisliTyCon :: TyCon
-#  if MIN_VERSION_base(4,4,0)
-kleisliTyCon = mkTyCon3 "base" "Control.Arrow" "Kleisli"
-#  else
-kleisliTyCon = mkTyCon "Control.Arrow.Kleisli"
-#  endif
-
-instance Typeable2 a => Typeable2 (WrappedArrow a) where
-  typeOf2 t = mkTyConApp wrappedArrowTyCon [typeOf2 (a t)]
-    where
-      a :: WrappedArrow a b c -> a b c
-      a = undefined
-
-wrappedArrowTyCon :: TyCon
-#  if MIN_VERSION_base(4,4,0)
-wrappedArrowTyCon = mkTyCon3 "base" "Control.Applicative" "WrappedArrow"
-#  else
-wrappedArrowTyCon = mkTyCon "Control.Applicative.WrappedArrow"
-#  endif
-
-instance Typeable1 m => Typeable1 (WrappedMonad m) where
-  typeOf1 t = mkTyConApp wrappedMonadTyCon [typeOf1 (m t)]
-    where
-      m :: WrappedMonad m a -> m a
-      m = undefined
-
-wrappedMonadTyCon :: TyCon
-#  if MIN_VERSION_base(4,4,0)
-wrappedMonadTyCon = mkTyCon3 "base" "Control.Applicative" "WrappedMonad"
-#  else
-wrappedMonadTyCon = mkTyCon "Control.Applicative.WrappedMonad"
-#  endif
-
--- GHC will get confused if you try deriving a Typeable instance for Any
--- prior to GHC 7.8, sadly
-instance Typeable Exts.Any where
-  typeOf _ = mkTyConApp anyTyCon []
-
-anyTyCon :: TyCon
-#  if MIN_VERSION_base(4,4,0)
-anyTyCon = mkTyCon3 "ghc-prim" "GHC.Prim" "Any"
-#  else
-anyTyCon = mkTyCon "GHC.Prim.Any"
-#  endif
-# endif
-
-# if __GLASGOW_HASKELL__ >= 708
--- Data types which have more than seven type arguments
-deriving instance Typeable (,,,,,,,)
-deriving instance Typeable (,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-
--- Typeclasses
-deriving instance Typeable Arrow
-deriving instance Typeable ArrowApply
-deriving instance Typeable ArrowChoice
-deriving instance Typeable ArrowLoop
-deriving instance Typeable ArrowZero
-deriving instance Typeable Bits
-deriving instance Typeable Bounded
-deriving instance Typeable BufferedIO
-deriving instance Typeable Category
-deriving instance Typeable Coercible
-deriving instance Typeable Constructor
-deriving instance Typeable Data
-deriving instance Typeable Datatype
-deriving instance Typeable Enum
-deriving instance Typeable Exception
-deriving instance Typeable Eq
-deriving instance Typeable FiniteBits
-deriving instance Typeable Floating
-deriving instance Typeable F.Foldable
-deriving instance Typeable Fractional
-deriving instance Typeable Functor
-deriving instance Typeable Generic
-deriving instance Typeable Generic1
-deriving instance Typeable GHCiSandboxIO
-deriving instance Typeable HasResolution
-deriving instance Typeable HPrintfType
-deriving instance Typeable Integral
-deriving instance Typeable IODevice
-deriving instance Typeable IP
-deriving instance Typeable IsChar
-deriving instance Typeable IsList
-deriving instance Typeable IsString
-deriving instance Typeable Ix
-deriving instance Typeable KnownNat
-deriving instance Typeable KnownSymbol
-deriving instance Typeable Monad
-deriving instance Typeable MonadFix
-deriving instance Typeable MonadPlus
-deriving instance Typeable MonadZip
-deriving instance Typeable Num
-deriving instance Typeable Ord
-deriving instance Typeable PrintfArg
-deriving instance Typeable PrintfType
-deriving instance Typeable RawIO
-deriving instance Typeable Read
-deriving instance Typeable Real
-deriving instance Typeable RealFloat
-deriving instance Typeable RealFrac
-deriving instance Typeable Selector
-deriving instance Typeable Show
-deriving instance Typeable Storable
-deriving instance Typeable TestCoercion
-deriving instance Typeable TestEquality
-deriving instance Typeable T.Traversable
-deriving instance Typeable Typeable
-
--- Constraints
-deriving instance Typeable (~)
-deriving instance Typeable Constraint
-
--- Promoted data constructors
-deriving instance Typeable '()
-deriving instance Typeable '(,)
-deriving instance Typeable '(,,)
-deriving instance Typeable '(,,,)
-deriving instance Typeable '(,,,,)
-deriving instance Typeable '(,,,,,)
-deriving instance Typeable '(,,,,,,)
-deriving instance Typeable '(,,,,,,,)
-deriving instance Typeable '(,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
-deriving instance Typeable '[]
-deriving instance Typeable '(:)
-deriving instance Typeable '(:%)
-deriving instance Typeable '(:+)
-deriving instance Typeable 'AbsoluteSeek
-deriving instance Typeable 'All
-deriving instance Typeable 'AlreadyExists
-deriving instance Typeable 'Monoid.Any
-deriving instance Typeable 'AppendHandle
-deriving instance Typeable 'AppendMode
-deriving instance Typeable 'BlockedIndefinitelyOnMVar
-deriving instance Typeable 'BlockedIndefinitelyOnSTM
-deriving instance Typeable 'BlockedOnBlackHole
-deriving instance Typeable 'BlockedOnException
-deriving instance Typeable 'BlockedOnForeignCall
-deriving instance Typeable 'BlockedOnMVar
-deriving instance Typeable 'BlockedOnOther
-deriving instance Typeable 'BlockedOnSTM
-deriving instance Typeable 'ClosedHandle
-deriving instance Typeable 'ClosePunctuation
-deriving instance Typeable 'ConnectorPunctuation
-deriving instance Typeable 'Const
-deriving instance Typeable 'Control
-deriving instance Typeable 'CRLF
-deriving instance Typeable 'CurrencySymbol
-deriving instance Typeable 'DashPunctuation
-deriving instance Typeable 'Deadlock
-deriving instance Typeable 'DecimalNumber
-deriving instance Typeable 'Denormal
-deriving instance Typeable 'Directory
-deriving instance Typeable 'DivideByZero
-deriving instance Typeable 'Down
-deriving instance Typeable 'Dual
-deriving instance Typeable 'EnclosingMark
-deriving instance Typeable 'Endo
-deriving instance Typeable 'Exception.EOF
-deriving instance Typeable 'EQ
-deriving instance Typeable 'ErrorOnCodingFailure
-deriving instance Typeable 'False
-deriving instance Typeable 'FinalQuote
-deriving instance Typeable 'First
-deriving instance Typeable 'ForceSpecConstr
-deriving instance Typeable 'Format
-deriving instance Typeable 'GT
-deriving instance Typeable 'HardwareFault
-deriving instance Typeable 'HeapOverflow
-deriving instance Typeable 'IgnoreCodingFailure
-deriving instance Typeable 'IllegalOperation
-deriving instance Typeable 'InappropriateType
-deriving instance Typeable 'Data.Infix
-deriving instance Typeable 'InitialQuote
-deriving instance Typeable 'InputUnderflow
-deriving instance Typeable 'Interrupted
-deriving instance Typeable 'InvalidArgument
-deriving instance Typeable 'InvalidSequence
-deriving instance Typeable 'Just
-deriving instance Typeable 'K1
-deriving instance Typeable 'KProxy
-deriving instance Typeable 'Last
-deriving instance Typeable 'Left
-deriving instance Typeable 'LeftAdjust
-deriving instance Typeable 'LeftAssociative
-deriving instance Typeable 'LetterNumber
-deriving instance Typeable 'LF
-deriving instance Typeable 'LineSeparator
-deriving instance Typeable 'LossOfPrecision
-deriving instance Typeable 'LowercaseLetter
-deriving instance Typeable 'LT
-deriving instance Typeable 'MaskedInterruptible
-deriving instance Typeable 'MaskedUninterruptible
-deriving instance Typeable 'MathSymbol
-deriving instance Typeable 'ModifierLetter
-deriving instance Typeable 'ModifierSymbol
-deriving instance Typeable 'NestedAtomically
-deriving instance Typeable 'NewlineMode
-deriving instance Typeable 'NonSpacingMark
-deriving instance Typeable 'NonTermination
-deriving instance Typeable 'NoSpecConstr
-deriving instance Typeable 'NoSuchThing
-deriving instance Typeable 'NotAssigned
-deriving instance Typeable 'NotAssociative
-deriving instance Typeable 'Nothing
-deriving instance Typeable 'O
-deriving instance Typeable 'OpenPunctuation
-deriving instance Typeable 'OtherError
-deriving instance Typeable 'OtherLetter
-deriving instance Typeable 'OtherNumber
-deriving instance Typeable 'OtherPunctuation
-deriving instance Typeable 'OtherSymbol
-deriving instance Typeable 'OutputUnderflow
-deriving instance Typeable 'Overflow
-deriving instance Typeable 'Par1
-deriving instance Typeable 'ParagraphSeparator
-deriving instance Typeable 'PermissionDenied
-deriving instance Typeable 'Data.Prefix
-deriving instance Typeable 'PrivateUse
-deriving instance Typeable 'Product
-deriving instance Typeable 'ProtocolError
-deriving instance Typeable 'RatioZeroDenominator
-deriving instance Typeable 'RawDevice
-deriving instance Typeable 'ReadBuffer
-deriving instance Typeable 'ReadHandle
-deriving instance Typeable 'ReadMode
-deriving instance Typeable 'ReadWriteHandle
-deriving instance Typeable 'ReadWriteMode
-deriving instance Typeable 'RegularFile
-deriving instance Typeable 'RelativeSeek
-deriving instance Typeable 'ResourceBusy
-deriving instance Typeable 'ResourceExhausted
-deriving instance Typeable 'ResourceVanished
-deriving instance Typeable 'Right
-deriving instance Typeable 'RightAssociative
-deriving instance Typeable 'RoundtripFailure
-deriving instance Typeable 'SeekFromEnd
-deriving instance Typeable 'SemiClosedHandle
-deriving instance Typeable 'SignPlus
-deriving instance Typeable 'SignSpace
-deriving instance Typeable 'Space
-deriving instance Typeable 'SpacingCombiningMark
-deriving instance Typeable 'SPEC
-deriving instance Typeable 'SPEC2
-deriving instance Typeable 'StackOverflow
-deriving instance Typeable 'Stream
-deriving instance Typeable 'Sum
-deriving instance Typeable 'Surrogate
-deriving instance Typeable 'SystemError
-deriving instance Typeable 'ThreadBlocked
-deriving instance Typeable 'ThreadDied
-deriving instance Typeable 'ThreadFinished
-deriving instance Typeable 'ThreadKilled
-deriving instance Typeable 'ThreadRunning
-deriving instance Typeable 'TimeExpired
-deriving instance Typeable 'TitlecaseLetter
-deriving instance Typeable 'TransliterateCodingFailure
-deriving instance Typeable 'True
-deriving instance Typeable 'U1
-deriving instance Typeable 'Underflow
-deriving instance Typeable 'Unmasked
-deriving instance Typeable 'UnsatisfiedConstraints
-deriving instance Typeable 'UnsupportedOperation
-deriving instance Typeable 'UppercaseLetter
-deriving instance Typeable 'UserError
-deriving instance Typeable 'UserInterrupt
-deriving instance Typeable 'WriteBuffer
-deriving instance Typeable 'WriteHandle
-deriving instance Typeable 'WriteMode
-deriving instance Typeable 'ZeroPad
-deriving instance Typeable 'ZipList
-
-#  if defined(mingw32_HOST_OS)
-deriving instance Typeable 'Break
-deriving instance Typeable 'Close
-deriving instance Typeable 'ControlC
-deriving instance Typeable 'Logoff
-deriving instance Typeable 'Shutdown
-#  endif
-# endif
-
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveFoldable #-}
+{-# LANGUAGE DeriveFunctor #-}
+{-# LANGUAGE DeriveTraversable #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+#if __GLASGOW_HASKELL__ < 806
+{-# LANGUAGE TypeInType #-}
+#endif
+
+{-# OPTIONS_GHC -Wno-deprecations #-}
+{-# OPTIONS_GHC -Wno-orphans #-}
+{-|
+Exports orphan instances that mimic instances available in later versions of @base@.
+To use them, simply @import Data.Orphans ()@.
+-}
+module Data.Orphans () where
+
+#ifdef __GLASGOW_HASKELL__
+# if !(MIN_VERSION_base(4,11,0))
+import qualified Control.Monad.Fail as Fail (MonadFail(..))
+# endif
+
+# if !(MIN_VERSION_base(4,16,0))
+import qualified Data.Functor.Product as Functor
+# endif
+
+# if !(MIN_VERSION_base(4,10,0))
+import           Data.Data as Data
+# endif
+
+# if !(MIN_VERSION_base(4,11,0))
+import           Control.Monad.ST as Strict
+# endif
+
+# if MIN_VERSION_base(4,11,0) && !(MIN_VERSION_base(4,21,0))
+import           GHC.Read (readField)
+# endif
+
+# if !(MIN_VERSION_base(4,12,0))
+import qualified Data.Foldable as F (Foldable(..))
+import qualified Data.Traversable as T (Traversable(..))
+# endif
+
+# if MIN_VERSION_base(4,15,0) && !(MIN_VERSION_base(4,16,0))
+import           GHC.Tuple (Solo(..))
+# endif
+
+# if !(MIN_VERSION_base(4,21,0))
+import           Data.Orphans.Prelude
+import           GHC.Generics as Generics hiding (prec)
+# endif
+
+#include "HsBaseConfig.h"
+
+-------------------------------------------------------------------------------
+
+# if !(MIN_VERSION_base(4,10,0))
+deriving instance (Typeable k, Data a, Typeable (b :: k)) => Data (Const a b)
+
+instance Eq1 NonEmpty where
+  liftEq eq (a :| as) (b :| bs) = eq a b && liftEq eq as bs
+
+instance Ord1 NonEmpty where
+  liftCompare cmp (a :| as) (b :| bs) = cmp a b <> liftCompare cmp as bs
+
+instance Read1 NonEmpty where
+  liftReadsPrec rdP rdL p s = readParen (p > 5) (\s' -> do
+    (a, s'') <- rdP 6 s'
+    (":|", s''') <- lex s''
+    (as, s'''') <- rdL s'''
+    return (a :| as, s'''')) s
+
+instance Show1 NonEmpty where
+  liftShowsPrec shwP shwL p (a :| as) = showParen (p > 5) $
+    shwP 6 a . showString " :| " . shwL as
+
+instance Semigroup a => Semigroup (IO a) where
+    (<>) = liftA2 (<>)
+
+#  if !defined(mingw32_HOST_OS) && !defined(ghcjs_HOST_OS)
+instance Semigroup Event where
+    (<>) = mappend
+    stimes = stimesMonoid
+
+instance Semigroup Lifetime where
+    (<>) = mappend
+    stimes = stimesMonoid
+#  endif
+# endif
+
+# if !(MIN_VERSION_base(4,11,0))
+instance Alternative ZipList where
+  empty = ZipList []
+  ZipList xs <|> ZipList ys = ZipList (xs ++ drop (length xs) ys)
+
+deriving instance Monoid a => Monoid (Down a)
+deriving instance Num a => Num (Down a)
+
+instance Functor Down where
+    fmap = coerce
+
+instance Applicative Down where
+    pure = Down
+    (<*>) = coerce
+
+instance Monad Down where
+    return = Down
+    Down a >>= k = k a
+
+instance Monoid a => Monoid (Strict.ST s a) where
+    mempty = pure mempty
+    mappend = liftA2 mappend
+
+instance Fail.MonadFail (Strict.ST s) where
+    fail s = errorWithoutStackTrace s
+
+deriving instance Semigroup a => Semigroup (Down a)
+
+instance Semigroup a => Semigroup (Strict.ST s a) where
+    (<>) = liftA2 (<>)
+
+#  if MIN_VERSION_base(4,10,0)
+deriving instance Data IntPtr
+deriving instance Data WordPtr
+#  else
+-- The constructors for IntPtr and WordPtr aren't exposed on older versions
+-- of base, so we're forced to hand-roll the Data instances here
+instance Data IntPtr where
+  gfoldl k z iptr = z intPtr `k` unIntPtr iptr
+  gunfold k z _ = k (z intPtr)
+  toConstr !_ = cIntPtr
+  dataTypeOf _ = tIntPtr
+
+intPtr :: Int -> IntPtr
+intPtr = unsafeCoerce
+
+unIntPtr :: IntPtr -> Int
+unIntPtr = unsafeCoerce
+
+tIntPtr :: DataType
+tIntPtr = mkDataType "IntPtr" [cIntPtr]
+
+cIntPtr :: Constr
+cIntPtr = mkConstr tIntPtr "IntPtr" [] Data.Prefix
+
+instance Data WordPtr where
+  gfoldl k z wptr = z wordPtr `k` unWordPtr wptr
+  gunfold k z _ = k (z wordPtr)
+  toConstr !_ = cWordPtr
+  dataTypeOf _ = tWordPtr
+
+wordPtr :: Word -> WordPtr
+wordPtr = unsafeCoerce
+
+unWordPtr :: WordPtr -> Word
+unWordPtr = unsafeCoerce
+
+tWordPtr :: DataType
+tWordPtr = mkDataType "WordPtr" [cWordPtr]
+
+cWordPtr :: Constr
+cWordPtr = mkConstr tWordPtr "WordPtr" [] Data.Prefix
+#  endif
+# endif
+
+# if !(MIN_VERSION_base(4,12,0))
+instance MonadFix Down where
+    mfix f = Down (fix (getDown . f))
+      where getDown (Down x) = x
+deriving instance Data a => Data (Down a)
+deriving instance F.Foldable Down
+deriving instance T.Traversable Down
+instance MonadZip Down where
+    mzipWith = liftM2
+instance Eq1 Down where
+    liftEq eq (Down x) (Down y) = eq x y
+instance Ord1 Down where
+    liftCompare comp (Down x) (Down y) = case comp x y of
+        LT -> GT
+        EQ -> EQ
+        GT -> LT
+instance Read1 Down where
+    liftReadsPrec rp _ = readsData $
+         readsUnaryWith rp "Down" Down
+instance Show1 Down where
+    liftShowsPrec sp _ d (Down x) = showsUnaryWith sp "Down" d x
+
+instance Monoid c => Applicative (K1 i c) where
+  pure _ = K1 mempty
+  (<*>) = coerce (mappend :: c -> c -> c)
+#  if MIN_VERSION_base(4,10,0)
+  liftA2 = \_ -> coerce (mappend :: c -> c -> c)
+#  endif
+
+instance Monoid (U1 p) where
+  mempty = U1
+#  if !(MIN_VERSION_base(4,11,0))
+  _ `mappend` _ = U1
+#  endif
+deriving instance Monoid p => Monoid (Par1 p)
+deriving instance Monoid (f p) => Monoid (Rec1 f p)
+deriving instance Monoid c => Monoid (K1 i c p)
+deriving instance Monoid (f p) => Monoid (M1 i c f p)
+instance (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) where
+  mempty = mempty :*: mempty
+#  if !(MIN_VERSION_base(4,11,0))
+  (x1 :*: y1) `mappend` (x2 :*: y2) = (x1 `mappend` x2) :*: (y1 `mappend` y2)
+#  endif
+deriving instance Monoid (f (g p)) => Monoid ((f :.: g) p)
+
+instance Semigroup (V1 p) where
+  v <> _ = v
+instance Semigroup (U1 p) where
+  _ <> _ = U1
+deriving instance Semigroup p => Semigroup (Par1 p)
+deriving instance Semigroup (f p) => Semigroup (Rec1 f p)
+deriving instance Semigroup c => Semigroup (K1 i c p)
+deriving instance Semigroup (f p) => Semigroup (M1 i c f p)
+instance (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) where
+  (x1 :*: y1) <> (x2 :*: y2) = (x1 <> x2) :*: (y1 <> y2)
+deriving instance Semigroup (f (g p)) => Semigroup ((f :.: g) p)
+
+deriving instance Foldable f => Foldable (Alt f)
+deriving instance Traversable f => Traversable (Alt f)
+# endif
+
+# if !(MIN_VERSION_base(4,14,0))
+instance Functor ((,,) a b) where
+    fmap f (a, b, c) = (a, b, f c)
+
+instance (Monoid a, Monoid b) => Applicative ((,,) a b) where
+    pure x = (mempty, mempty, x)
+    (a, b, f) <*> (a', b', x) = (a `mappend` a', b `mappend` b', f x)
+
+instance (Monoid a, Monoid b) => Monad ((,,) a b) where
+    (u, v, a) >>= k =
+      case k a of
+        (u', v', b) ->
+          (u `mappend` u', v `mappend` v', b)
+
+instance Functor ((,,,) a b c) where
+    fmap f (a, b, c, d) = (a, b, c, f d)
+
+instance (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) where
+    pure x = (mempty, mempty, mempty, x)
+    (a, b, c, f) <*> (a', b', c', x) =
+      (a `mappend` a', b `mappend` b', c `mappend` c', f x)
+
+instance (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) where
+    (u, v, w, a) >>= k =
+      case k a of
+        (u', v', w', b) ->
+          (u `mappend` u', v `mappend` v', w `mappend` w', b)
+
+deriving instance Functor m => Functor (Kleisli m a)
+
+instance Applicative m => Applicative (Kleisli m a) where
+  pure = Kleisli . const . pure
+  {-# INLINE pure #-}
+  Kleisli f <*> Kleisli g = Kleisli $ \x -> f x <*> g x
+  {-# INLINE (<*>) #-}
+  Kleisli f *> Kleisli g = Kleisli $ \x -> f x *> g x
+  {-# INLINE (*>) #-}
+  Kleisli f <* Kleisli g = Kleisli $ \x -> f x <* g x
+  {-# INLINE (<*) #-}
+
+instance Alternative m => Alternative (Kleisli m a) where
+  empty = Kleisli $ const empty
+  {-# INLINE empty #-}
+  Kleisli f <|> Kleisli g = Kleisli $ \x -> f x <|> g x
+  {-# INLINE (<|>) #-}
+
+instance Monad m => Monad (Kleisli m a) where
+  Kleisli f >>= k = Kleisli $ \x -> f x >>= \a -> runKleisli (k a) x
+  {-# INLINE (>>=) #-}
+
+instance MonadPlus m => MonadPlus (Kleisli m a) where
+  mzero = Kleisli $ const mzero
+  {-# INLINE mzero #-}
+  Kleisli f `mplus` Kleisli g = Kleisli $ \x -> f x `mplus` g x
+  {-# INLINE mplus #-}
+
+-- | Swaps @'minBound'@ and @'maxBound'@ of the underlying type.
+instance Bounded a => Bounded (Down a) where
+    minBound = Down maxBound
+    maxBound = Down minBound
+
+deriving instance Bits       a => Bits       (Down a)
+deriving instance Floating   a => Floating   (Down a)
+deriving instance Fractional a => Fractional (Down a)
+deriving instance Ix         a => Ix         (Down a)
+deriving instance Real       a => Real       (Down a)
+deriving instance RealFrac   a => RealFrac   (Down a)
+deriving instance RealFloat  a => RealFloat  (Down a)
+deriving instance Storable   a => Storable   (Down a)
+deriving instance FiniteBits a => FiniteBits (Down a)
+
+deriving instance (Typeable2 a, Typeable b, Typeable c, Data (a b c))
+                         => Data (WrappedArrow a b c)
+deriving instance (Typeable1 m, Typeable a, Data (m a))
+                         => Data (WrappedMonad m a)
+deriving instance Data a => Data (ZipList a)
+
+instance IsList (ZipList a) where
+  type Item (ZipList a) = a
+  fromList = ZipList
+  toList = getZipList
+
+instance (TestEquality f) => TestEquality (Compose f g) where
+  testEquality (Compose x) (Compose y) =
+    case testEquality x y of -- :: Maybe (g x :~: g y)
+      Just Refl -> Just Refl -- :: Maybe (x :~: y)
+      Nothing   -> Nothing
+# endif
+
+# if !(MIN_VERSION_base(4,15,0))
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6) =>
+      Ix (a1,a2,a3,a4,a5,a6)  where
+    range ((l1,l2,l3,l4,l5,l6),(u1,u2,u3,u4,u5,u6)) =
+      [(i1,i2,i3,i4,i5,i6) | i1 <- range (l1,u1),
+                             i2 <- range (l2,u2),
+                             i3 <- range (l3,u3),
+                             i4 <- range (l4,u4),
+                             i5 <- range (l5,u5),
+                             i6 <- range (l6,u6)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6),(u1,u2,u3,u4,u5,u6)) (i1,i2,i3,i4,i5,i6) =
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1)))))
+
+    inRange ((l1,l2,l3,l4,l5,l6),(u1,u2,u3,u4,u5,u6)) (i1,i2,i3,i4,i5,i6) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7)  where
+    range ((l1,l2,l3,l4,l5,l6,l7),(u1,u2,u3,u4,u5,u6,u7)) =
+      [(i1,i2,i3,i4,i5,i6,i7) | i1 <- range (l1,u1),
+                                i2 <- range (l2,u2),
+                                i3 <- range (l3,u3),
+                                i4 <- range (l4,u4),
+                                i5 <- range (l5,u5),
+                                i6 <- range (l6,u6),
+                                i7 <- range (l7,u7)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7),(u1,u2,u3,u4,u5,u6,u7))
+        (i1,i2,i3,i4,i5,i6,i7) =
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7),(u1,u2,u3,u4,u5,u6,u7))
+        (i1,i2,i3,i4,i5,i6,i7) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7,a8)  where
+    range ((l1,l2,l3,l4,l5,l6,l7,l8),(u1,u2,u3,u4,u5,u6,u7,u8)) =
+      [(i1,i2,i3,i4,i5,i6,i7,i8) | i1 <- range (l1,u1),
+                                   i2 <- range (l2,u2),
+                                   i3 <- range (l3,u3),
+                                   i4 <- range (l4,u4),
+                                   i5 <- range (l5,u5),
+                                   i6 <- range (l6,u6),
+                                   i7 <- range (l7,u7),
+                                   i8 <- range (l8,u8)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8),(u1,u2,u3,u4,u5,u6,u7,u8))
+        (i1,i2,i3,i4,i5,i6,i7,i8) =
+      unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1)))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7,l8),(u1,u2,u3,u4,u5,u6,u7,u8))
+        (i1,i2,i3,i4,i5,i6,i7,i8) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7 && inRange (l8,u8) i8
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9)  where
+    range ((l1,l2,l3,l4,l5,l6,l7,l8,l9),(u1,u2,u3,u4,u5,u6,u7,u8,u9)) =
+      [(i1,i2,i3,i4,i5,i6,i7,i8,i9) | i1 <- range (l1,u1),
+                                      i2 <- range (l2,u2),
+                                      i3 <- range (l3,u3),
+                                      i4 <- range (l4,u4),
+                                      i5 <- range (l5,u5),
+                                      i6 <- range (l6,u6),
+                                      i7 <- range (l7,u7),
+                                      i8 <- range (l8,u8),
+                                      i9 <- range (l9,u9)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9),(u1,u2,u3,u4,u5,u6,u7,u8,u9))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9) =
+      unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (
+      unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1))))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9),(u1,u2,u3,u4,u5,u6,u7,u8,u9))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7 && inRange (l8,u8) i8 &&
+      inRange (l9,u9) i9
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
+           Ix aA) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA)  where
+    range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA),(u1,u2,u3,u4,u5,u6,u7,u8,u9,uA)) =
+      [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA) | i1 <- range (l1,u1),
+                                         i2 <- range (l2,u2),
+                                         i3 <- range (l3,u3),
+                                         i4 <- range (l4,u4),
+                                         i5 <- range (l5,u5),
+                                         i6 <- range (l6,u6),
+                                         i7 <- range (l7,u7),
+                                         i8 <- range (l8,u8),
+                                         i9 <- range (l9,u9),
+                                         iA <- range (lA,uA)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA),
+                 (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA) =
+      unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (
+      unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (
+      unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1)))))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA),(u1,u2,u3,u4,u5,u6,u7,u8,u9,uA))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7 && inRange (l8,u8) i8 &&
+      inRange (l9,u9) i9 && inRange (lA,uA) iA
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
+           Ix aA, Ix aB) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB)  where
+    range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB),
+           (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB)) =
+      [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB) | i1 <- range (l1,u1),
+                                            i2 <- range (l2,u2),
+                                            i3 <- range (l3,u3),
+                                            i4 <- range (l4,u4),
+                                            i5 <- range (l5,u5),
+                                            i6 <- range (l6,u6),
+                                            i7 <- range (l7,u7),
+                                            i8 <- range (l8,u8),
+                                            i9 <- range (l9,u9),
+                                            iA <- range (lA,uA),
+                                            iB <- range (lB,uB)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB),
+                 (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB) =
+      unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (
+      unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (
+      unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (
+      unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1))))))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB),
+             (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7 && inRange (l8,u8) i8 &&
+      inRange (l9,u9) i9 && inRange (lA,uA) iA &&
+      inRange (lB,uB) iB
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
+           Ix aA, Ix aB, Ix aC) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC)  where
+    range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC),
+           (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC)) =
+      [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC) | i1 <- range (l1,u1),
+                                               i2 <- range (l2,u2),
+                                               i3 <- range (l3,u3),
+                                               i4 <- range (l4,u4),
+                                               i5 <- range (l5,u5),
+                                               i6 <- range (l6,u6),
+                                               i7 <- range (l7,u7),
+                                               i8 <- range (l8,u8),
+                                               i9 <- range (l9,u9),
+                                               iA <- range (lA,uA),
+                                               iB <- range (lB,uB),
+                                               iC <- range (lC,uC)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC),
+                 (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC) =
+      unsafeIndex (lC,uC) iC + unsafeRangeSize (lC,uC) * (
+      unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (
+      unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (
+      unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (
+      unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1)))))))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC),
+             (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7 && inRange (l8,u8) i8 &&
+      inRange (l9,u9) i9 && inRange (lA,uA) iA &&
+      inRange (lB,uB) iB && inRange (lC,uC) iC
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
+           Ix aA, Ix aB, Ix aC, Ix aD) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD)  where
+    range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD),
+           (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD)) =
+      [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD) | i1 <- range (l1,u1),
+                                                  i2 <- range (l2,u2),
+                                                  i3 <- range (l3,u3),
+                                                  i4 <- range (l4,u4),
+                                                  i5 <- range (l5,u5),
+                                                  i6 <- range (l6,u6),
+                                                  i7 <- range (l7,u7),
+                                                  i8 <- range (l8,u8),
+                                                  i9 <- range (l9,u9),
+                                                  iA <- range (lA,uA),
+                                                  iB <- range (lB,uB),
+                                                  iC <- range (lC,uC),
+                                                  iD <- range (lD,uD)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD),
+                 (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD) =
+      unsafeIndex (lD,uD) iD + unsafeRangeSize (lD,uD) * (
+      unsafeIndex (lC,uC) iC + unsafeRangeSize (lC,uC) * (
+      unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (
+      unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (
+      unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (
+      unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1))))))))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD),
+             (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7 && inRange (l8,u8) i8 &&
+      inRange (l9,u9) i9 && inRange (lA,uA) iA &&
+      inRange (lB,uB) iB && inRange (lC,uC) iC &&
+      inRange (lD,uD) iD
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
+           Ix aA, Ix aB, Ix aC, Ix aD, Ix aE) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD,aE)  where
+    range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE),
+           (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE)) =
+      [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE) | i1 <- range (l1,u1),
+                                                     i2 <- range (l2,u2),
+                                                     i3 <- range (l3,u3),
+                                                     i4 <- range (l4,u4),
+                                                     i5 <- range (l5,u5),
+                                                     i6 <- range (l6,u6),
+                                                     i7 <- range (l7,u7),
+                                                     i8 <- range (l8,u8),
+                                                     i9 <- range (l9,u9),
+                                                     iA <- range (lA,uA),
+                                                     iB <- range (lB,uB),
+                                                     iC <- range (lC,uC),
+                                                     iD <- range (lD,uD),
+                                                     iE <- range (lE,uE)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE),
+                 (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE) =
+      unsafeIndex (lE,uE) iE + unsafeRangeSize (lE,uE) * (
+      unsafeIndex (lD,uD) iD + unsafeRangeSize (lD,uD) * (
+      unsafeIndex (lC,uC) iC + unsafeRangeSize (lC,uC) * (
+      unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (
+      unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (
+      unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (
+      unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1)))))))))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE),
+             (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7 && inRange (l8,u8) i8 &&
+      inRange (l9,u9) i9 && inRange (lA,uA) iA &&
+      inRange (lB,uB) iB && inRange (lC,uC) iC &&
+      inRange (lD,uD) iD && inRange (lE,uE) iE
+
+    -- Default method for index
+
+instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
+           Ix aA, Ix aB, Ix aC, Ix aD, Ix aE, Ix aF) =>
+      Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD,aE,aF)  where
+    range ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE,lF),
+           (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE,uF)) =
+      [(i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE,iF) | i1 <- range (l1,u1),
+                                                        i2 <- range (l2,u2),
+                                                        i3 <- range (l3,u3),
+                                                        i4 <- range (l4,u4),
+                                                        i5 <- range (l5,u5),
+                                                        i6 <- range (l6,u6),
+                                                        i7 <- range (l7,u7),
+                                                        i8 <- range (l8,u8),
+                                                        i9 <- range (l9,u9),
+                                                        iA <- range (lA,uA),
+                                                        iB <- range (lB,uB),
+                                                        iC <- range (lC,uC),
+                                                        iD <- range (lD,uD),
+                                                        iE <- range (lE,uE),
+                                                        iF <- range (lF,uF)]
+
+    unsafeIndex ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE,lF),
+                 (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE,uF))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE,iF) =
+      unsafeIndex (lF,uF) iF + unsafeRangeSize (lF,uF) * (
+      unsafeIndex (lE,uE) iE + unsafeRangeSize (lE,uE) * (
+      unsafeIndex (lD,uD) iD + unsafeRangeSize (lD,uD) * (
+      unsafeIndex (lC,uC) iC + unsafeRangeSize (lC,uC) * (
+      unsafeIndex (lB,uB) iB + unsafeRangeSize (lB,uB) * (
+      unsafeIndex (lA,uA) iA + unsafeRangeSize (lA,uA) * (
+      unsafeIndex (l9,u9) i9 + unsafeRangeSize (l9,u9) * (
+      unsafeIndex (l8,u8) i8 + unsafeRangeSize (l8,u8) * (
+      unsafeIndex (l7,u7) i7 + unsafeRangeSize (l7,u7) * (
+      unsafeIndex (l6,u6) i6 + unsafeRangeSize (l6,u6) * (
+      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (
+      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (
+      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (
+      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (
+      unsafeIndex (l1,u1) i1))))))))))))))
+
+    inRange ((l1,l2,l3,l4,l5,l6,l7,l8,l9,lA,lB,lC,lD,lE,lF),
+             (u1,u2,u3,u4,u5,u6,u7,u8,u9,uA,uB,uC,uD,uE,uF))
+        (i1,i2,i3,i4,i5,i6,i7,i8,i9,iA,iB,iC,iD,iE,iF) =
+      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&
+      inRange (l3,u3) i3 && inRange (l4,u4) i4 &&
+      inRange (l5,u5) i5 && inRange (l6,u6) i6 &&
+      inRange (l7,u7) i7 && inRange (l8,u8) i8 &&
+      inRange (l9,u9) i9 && inRange (lA,uA) iA &&
+      inRange (lB,uB) iB && inRange (lC,uC) iC &&
+      inRange (lD,uD) iD && inRange (lE,uE) iE &&
+      inRange (lF,uF) iF
+
+    -- Default method for index
+
+instance MonadZip Complex where
+  mzipWith = liftA2
+
+instance MonadFix Complex where
+  mfix f = (let a :+ _ = f a in a) :+ (let _ :+ a = f a in a)
+# endif
+
+# if !(MIN_VERSION_base(4,16,0))
+instance Eq1 Complex where
+    liftEq eq (x :+ y) (u :+ v) = eq x u && eq y v
+
+instance Read1 Complex where
+#  if MIN_VERSION_base(4,10,0)
+    liftReadPrec rp _  = parens $ prec complexPrec $ do
+        x <- step rp
+        expectP (Symbol ":+")
+        y <- step rp
+        return (x :+ y)
+      where
+        complexPrec = 6
+
+    liftReadListPrec = liftReadListPrecDefault
+    liftReadList     = liftReadListDefault
+#  else
+    liftReadsPrec rdP _ p s = readParen (p > complexPrec) (\s' -> do
+      (x, s'')     <- rdP (complexPrec+1) s'
+      (":+", s''') <- lex s''
+      (y, s'''')   <- rdP (complexPrec+1) s'''
+      return (x :+ y, s'''')) s
+      where
+        complexPrec = 6
+#  endif
+
+instance Show1 Complex where
+    liftShowsPrec sp _ d (x :+ y) = showParen (d > complexPrec) $
+        sp (complexPrec+1) x . showString " :+ " . sp (complexPrec+1) y
+      where
+        complexPrec = 6
+
+instance Eq a => Eq2 ((,,) a) where
+    liftEq2 e1 e2 (u1, x1, y1) (v1, x2, y2) =
+        u1 == v1 &&
+        e1 x1 x2 && e2 y1 y2
+
+instance Ord a => Ord2 ((,,) a) where
+    liftCompare2 comp1 comp2 (u1, x1, y1) (v1, x2, y2) =
+        compare u1 v1 `mappend`
+        comp1 x1 x2 `mappend` comp2 y1 y2
+
+instance Read a => Read2 ((,,) a) where
+#  if MIN_VERSION_base(4,10,0)
+    liftReadPrec2 rp1 _ rp2 _ = parens $ paren $ do
+        x1 <- readPrec
+        expectP (Punc ",")
+        y1 <- rp1
+        expectP (Punc ",")
+        y2 <- rp2
+        return (x1,y1,y2)
+
+    liftReadListPrec2 = liftReadListPrec2Default
+    liftReadList2     = liftReadList2Default
+#  else
+    liftReadsPrec2 rp1 _ rp2 _ _ = readParen False $ \ r ->
+        [((e1,e2,e3), y) | ("(",s) <- lex r,
+                           (e1,t)  <- readsPrec 0 s,
+                           (",",u) <- lex t,
+                           (e2,v)  <- rp1 0 u,
+                           (",",w) <- lex v,
+                           (e3,x)  <- rp2 0 w,
+                           (")",y) <- lex x]
+#  endif
+
+instance Show a => Show2 ((,,) a) where
+    liftShowsPrec2 sp1 _ sp2 _ _ (x1,y1,y2)
+        = showChar '(' . showsPrec 0 x1
+        . showChar ',' . sp1 0 y1
+        . showChar ',' . sp2 0 y2
+        . showChar ')'
+
+instance (Eq a, Eq b) => Eq1 ((,,) a b) where
+    liftEq = liftEq2 (==)
+
+instance (Ord a, Ord b) => Ord1 ((,,) a b) where
+    liftCompare = liftCompare2 compare
+
+instance (Read a, Read b) => Read1 ((,,) a b) where
+#  if MIN_VERSION_base(4,10,0)
+    liftReadPrec = liftReadPrec2 readPrec readListPrec
+
+    liftReadListPrec = liftReadListPrecDefault
+    liftReadList     = liftReadListDefault
+#  else
+    liftReadsPrec = liftReadsPrec2 readsPrec readList
+#  endif
+
+instance (Show a, Show b) => Show1 ((,,) a b) where
+    liftShowsPrec = liftShowsPrec2 showsPrec showList
+
+instance (Eq a, Eq b) => Eq2 ((,,,) a b) where
+    liftEq2 e1 e2 (u1, u2, x1, y1) (v1, v2, x2, y2) =
+        u1 == v1 &&
+        u2 == v2 &&
+        e1 x1 x2 && e2 y1 y2
+
+instance (Ord a, Ord b) => Ord2 ((,,,) a b) where
+    liftCompare2 comp1 comp2 (u1, u2, x1, y1) (v1, v2, x2, y2) =
+        compare u1 v1 `mappend`
+        compare u2 v2 `mappend`
+        comp1 x1 x2 `mappend` comp2 y1 y2
+
+instance (Read a, Read b) => Read2 ((,,,) a b) where
+#  if MIN_VERSION_base(4,10,0)
+    liftReadPrec2 rp1 _ rp2 _ = parens $ paren $ do
+        x1 <- readPrec
+        expectP (Punc ",")
+        x2 <- readPrec
+        expectP (Punc ",")
+        y1 <- rp1
+        expectP (Punc ",")
+        y2 <- rp2
+        return (x1,x2,y1,y2)
+
+    liftReadListPrec2 = liftReadListPrec2Default
+    liftReadList2     = liftReadList2Default
+#  else
+    liftReadsPrec2 rp1 _ rp2 _ _ = readParen False $ \ r ->
+        [((e1,e2,e3,e4), s9) | ("(",s1) <- lex r,
+                               (e1,s2)  <- readsPrec 0 s1,
+                               (",",s3) <- lex s2,
+                               (e2,s4)  <- readsPrec 0 s3,
+                               (",",s5) <- lex s4,
+                               (e3,s6)  <- rp1 0 s5,
+                               (",",s7) <- lex s6,
+                               (e4,s8)  <- rp2 0 s7,
+                               (")",s9) <- lex s8]
+#  endif
+
+instance (Show a, Show b) => Show2 ((,,,) a b) where
+    liftShowsPrec2 sp1 _ sp2 _ _ (x1,x2,y1,y2)
+        = showChar '(' . showsPrec 0 x1
+        . showChar ',' . showsPrec 0 x2
+        . showChar ',' . sp1 0 y1
+        . showChar ',' . sp2 0 y2
+        . showChar ')'
+
+instance (Eq a, Eq b, Eq c) => Eq1 ((,,,) a b c) where
+    liftEq = liftEq2 (==)
+
+instance (Ord a, Ord b, Ord c) => Ord1 ((,,,) a b c) where
+    liftCompare = liftCompare2 compare
+
+instance (Read a, Read b, Read c) => Read1 ((,,,) a b c) where
+#  if MIN_VERSION_base(4,10,0)
+    liftReadPrec = liftReadPrec2 readPrec readListPrec
+
+    liftReadListPrec = liftReadListPrecDefault
+    liftReadList     = liftReadListDefault
+#  else
+    liftReadsPrec = liftReadsPrec2 readsPrec readList
+#  endif
+
+instance (Show a, Show b, Show c) => Show1 ((,,,) a b c) where
+    liftShowsPrec = liftShowsPrec2 showsPrec showList
+
+deriving instance Semigroup (f (g a)) => Semigroup (Compose f g a)
+deriving instance Monoid    (f (g a)) => Monoid    (Compose f g a)
+
+instance (Semigroup (f a), Semigroup (g a)) => Semigroup (Functor.Product f g a) where
+    Functor.Pair x1 y1 <> Functor.Pair x2 y2 = Functor.Pair (x1 <> x2) (y1 <> y2)
+
+instance (Monoid (f a), Monoid (g a)) => Monoid (Functor.Product f g a) where
+    mempty = Functor.Pair mempty mempty
+#  if !(MIN_VERSION_base(4,11,0))
+    Functor.Pair x1 y1 `mappend` Functor.Pair x2 y2 = Functor.Pair (x1 `mappend` x2) (y1 `mappend` y2)
+#  endif
+
+#  if MIN_VERSION_base(4,15,0)
+instance Enum a => Enum (Solo a) where
+    succ (Solo a) = Solo (succ a)
+    pred (Solo a) = Solo (pred a)
+
+    toEnum x = Solo (toEnum x)
+
+    fromEnum (Solo x) = fromEnum x
+    enumFrom (Solo x) = [Solo a | a <- enumFrom x]
+    enumFromThen (Solo x) (Solo y) =
+      [Solo a | a <- enumFromThen x y]
+    enumFromTo (Solo x) (Solo y) =
+      [Solo a | a <- enumFromTo x y]
+    enumFromThenTo (Solo x) (Solo y) (Solo z) =
+      [Solo a | a <- enumFromThenTo x y z]
+
+deriving instance Eq a => Eq (Solo a)
+deriving instance Ord a => Ord (Solo a)
+deriving instance Bounded a => Bounded (Solo a)
+
+instance Ix a => Ix (Solo a) where -- as derived
+    {-# SPECIALISE instance Ix (Solo Int) #-}
+
+    {-# INLINE range #-}
+    range (Solo l, Solo u) =
+      [ Solo i | i <- range (l,u) ]
+
+    {-# INLINE unsafeIndex #-}
+    unsafeIndex (Solo l, Solo u) (Solo i) =
+      unsafeIndex (l,u) i
+
+    {-# INLINE inRange #-}
+    inRange (Solo l, Solo u) (Solo i) =
+      inRange (l, u) i
+
+    -- Default method for index
+#  endif
+# endif
+
+# if !(MIN_VERSION_base(4,16,1))
+deriving instance Ix CChar
+deriving instance Ix CSChar
+deriving instance Ix CUChar
+deriving instance Ix CShort
+deriving instance Ix CUShort
+deriving instance Ix CInt
+deriving instance Ix CUInt
+deriving instance Ix CLong
+deriving instance Ix CULong
+deriving instance Ix CLLong
+deriving instance Ix CULLong
+deriving instance Ix CPtrdiff
+deriving instance Ix CSize
+deriving instance Ix CWchar
+deriving instance Ix CSigAtomic
+deriving instance Ix CIntPtr
+deriving instance Ix CUIntPtr
+deriving instance Ix CIntMax
+deriving instance Ix CUIntMax
+#  if MIN_VERSION_base(4,10,0)
+deriving instance Ix CBool
+#  endif
+
+#  if MIN_VERSION_base(4,10,0)
+-- These are guarded on base-4.10.0 because that was the first version which
+-- exported their constructors, which is necessary to use
+-- GeneralizedNewtypeDeriving. See
+-- https://gitlab.haskell.org/ghc/ghc/-/issues/11983.
+deriving instance Ix WordPtr
+deriving instance Ix IntPtr
+#  endif
+
+#  if defined(HTYPE_DEV_T)
+deriving instance Ix CDev
+#  endif
+#  if defined(HTYPE_INO_T)
+deriving instance Ix CIno
+#  endif
+#  if defined(HTYPE_MODE_T)
+deriving instance Ix CMode
+#  endif
+#  if defined(HTYPE_OFF_T)
+deriving instance Ix COff
+#  endif
+#  if defined(HTYPE_PID_T)
+deriving instance Ix CPid
+#  endif
+#  if defined(HTYPE_SSIZE_T)
+deriving instance Ix CSsize
+#  endif
+#  if defined(HTYPE_GID_T)
+deriving instance Ix CGid
+#  endif
+#  if defined(HTYPE_NLINK_T)
+deriving instance Ix CNlink
+#  endif
+#  if defined(HTYPE_UID_T)
+deriving instance Ix CUid
+#  endif
+#  if defined(HTYPE_CC_T)
+deriving instance Ix CCc
+#  endif
+#  if defined(HTYPE_SPEED_T)
+deriving instance Ix CSpeed
+#  endif
+#  if defined(HTYPE_TCFLAG_T)
+deriving instance Ix CTcflag
+#  endif
+#  if defined(HTYPE_RLIM_T)
+deriving instance Ix CRLim
+#  endif
+deriving instance Ix Fd
+
+#  if MIN_VERSION_base(4,10,0)
+#   if defined(HTYPE_BLKSIZE_T)
+deriving instance Ix CBlkSize
+#   endif
+#   if defined(HTYPE_BLKCNT_T)
+deriving instance Ix CBlkCnt
+#   endif
+#   if defined(HTYPE_CLOCKID_T)
+deriving instance Ix CClockId
+#   endif
+#   if defined(HTYPE_FSBLKCNT_T)
+deriving instance Ix CFsBlkCnt
+#   endif
+#   if defined(HTYPE_FSFILCNT_T)
+deriving instance Ix CFsFilCnt
+#   endif
+#   if defined(HTYPE_ID_T)
+deriving instance Ix CId
+#   endif
+#   if defined(HTYPE_KEY_T)
+deriving instance Ix CKey
+#   endif
+#   if defined(HTYPE_SOCKLEN_T)
+deriving instance Ix CSocklen
+#   endif
+#   if defined(HTYPE_NFDS_T)
+deriving instance Ix CNfds
+#   endif
+#  endif
+# endif
+
+# if !(MIN_VERSION_base(4,18,0))
+instance Functor ((,,,,) a b c d) where
+    fmap f (a, b, c, d, e) = (a, b, c, d, f e)
+instance Functor ((,,,,,) a b c d e) where
+    fmap fun (a, b, c, d, e, f) = (a, b, c, d, e, fun f)
+instance Functor ((,,,,,,) a b c d e f) where
+    fmap fun (a, b, c, d, e, f, g) = (a, b, c, d, e, f, fun g)
+
+#  if !(MIN_VERSION_base(4,14,0)) || MIN_VERSION_base(4,15,0)
+-- | Swaps @'succ'@ and @'pred'@ of the underlying type.
+instance (Enum a, Bounded a, Eq a) => Enum (Down a) where
+    succ = fmap pred
+    pred = fmap succ
+
+    -- Here we use the fact that 'comparing (complement @Int)' behaves
+    -- as an order-swapping `compare @Int`.
+    fromEnum (Down x) = complement $ fromEnum x
+    toEnum = Down . toEnum . complement
+
+    enumFrom (Down x)
+        | x == minBound
+        = [Down x] -- We can't rely on 'enumFromThen _ (pred @a minBound)` behaving nicely,
+                   -- since 'enumFromThen _' might be strict and 'pred minBound' might throw
+        | otherwise
+        = coerce $ enumFromThen x (pred x)
+    enumFromThen (Down x) (Down y) = coerce $ enumFromThen x y
+#  endif
+
+#  if MIN_VERSION_base(4,17,0)
+instance (Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) where
+   Generically1 x == Generically1 y = from1 x == from1 y
+   Generically1 x /= Generically1 y = from1 x /= from1 y
+
+instance (Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) where
+   Generically1 x `compare` Generically1 y = from1 x `compare` from1 y
+#  endif
+# endif
+
+# if !(MIN_VERSION_base(4,19,0))
+deriving instance Enum (f (g a)) => Enum (Compose f g a)
+deriving instance Bounded (f (g a)) => Bounded (Compose f g a)
+deriving instance Num (f (g a)) => Num (Compose f g a)
+
+-- In base-4.18.0.0, the Ord instance for Compose was simplified to:
+--
+--   instance Ord (f (g a)) => Ord (Compose f g a)
+--
+-- Before that, the Ord instance was defined as:
+--
+--   instance (Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)
+--
+-- This makes deriving Real and Integral instances slightly more complicated for
+-- these older versions of base, as there are no Real1 or Integral1 classes. We
+-- opt for making the instance contexts more complicated instead.
+#  if MIN_VERSION_base(4,18,0)
+deriving instance Real (f (g a)) => Real (Compose f g a)
+deriving instance Integral (f (g a)) => Integral (Compose f g a)
+#  else
+deriving instance (Real (f (g a)), Ord1 f, Ord1 g, Ord a) => Real (Compose f g a)
+deriving instance (Integral (f (g a)), Ord1 f, Ord1 g, Ord a) => Integral (Compose f g a)
+#  endif
+
+#  if MIN_VERSION_base(4,18,0)
+instance Eq (SChar c) where
+  _ == _ = True
+instance Ord (SChar c) where
+  compare _ _ = EQ
+
+instance Eq (SNat n) where
+  _ == _ = True
+instance Ord (SNat n) where
+  compare _ _ = EQ
+
+instance Eq (SSymbol s) where
+  _ == _ = True
+instance Ord (SSymbol s) where
+  compare _ _ = EQ
+#  endif
+# endif
+
+# if !(MIN_VERSION_base(4,20,0))
+deriving instance Fractional (f (g a)) => Fractional (Compose f g a)
+deriving instance Floating (f (g a)) => Floating (Compose f g a)
+
+-- RealFrac and RealFloat both have Ord as a superclass. For the reasons stated
+-- above (near the Real/Integral instances for Compose), these
+-- RealFrace/RealFloat instances are slightly more complicated for older
+-- versions of base.
+#  if MIN_VERSION_base(4,18,0)
+deriving instance RealFrac (f (g a)) => RealFrac (Compose f g a)
+deriving instance RealFloat (f (g a)) => RealFloat (Compose f g a)
+#  else
+deriving instance (RealFrac (f (g a)), Ord1 f, Ord1 g, Ord a) => RealFrac (Compose f g a)
+deriving instance (RealFloat (f (g a)), Ord1 f, Ord1 g, Ord a) => RealFloat (Compose f g a)
+#  endif
+# endif
+
+# if !(MIN_VERSION_base(4,21,0))
+instance Monoid a => MonadFix ((,) a) where
+    -- See the CLC proposal thread for discussion and proofs of the laws: https://github.com/haskell/core-libraries-committee/issues/238
+    mfix f = let a = f (snd a) in a
+
+instance Eq1 V1 where
+  liftEq _ = \_ _ -> True
+
+instance Ord1 V1 where
+  liftCompare _ = \_ _ -> EQ
+
+instance Show1 V1 where
+  liftShowsPrec _ _ _ = \_ -> showString "V1"
+
+instance Read1 V1 where
+  liftReadsPrec _ _ = readPrec_to_S pfail
+
+#  if MIN_VERSION_base(4,10,0)
+  liftReadListPrec  = liftReadListPrecDefault
+  liftReadList      = liftReadListDefault
+#  endif
+
+instance Eq1 U1 where
+  liftEq _ = \_ _ -> True
+
+instance Ord1 U1 where
+  liftCompare _ = \_ _ -> EQ
+
+instance Show1 U1 where
+  liftShowsPrec _ _ _ = \U1 -> showString "U1"
+
+instance Read1 U1 where
+#  if MIN_VERSION_base(4,10,0)
+  liftReadPrec _ _ =
+    parens (expectP (Ident "U1") *> pure U1)
+
+  liftReadListPrec  = liftReadListPrecDefault
+  liftReadList      = liftReadListDefault
+#  else
+  liftReadsPrec _ _ =
+    readPrec_to_S $
+    parens (expectP (Ident "U1") *> pure U1)
+#  endif
+
+instance Eq1 Par1 where
+  liftEq eq = \(Par1 a) (Par1 a') -> eq a a'
+
+instance Ord1 Par1 where
+  liftCompare cmp = \(Par1 a) (Par1 a') -> cmp a a'
+
+instance Show1 Par1 where
+  liftShowsPrec sp _ d = \(Par1 { unPar1 = a }) ->
+    showsSingleFieldRecordWith sp "Par1" "unPar1" d a
+
+instance Read1 Par1 where
+#  if MIN_VERSION_base(4,10,0)
+  liftReadPrec rp _ =
+    readSingleFieldRecordWith rp "Par1" "unPar1" Par1
+
+  liftReadListPrec  = liftReadListPrecDefault
+  liftReadList      = liftReadListDefault
+#  else
+  liftReadsPrec rp _ =
+    readPrec_to_S $
+    readSingleFieldRecordWith (readS_to_Prec rp) "Par1" "unPar1" Par1
+#  endif
+
+instance Eq1 f => Eq1 (Rec1 f) where
+  liftEq eq = \(Rec1 a) (Rec1 a') -> liftEq eq a a'
+
+instance Ord1 f => Ord1 (Rec1 f) where
+  liftCompare cmp = \(Rec1 a) (Rec1 a') -> liftCompare cmp a a'
+
+instance Show1 f => Show1 (Rec1 f) where
+  liftShowsPrec sp sl d = \(Rec1 { unRec1 = a }) ->
+    showsSingleFieldRecordWith (liftShowsPrec sp sl) "Rec1" "unRec1" d a
+
+instance Read1 f => Read1 (Rec1 f) where
+#  if MIN_VERSION_base(4,10,0)
+  liftReadPrec rp rl =
+    readSingleFieldRecordWith (liftReadPrec rp rl) "Rec1" "unRec1" Rec1
+
+  liftReadListPrec   = liftReadListPrecDefault
+  liftReadList       = liftReadListDefault
+#  else
+  liftReadsPrec rp rl =
+    readPrec_to_S $
+    readSingleFieldRecordWith
+      (readS_to_Prec (liftReadsPrec rp rl))
+      "Rec1"
+      "unRec1"
+      Rec1
+#  endif
+
+instance Eq c => Eq1 (K1 i c) where
+  liftEq _ = \(K1 a) (K1 a') -> a == a'
+
+instance Ord c => Ord1 (K1 i c) where
+  liftCompare _ = \(K1 a) (K1 a') -> compare a a'
+
+instance Show c => Show1 (K1 i c) where
+  liftShowsPrec _ _ d = \(K1 { unK1 = a }) ->
+    showsSingleFieldRecordWith showsPrec "K1" "unK1" d a
+
+instance Read c => Read1 (K1 i c) where
+#  if MIN_VERSION_base(4,10,0)
+  liftReadPrec _ _ = readData $
+    readSingleFieldRecordWith readPrec "K1" "unK1" K1
+
+  liftReadListPrec  = liftReadListPrecDefault
+  liftReadList      = liftReadListDefault
+#  else
+  liftReadsPrec _ _ =
+    readPrec_to_S $
+    readData $
+    readSingleFieldRecordWith readPrec "K1" "unK1" K1
+#  endif
+
+instance Eq1 f => Eq1 (M1 i c f) where
+  liftEq eq = \(M1 a) (M1 a') -> liftEq eq a a'
+
+instance Ord1 f => Ord1 (M1 i c f) where
+  liftCompare cmp = \(M1 a) (M1 a') -> liftCompare cmp a a'
+
+instance Show1 f => Show1 (M1 i c f) where
+  liftShowsPrec sp sl d = \(M1 { unM1 = a }) ->
+    showsSingleFieldRecordWith (liftShowsPrec sp sl) "M1" "unM1" d a
+
+instance Read1 f => Read1 (M1 i c f) where
+#  if MIN_VERSION_base(4,10,0)
+  liftReadPrec rp rl = readData $
+    readSingleFieldRecordWith (liftReadPrec rp rl) "M1" "unM1" M1
+
+  liftReadListPrec  = liftReadListPrecDefault
+  liftReadList      = liftReadListDefault
+#  else
+  liftReadsPrec rp rl =
+    readPrec_to_S $
+    readData $
+    readSingleFieldRecordWith
+      (readS_to_Prec (liftReadsPrec rp rl))
+      "M1"
+      "unM1"
+      M1
+#  endif
+
+instance (Eq1 f, Eq1 g) => Eq1 (f :+: g) where
+  liftEq eq = \lhs rhs -> case (lhs, rhs) of
+    (L1 a, L1 a') -> liftEq eq a a'
+    (R1 b, R1 b') -> liftEq eq b b'
+    _           -> False
+
+instance (Ord1 f, Ord1 g) => Ord1 (f :+: g) where
+  liftCompare cmp = \lhs rhs -> case (lhs, rhs) of
+    (L1 _, R1 _)  -> LT
+    (R1 _, L1 _)  -> GT
+    (L1 a, L1 a') -> liftCompare cmp a a'
+    (R1 b, R1 b') -> liftCompare cmp b b'
+
+instance (Show1 f, Show1 g) => Show1 (f :+: g) where
+  liftShowsPrec sp sl d = \x -> case x of
+    L1 a -> showsUnaryWith (liftShowsPrec sp sl) "L1" d a
+    R1 b -> showsUnaryWith (liftShowsPrec sp sl) "R1" d b
+
+instance (Read1 f, Read1 g) => Read1 (f :+: g) where
+#  if MIN_VERSION_base(4,10,0)
+  liftReadPrec rp rl = readData $
+    readUnaryWith (liftReadPrec rp rl) "L1" L1 <|>
+    readUnaryWith (liftReadPrec rp rl) "R1" R1
+
+  liftReadListPrec  = liftReadListPrecDefault
+  liftReadList      = liftReadListDefault
+#  else
+  liftReadsPrec rp rl =
+    readPrec_to_S $
+    readData $
+    readUnaryWith (readS_to_Prec (liftReadsPrec rp rl)) "L1" L1 <|>
+    readUnaryWith (readS_to_Prec (liftReadsPrec rp rl)) "R1" R1
+#  endif
+
+instance (Eq1 f, Eq1 g) => Eq1 (f :*: g) where
+  liftEq eq = \(f :*: g) (f' :*: g') -> liftEq eq f f' && liftEq eq g g'
+
+instance (Ord1 f, Ord1 g) => Ord1 (f :*: g) where
+  liftCompare cmp = \(f :*: g) (f' :*: g') -> liftCompare cmp f f' <> liftCompare cmp g g'
+
+instance (Show1 f, Show1 g) => Show1 (f :*: g) where
+  liftShowsPrec sp sl d = \(a :*: b) ->
+    showsBinaryOpWith
+      (liftShowsPrec sp sl)
+      (liftShowsPrec sp sl)
+      7
+      ":*:"
+      d
+      a
+      b
+
+instance (Read1 f, Read1 g) => Read1 (f :*: g) where
+#  if MIN_VERSION_base(4,10,0)
+  liftReadPrec rp rl = parens $ prec 6 $
+    readBinaryOpWith (liftReadPrec rp rl) (liftReadPrec rp rl) ":*:" (:*:)
+
+  liftReadListPrec  = liftReadListPrecDefault
+  liftReadList      = liftReadListDefault
+#  else
+  liftReadsPrec rp rl =
+    readPrec_to_S $
+    parens $ prec 6 $
+    readBinaryOpWith
+      (readS_to_Prec (liftReadsPrec rp rl))
+      (readS_to_Prec (liftReadsPrec rp rl))
+      ":*:"
+      (:*:)
+#  endif
+
+instance (Eq1 f, Eq1 g) => Eq1 (f :.: g) where
+  liftEq eq = \(Comp1 a) (Comp1 a') -> liftEq (liftEq eq) a a'
+
+instance (Ord1 f, Ord1 g) => Ord1 (f :.: g) where
+  liftCompare cmp = \(Comp1 a) (Comp1 a') -> liftCompare (liftCompare cmp) a a'
+
+instance (Show1 f, Show1 g) => Show1 (f :.: g) where
+  liftShowsPrec sp sl d = \(Comp1 { unComp1 = a }) ->
+    showsSingleFieldRecordWith
+      (liftShowsPrec (liftShowsPrec sp sl) (liftShowList sp sl))
+      "Comp1"
+      "unComp1"
+      d
+      a
+
+instance (Read1 f, Read1 g) => Read1 (f :.: g) where
+#  if MIN_VERSION_base(4,10,0)
+  liftReadPrec rp rl = readData $
+    readSingleFieldRecordWith
+      (liftReadPrec (liftReadPrec rp rl) (liftReadListPrec rp rl))
+      "Comp1"
+      "unComp1"
+      Comp1
+
+  liftReadListPrec  = liftReadListPrecDefault
+  liftReadList      = liftReadListDefault
+#  else
+  liftReadsPrec rp rl =
+    readPrec_to_S $
+    readData $
+    readSingleFieldRecordWith
+      (readS_to_Prec (liftReadsPrec (liftReadsPrec rp rl) (liftReadList rp rl)))
+      "Comp1"
+      "unComp1"
+      Comp1
+#  endif
+
+instance Eq1 UAddr where
+  -- NB cannot use eqAddr# because its module isn't safe
+  liftEq _ = \(UAddr a) (UAddr b) -> UAddr a == UAddr b
+
+instance Ord1 UAddr where
+  liftCompare _ = \(UAddr a) (UAddr b) -> compare (UAddr a) (UAddr b)
+
+instance Show1 UAddr where
+  liftShowsPrec _ _ = showsPrec
+
+-- NB no Read1 for URec (Ptr ()) because there's no Read for Ptr.
+
+instance Eq1 UChar where
+  liftEq _ = \(UChar a) (UChar b) -> UChar a == UChar b
+
+instance Ord1 UChar where
+  liftCompare _ = \(UChar a) (UChar b) -> compare (UChar a) (UChar b)
+
+instance Show1 UChar where
+  liftShowsPrec _ _ = showsPrec
+
+instance Eq1 UDouble where
+  liftEq _ = \(UDouble a) (UDouble b) -> UDouble a == UDouble b
+
+instance Ord1 UDouble where
+  liftCompare _ = \(UDouble a) (UDouble b) -> compare (UDouble a) (UDouble b)
+
+instance Show1 UDouble where
+  liftShowsPrec _ _ = showsPrec
+
+instance Eq1 UFloat where
+  liftEq _ = \(UFloat a) (UFloat b) -> UFloat a == UFloat b
+
+instance Ord1 UFloat where
+  liftCompare _ = \(UFloat a) (UFloat b) -> compare (UFloat a) (UFloat b)
+
+instance Show1 UFloat where
+  liftShowsPrec _ _ = showsPrec
+
+instance Eq1 UInt where
+  liftEq _ = \(UInt a) (UInt b) -> UInt a == UInt b
+
+instance Ord1 UInt where
+  liftCompare _ = \(UInt a) (UInt b) -> compare (UInt a) (UInt b)
+
+instance Show1 UInt where
+  liftShowsPrec _ _ = showsPrec
+
+instance Eq1 UWord where
+  liftEq _ = \(UWord a) (UWord b) -> UWord a == UWord b
+
+instance Ord1 UWord where
+  liftCompare _ = \(UWord a) (UWord b) -> compare (UWord a) (UWord b)
+
+instance Show1 UWord where
+  liftShowsPrec _ _ = showsPrec
+
+readSingleFieldRecordWith :: ReadPrec a -> String -> String -> (a -> t) -> ReadPrec t
+readSingleFieldRecordWith rp name field cons = parens $ prec 11 $ do
+  expectP $ Ident name
+  expectP $ Punc "{"
+  x <- readField field $ reset rp
+  expectP $ Punc "}"
+  pure $ cons x
+
+readBinaryOpWith
+  :: ReadPrec a
+  -> ReadPrec b
+  -> String
+  -> (a -> b -> t)
+  -> ReadPrec t
+readBinaryOpWith rp1 rp2 name cons =
+  cons <$> step rp1 <* expectP (Symbol name) <*> step rp2
+
+#  if !(MIN_VERSION_base(4,10,0))
+readData :: ReadPrec a -> ReadPrec a
+readData reader = parens $ prec 10 reader
+
+readUnaryWith :: ReadPrec a -> String -> (a -> t) -> ReadPrec t
+readUnaryWith rp name cons = do
+    expectP $ Ident name
+    x <- step rp
+    return $ cons x
+#  endif
+
+#  if !(MIN_VERSION_base(4,11,0))
+readField :: String -> ReadPrec a -> ReadPrec a
+readField fieldName readVal = do
+        expectP (Ident fieldName)
+        expectP (Punc "=")
+        readVal
+{-# NOINLINE readField #-}
+#  endif
+
+showsSingleFieldRecordWith :: (Int -> a -> ShowS) -> String -> String -> Int -> a -> ShowS
+showsSingleFieldRecordWith sp name field d x =
+  showParen (d > appPrec) $
+    showString name . showString " {" . showString field . showString " = " . sp 0 x . showChar '}'
+
+showsBinaryOpWith
+  :: (Int -> a -> ShowS)
+  -> (Int -> b -> ShowS)
+  -> Int
+  -> String
+  -> Int
+  -> a
+  -> b
+  -> ShowS
+showsBinaryOpWith sp1 sp2 opPrec name d x y = showParen (d >= opPrec) $
+  sp1 opPrec x . showChar ' ' . showString name . showChar ' ' . sp2 opPrec y
+
+instance Show (UAddr p) where
+  -- This Show instance would be equivalent to what deriving Show would generate,
+  -- but because deriving Show doesn't support Addr# fields we define it manually.
+  showsPrec d (UAddr x) =
+    showParen (d > appPrec)
+      (\y -> showString "UAddr {uAddr# = " (showsPrec 0 (Ptr x) (showChar '}' y)))
+# endif
 #endif
diff --git a/src/Data/Orphans/Prelude.hs b/src/Data/Orphans/Prelude.hs
--- a/src/Data/Orphans/Prelude.hs
+++ b/src/Data/Orphans/Prelude.hs
@@ -1,10 +1,13 @@
 {-# LANGUAGE CPP #-}
-
-#if __GLASGOW_HASKELL__ >= 706
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE ExplicitNamespaces #-}
+
+#if __GLASGOW_HASKELL__ >= 806
+{-# LANGUAGE NoStarIsType #-}
 #endif
 
-{-# OPTIONS_GHC -fno-warn-deprecations #-}
+{-# OPTIONS_GHC -Wno-deprecations #-}
 
 {-|
 Exports modules that Data.Orphans needs. Because Data.Orphans uses several modules
@@ -15,33 +18,48 @@
 Note that this module does not export any modules that could introduce name clashes.
 -}
 module Data.Orphans.Prelude
-#if MIN_VERSION_base(4,12,0)
+#if !defined(__GLASGOW_HASKELL__) || MIN_VERSION_base(4,21,0)
     () where
 #else
-    (module OrphansPrelude, realPart, imagPart) where
+    ( module OrphansPrelude
+    , realPart
+    , imagPart
+    , Typeable1
+    , Typeable2
+    , Typeable3
+    , Typeable4
+    , Typeable5
+    , Typeable6
+    , Typeable7
+    ) where
 
 import Control.Applicative as OrphansPrelude
-import Control.Arrow as OrphansPrelude hiding (first, loop, second)
+import Control.Arrow as OrphansPrelude hiding ((+++), first, loop, second)
 import Control.Category as OrphansPrelude hiding ((.), id)
 import Control.Concurrent.QSem as OrphansPrelude
 import Control.Monad as OrphansPrelude hiding (mapM, sequence)
 import Control.Monad.Fix as OrphansPrelude
+import Control.Monad.Zip as OrphansPrelude
 
+import Data.Bifunctor as OrphansPrelude
 import Data.Bits as OrphansPrelude
 import Data.Char as OrphansPrelude
 import Data.Complex as OrphansPrelude (Complex(..))
 import Data.Data as OrphansPrelude (Data(..), Constr, DataType, mkConstr, mkDataType)
 import Data.Fixed as OrphansPrelude
+import Data.Functor.Classes as OrphansPrelude
+import Data.Functor.Compose as OrphansPrelude
+import Data.Functor.Identity as OrphansPrelude
 import Data.Int as OrphansPrelude
-import Data.Ix as OrphansPrelude
 import Data.List as OrphansPrelude (genericLength)
-import Data.Monoid as OrphansPrelude
-  hiding ( Any(..)
-# if MIN_VERSION_base(4,5,0)
-         , (<>)
-# endif
-         )
+import Data.Monoid as OrphansPrelude hiding (Any(..), (<>))
+import Data.Ord as OrphansPrelude (Down(..))
+import Data.Proxy as OrphansPrelude
+import Data.Semigroup as OrphansPrelude (stimesMonoid)
 import Data.String as OrphansPrelude (IsString)
+import Data.Type.Coercion as OrphansPrelude (Coercion, TestCoercion)
+import Data.Type.Equality as OrphansPrelude ((:~:)(..), TestEquality(..))
+import Data.Typeable as OrphansPrelude (Typeable)
 import Data.Version as OrphansPrelude
 import Data.Word as OrphansPrelude
 
@@ -51,18 +69,28 @@
 import Foreign.Ptr as OrphansPrelude
 import Foreign.Storable as OrphansPrelude
 
+import GHC.Arr as OrphansPrelude (Ix(..))
 import GHC.Base as OrphansPrelude
 import GHC.Conc as OrphansPrelude
 import GHC.Desugar as OrphansPrelude (AnnotationWrapper)
+import GHC.Exts as OrphansPrelude (IsList(..), Ptr(..))
+import GHC.Fingerprint as OrphansPrelude
 import GHC.ForeignPtr as OrphansPrelude
+import GHC.GHCi as OrphansPrelude
 import GHC.IO.Buffer as OrphansPrelude
 import GHC.IO.BufferedIO as OrphansPrelude (BufferedIO)
 import GHC.IO.Device as OrphansPrelude (IODevice, IODeviceType(..), RawIO)
 import GHC.IO.Encoding as OrphansPrelude
+import GHC.IO.Encoding.Failure as OrphansPrelude
 import GHC.IO.Handle as OrphansPrelude
 import GHC.IO.Handle.Types as OrphansPrelude
+import GHC.Read as OrphansPrelude (expectP, paren)
 import GHC.Real as OrphansPrelude (Ratio(..), (%))
 import GHC.ST as OrphansPrelude
+import GHC.Show as OrphansPrelude (appPrec)
+import GHC.Stack as OrphansPrelude
+import GHC.Stats as OrphansPrelude
+import GHC.TypeLits as OrphansPrelude hiding (type (*))
 
 import Numeric as OrphansPrelude (showHex)
 
@@ -72,6 +100,8 @@
 import System.Posix.Types as OrphansPrelude
 
 import Text.Printf as OrphansPrelude
+import Text.Read as OrphansPrelude
+import Text.Read.Lex as OrphansPrelude (Number)
 
 import Unsafe.Coerce as OrphansPrelude (unsafeCoerce)
 
@@ -79,63 +109,36 @@
 import GHC.IO.Encoding.CodePage.Table as OrphansPrelude
 # endif
 
-# if MIN_VERSION_base(4,4,0)
-import Control.Monad.Zip as OrphansPrelude
-import GHC.Fingerprint as OrphansPrelude
-import GHC.IO.Encoding.Failure as OrphansPrelude
-
-#  if !defined(mingw32_HOST_OS) && !defined(__GHCJS__)
+# if !defined(mingw32_HOST_OS) && !defined(__GHCJS__)
 import GHC.Event as OrphansPrelude
-#  endif
-
-# if !(MIN_VERSION_base(4,10,0))
-import Data.Typeable.Internal as OrphansPrelude
 # endif
-# endif
 
-# if MIN_VERSION_base(4,5,0)
-import GHC.Stack as OrphansPrelude
-import GHC.Stats as OrphansPrelude
-# endif
-
-# if MIN_VERSION_base(4,6,0)
-import Data.Ord as OrphansPrelude (Down(..))
-import GHC.GHCi as OrphansPrelude
-import GHC.TypeLits as OrphansPrelude hiding (type (*))
-# else
-import GHC.Exts as OrphansPrelude (Down(..))
-# endif
-
-# if MIN_VERSION_base(4,6,0) && !(MIN_VERSION_base(4,8,2))
-import GHC.IP as OrphansPrelude
+# if !(MIN_VERSION_base(4,12,0))
+import Data.List.NonEmpty as OrphansPrelude (NonEmpty(..))
+import Data.Semigroup as OrphansPrelude (Semigroup(..))
 # endif
 
-# if MIN_VERSION_base(4,7,0)
-import Data.Proxy as OrphansPrelude
-import Data.Type.Coercion as OrphansPrelude (Coercion, TestCoercion)
-import Data.Type.Equality as OrphansPrelude ((:~:), TestEquality)
-import Text.Read.Lex as OrphansPrelude (Number)
-# else
-import Control.Concurrent.SampleVar as OrphansPrelude
+# if !(MIN_VERSION_base(4,11,0))
+import Data.Typeable ( Typeable1, Typeable2, Typeable3, Typeable4
+                     , Typeable5, Typeable6, Typeable7 )
 # endif
 
-# if MIN_VERSION_base(4,8,0)
-import Data.Bifunctor as OrphansPrelude
-import Data.Functor.Identity as OrphansPrelude
-#endif
-
-# if MIN_VERSION_base(4,9,0)
-import Data.Functor.Classes as OrphansPrelude
-import Data.List.NonEmpty as OrphansPrelude (NonEmpty(..))
-import Data.Semigroup as OrphansPrelude (Semigroup(..), stimesMonoid)
+# if MIN_VERSION_base(4,17,0) && !(MIN_VERSION_base(4,18,0))
+import GHC.Generics as OrphansPrelude ( Generic(..), Generic1(..)
+                                      , Generically(..), Generically1(..) )
 # endif
 
-# if MIN_VERSION_base(4,4,0)
 realPart, imagPart :: Complex a -> a
-#else
-realPart, imagPart :: RealFloat a => Complex a -> a
-#endif
 realPart (x :+ _) = x
 imagPart (_ :+ y) = y
 
+# if MIN_VERSION_base(4,11,0)
+type Typeable1 (a :: Type -> Type)                                                 = Typeable a
+type Typeable2 (a :: Type -> Type -> Type)                                         = Typeable a
+type Typeable3 (a :: Type -> Type -> Type -> Type)                                 = Typeable a
+type Typeable4 (a :: Type -> Type -> Type -> Type -> Type)                         = Typeable a
+type Typeable5 (a :: Type -> Type -> Type -> Type -> Type -> Type)                 = Typeable a
+type Typeable6 (a :: Type -> Type -> Type -> Type -> Type -> Type -> Type)         = Typeable a
+type Typeable7 (a :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type) = Typeable a
+# endif
 #endif
diff --git a/test/Control/Applicative/OrphansSpec.hs b/test/Control/Applicative/OrphansSpec.hs
--- a/test/Control/Applicative/OrphansSpec.hs
+++ b/test/Control/Applicative/OrphansSpec.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 module Control.Applicative.OrphansSpec (main, spec) where
 
 import Test.Hspec
@@ -17,7 +18,9 @@
   Identity f <*> x = f <$> x
 
 instance Monad Identity where
+#if !(MIN_VERSION_base(4,11,0))
   return = Identity
+#endif
   m >>= k  = k (runIdentity m)
 
 main :: IO ()
diff --git a/test/Data/Bits/OrphansSpec.hs b/test/Data/Bits/OrphansSpec.hs
--- a/test/Data/Bits/OrphansSpec.hs
+++ b/test/Data/Bits/OrphansSpec.hs
@@ -1,25 +1,18 @@
-{-# LANGUAGE CPP #-}
 module Data.Bits.OrphansSpec (main, spec) where
 
 import Test.Hspec
 
-#if MIN_VERSION_base(4,6,0)
 import Data.Bits
 import Data.Orphans ()
-#endif
 
 main :: IO ()
 main = hspec spec
 
 spec :: Spec
 spec =
-#if MIN_VERSION_base(4,6,0)
   describe "Bits Bool instance" $
     it "allows bitwise operations on Bools" $ do
       True  .&. True  `shouldBe` True
       True  .&. False `shouldBe` False
       False .&. True  `shouldBe` False
       False .&. False `shouldBe` False
-#else
-  return ()
-#endif
diff --git a/test/Data/Version/OrphansSpec.hs b/test/Data/Version/OrphansSpec.hs
--- a/test/Data/Version/OrphansSpec.hs
+++ b/test/Data/Version/OrphansSpec.hs
@@ -1,7 +1,5 @@
 {-# LANGUAGE CPP #-}
-#if MIN_VERSION_base(4,7,0)
 {-# LANGUAGE OverloadedLists #-}
-#endif
 module Data.Version.OrphansSpec (main, spec) where
 
 import Test.Hspec
@@ -18,14 +16,20 @@
   describe "Data Version instance" $
     it "allows obtaining a Version constructor" $
       dataTypeName (dataTypeOf (Version [1,2,3] [])) `shouldBe`
-#if __GLASGOW_HASKELL__ >= 801
+#if __GLASGOW_HASKELL__ >= 801 && __GLASGOW_HASKELL__ < 903
+        -- Some old versions of GHC incorrectly return "Version" due to
+        -- https://gitlab.haskell.org/ghc/ghc/-/issues/20371.
         "Version"
+#elif __GLASGOW_HASKELL__ >= 910
+        -- In GHC 9.10 and later, Version is defined in
+        -- GHC.Internal.Data.Version (in the ghc-internal library).
+        "GHC.Internal.Data.Version.Version"
 #else
+        -- In older versions of GHC, Version is defined in Data.Version (in the
+        -- base library).
         "Data.Version.Version"
 #endif
 
-#if MIN_VERSION_base(4,7,0)
   describe "IsList Version instance" $
     it "creates a Version from an Int list" $
       [1,2,3] `shouldBe` Version [1,2,3] []
-#endif
diff --git a/test/GHC/Fingerprint/OrphansSpec.hs b/test/GHC/Fingerprint/OrphansSpec.hs
--- a/test/GHC/Fingerprint/OrphansSpec.hs
+++ b/test/GHC/Fingerprint/OrphansSpec.hs
@@ -1,29 +1,22 @@
-{-# LANGUAGE CPP #-}
 module GHC.Fingerprint.OrphansSpec (main, spec) where
 
 import Test.Hspec
 
-#if MIN_VERSION_base(4,4,0)
 import Data.Orphans ()
 import Data.Word (Word64)
 import GHC.Fingerprint.Type
-#endif
 
 main :: IO ()
 main = hspec spec
 
 spec :: Spec
 spec =
-#if MIN_VERSION_base(4,4,0)
   describe "Fingerprint" $
     it "has a Show instance" $ do
       let w1, w2 :: Word64
           w1 = 0x0123456789abcdef
           w2 = 0x42
-          
+
           f :: Fingerprint
           f = Fingerprint w1 w2
       show f `shouldBe` "0123456789abcdef0000000000000042"
-#else
-  return ()
-#endif
diff --git a/test/System/Posix/Types/OrphansSpec.hs b/test/System/Posix/Types/OrphansSpec.hs
--- a/test/System/Posix/Types/OrphansSpec.hs
+++ b/test/System/Posix/Types/OrphansSpec.hs
@@ -7,7 +7,7 @@
 import           Test.Hspec
 
 #if defined(HTYPE_DEV_T)
-import           Control.Applicative (liftA2)
+import qualified Control.Applicative as App (liftA2)
 
 import           Data.Bits (Bits(..))
 import           Data.Orphans ()
@@ -16,7 +16,7 @@
 import           System.Posix.Types
 
 import           Test.Hspec.QuickCheck (prop)
-import           Test.QuickCheck (NonZero(..))
+import           Test.QuickCheck (NonNegative(..), NonZero(..))
 #endif
 
 main :: IO ()
@@ -39,17 +39,17 @@
     prop "implements rotate" $
       pred2IntHDev rotate rotate
     prop "implements setBit" $
-      pred2IntHDev setBit setBit
+      pred2NonNegIntHDev setBit setBit
     prop "implements clearBit" $
-      pred2IntHDev clearBit clearBit
+      pred2NonNegIntHDev clearBit clearBit
     prop "implements complementBit" $
-      pred2IntHDev complementBit complementBit
+      pred2NonNegIntHDev complementBit complementBit
     prop "implements testBit" $
-      pred2IntEq testBit testBit
+      pred2NonNegIntEq testBit testBit
     prop "implements complement" $
       pred1HDevHDev complement complement
     prop "implements bit" $
-      pred1IntHDev bit bit
+      pred1NonNegIntHDev bit bit
     prop "implements bitSize" $
       pred1HDevEq bitSize bitSize
     prop "implements isSigned" $
@@ -82,7 +82,7 @@
             -> (a -> b)
             -> (a -> c)
             -> a -> d
-pred1Common = liftA2
+pred1Common = App.liftA2
 
 pred1HDev :: (b -> c -> Bool)
           -> (CDev -> b)
@@ -96,8 +96,8 @@
 pred1HDevHDev :: (CDev -> CDev) -> (HDev -> HDev) -> HDev -> Bool
 pred1HDevHDev = pred1HDev eqCDevHDev
 
-pred1IntHDev :: (Int -> CDev) -> (Int -> HDev) -> Int -> Bool
-pred1IntHDev = pred1Common eqCDevHDev
+pred1NonNegIntHDev :: (Int -> CDev) -> (Int -> HDev) -> NonNegative Int -> Bool
+pred1NonNegIntHDev f g (NonNegative x) = pred1Common eqCDevHDev f g x
 
 pred2Common :: (c -> d -> e)
             -> (a -> b -> c)
@@ -138,11 +138,16 @@
              -> HDev -> Int -> Bool
 pred2IntHDev = pred2Int eqCDevHDev
 
-pred2IntEq :: Eq a
-           => (CDev -> Int -> a)
-           -> (HDev -> Int -> a)
-           -> HDev -> Int -> Bool
-pred2IntEq = pred2Int (==)
+pred2NonNegIntHDev :: (CDev -> Int -> CDev)
+                   -> (HDev -> Int -> HDev)
+                   -> HDev -> NonNegative Int -> Bool
+pred2NonNegIntHDev f g hDev (NonNegative x) = pred2Int eqCDevHDev f g hDev x
+
+pred2NonNegIntEq :: Eq a
+                 => (CDev -> Int -> a)
+                 -> (HDev -> Int -> a)
+                 -> HDev -> NonNegative Int -> Bool
+pred2NonNegIntEq f g hDev (NonNegative x) = pred2Int (==) f g hDev x
 #else
 spec :: Spec
 spec = return ()