diff --git a/CHANGES.md b/CHANGES.md
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,16 +1,44 @@
 Changelog for singletons project
 ================================
 
+2.0
+---
+
+* Instance promotion now works properly -- it was quite buggy in 1.0.
+
+* Classes and instances can now be singletonized.
+
+* Limited support for functional dependencies.
+
+* We now have promoted and singletonized versions of `Enum`, as well as `Bounded`.
+
+* Deriving `Enum` is also now supported.
+
+* Ditto for `Num`, which includes an instance for `Nat`, naturally.
+
+* Promoting a literal number now uses overloaded literals at the type level,
+using a type-level `FromInteger` in the type-level `Num` class.
+
+* Better support for dealing with constraints. Some previously-unsingletonizable
+functions that have constrained parameters now work.
+
+* No more orphan `Quasi` instances!
+
+* Support for functions of arity 8 (instead of the old limit, 7).
+
+* Full support for fixity declarations.
+
+* A raft of bugfixes.
+
 1.1.2.1
 -------
 
 Fix bug #116, thus allowing locally-declared symbols to be used in GHC 7.10.
 
-
 1.1.2
 -----
 
-Fix warnings and Haddock failure with GHC 7.10.1.
+* No more GHC 7.8.2 support -- you must have GHC 7.8.3.
 
 1.1.1
 -----
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-singletons 1.0
+singletons 2.0
 ==============
 
 [![Build Status](https://travis-ci.org/goldfirere/singletons.svg?branch=master)](https://travis-ci.org/goldfirere/singletons)
@@ -12,8 +12,9 @@
 programming with singletons_, is available
 [here](http://www.cis.upenn.edu/~eir/papers/2012/singletons/paper.pdf) and will
 be referenced in this documentation as the "singletons paper". A follow-up
-paper, _Promoting Functions to Type Families in Haskell_, will be available
-online Real Soon Now and will be referenced in this documentation as the
+paper, _Promoting Functions to Type Families in Haskell_, is available
+[here](http://www.cis.upenn.edu/~eir/papers/2014/promotion/promotion.pdf)
+and will be referenced in this documentation as the
 "promotion paper".
 
 Purpose of the singletons library
@@ -32,9 +33,8 @@
 Compatibility
 -------------
 
-The singletons library requires GHC 7.8.2 or greater. We plan to restore GHC
-7.6.3 support, but no promises as to when will this happen. Any code that uses
-the singleton generation primitives needs to enable a long list of GHC
+The singletons library requires GHC 7.10.2 or greater. Any code that uses the
+singleton generation primitives needs to enable a long list of GHC
 extensions. This list includes, but is not necessarily limited to, the
 following:
 
@@ -50,6 +50,8 @@
 * `RankNTypes`
 * `UndecidableInstances`
 * `FlexibleInstances`
+* `InstanceSigs`
+* `DefaultSignatures`
 
 Modules for singleton types
 ---------------------------
@@ -74,18 +76,11 @@
 `Data.Singletons.Decide` exports type classes for propositional equality.
 
 `Data.Singletons.TypeLits` exports definitions for working with `GHC.TypeLits`.
-In GHC 7.6.3, `Data.Singletons.TypeLits` defines and exports `KnownNat` and
-`KnownSymbol`, which are part of `GHC.TypeLits` in GHC 7.8. This makes
-cross-version support a little easier.
 
 `Data.Singletons.Void` exports a `Void` type, shamelessly copied from
 Edward Kmett's `void` package, but without the great many package dependencies
 in `void`.
 
-`Data.Singletons.Types` exports a few type-level definitions that are in
-`base` for GHC 7.8, but not in GHC 7.6.3. By importing this package, users
-of both GHC versions can access these definitions.
-
 Modules for function promotion
 ------------------------------
 
@@ -251,8 +246,90 @@
 `Bool`, `Either`, `List`, `Maybe` and `Tuple`). These provide promoted versions
 of function found in GHC's base library.
 
+Note that GHC resolves variable names in Template Haskell quotes. You cannot
+then use an undefined identifier in a quote, making idioms like this not
+work:
+```haskell
+type family Foo a where ...
+$(promote [d| ... foo x ... |])
+```
+In this example, `foo` would be out of scope.
+
 Refer to the promotion paper for more details on function promotion.
 
+Classes and instances
+---------------------
+
+This is best understood by example. Let's look at a stripped down `Ord`:
+
+```haskell
+class Eq a => Ord a where
+  compare :: a -> a -> Ordering
+  (<)     :: a -> a -> Bool
+  x < y = case x `compare` y of
+            LT -> True
+	    EQ -> False
+	    GT -> False
+```
+
+This class gets promoted to a "kind class" thus:
+
+```haskell
+class (kproxy ~ 'KProxy, PEq kproxy) => POrd (kproxy :: KProxy a) where
+  type Compare (x :: a) (y :: a) :: Ordering
+  type (:<)    (x :: a) (y :: a) :: Bool
+  type x :< y = ... -- promoting `case` is yucky.
+```
+
+Note that default method definitions become default associated type family
+instances. This works out quite nicely.
+
+We also get this singleton class:
+
+```haskell
+class (kproxy ~ 'KProxy, SEq kproxy) => SOrd (kproxy :: KProxy a) where
+  sCompare :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (Compare x y)
+  (%:<)    :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (x :< y)
+
+  default (%:<) :: forall (x :: a) (y :: a).
+                   ((x :< y) ~ {- RHS from (:<) above -})
+		=> Sing x -> Sing y -> Sing (x :< y)
+  x %:< y = ...  -- this is a bit yucky too
+```
+
+Note that a singletonized class needs to use `default` signatures, because
+type-checking the default body requires that the default associated type
+family instance was used in the promoted class. The extra equality constraint
+on the default signature asserts this fact to the type-checker.
+
+Instances work roughly similarly.
+
+```haskell
+instance Ord Bool where
+  compare False False = EQ
+  compare False True  = LT
+  compare True  False = GT
+  compare True  True  = EQ
+
+instance POrd ('KProxy :: KProxy Bool) where
+  type Compare 'False 'False = 'EQ
+  type Compare 'False 'True  = 'LT
+  type Compare 'True  'False = 'GT
+  type Compare 'True  'True  = 'EQ
+
+instance SOrd ('KProxy :: KProxy Bool) where
+  sCompare :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (Compare x y)
+  sCompare SFalse SFalse = SEQ
+  sCompare SFalse STrue  = SLT
+  sCompare STrue  SFalse = SGT
+  sCompare STrue  STrue  = SEQ
+```
+
+The only interesting bit here is the instance signature. It's not necessary
+in such a simple scenario, but more complicated functions need to refer to
+scoped type variables, which the instance signature can bring into scope.
+The defaults all just work.
+
 On names
 --------
 
@@ -310,6 +387,20 @@
    symbols: `:+$`, `:+$$`, `:+$$$`
 
 
+7. original class: `Num`
+
+   promoted class: `PNum`
+
+   singleton class: `SNum`
+
+
+8. original class: `~>`
+
+   promoted class: `#~>`
+
+   singleton class: `:%~>`
+
+
 Special names
 -------------
 
@@ -376,24 +467,25 @@
 * sections
 * undefined
 * error
-* deriving Eq
+* deriving `Eq`, `Ord`, `Bounded`, and `Enum`
 * class constraints (though these sometimes fail with `let`, `lambda`, and `case`)
-* literals (for `Nat` and `Symbol`)
+* literals (for `Nat` and `Symbol`), including overloaded number literals
 * unboxed tuples (which are treated as normal tuples)
 * records
 * pattern guards
 * case
 * let
 * lambda expressions
+* `!` and `~` patterns (silently but successfully ignored during promotion)
+* class and instance declarations
+* functional dependencies (with limitations -- see below)
 
 The following constructs are supported for promotion but not singleton generation:
 
-* `!` and `~` patterns (silently but successfully ignored during promotion)
-* class and instance declarations
-* deriving of promoted `Eq`, `Ord` and `Bounded` instances
 * scoped type variables
-* overlapping patterns (GHC 7.8.2+ only). Note that overlapping patterns are
-  sometime not obvious. For example `filter` function does not singletonize due
+* overlapping patterns. Note that overlapping patterns are
+  sometimes not obvious. For example, the `filter` function does not
+  singletonize due
   to overlapping patterns:
 ```haskell
 filter :: (a -> Bool) -> [a] -> [a]
@@ -410,8 +502,8 @@
 * list comprehensions
 * do
 * arithmetic sequences
-* datatypes that store arrows
-* literals
+* datatypes that store arrows, `Nat`, or `Symbol`
+* literals (limited support)
 
 Why are these out of reach? First two depend on monads, which mention a
 higher-kinded type variable. GHC does not support higher-sorted kind variables,
@@ -435,6 +527,10 @@
 `Nat`. Since `Nat` does not exist at the term level it will only be possible to
 use the promoted definition, but not the original, term-level one.
 
+This is the same line of reasoning that forbids the use of `Nat` or `Symbol`
+in datatype definitions. But, see [this bug
+report](https://github.com/goldfirere/singletons/issues/76) for a workaround.
+
 Support for `*`
 ---------------
 
@@ -462,36 +558,12 @@
 Known bugs
 ----------
 
-* Due to GHC bug #9081 deriving of hand-written instances of `Ord`, `Eq` and
-  `Bounded` is not supported. Your only option here is to have these instances
-  derived automatically.
-* Fixity declarations don't promote due to GHC bug #9066.
-* Instances with overlapping patterns don't promote. This will be fixed Real
-  Soon Now.
-* Top-level eta-reduced patterns don't singletonize
 * Record updates don't singletonize
-
-Changes from earlier versions
------------------------------
-
-singletons 1.0 provides promotion mechanism that supports case expressions, let
-statements, anonymous functions, higher order functions and many other
-features. This version of the library was published together with the promotion
-paper.
-
-singletons 0.9 contains a bit of an API change from previous versions. Here is
-a summary:
-
-* There are no more "smart" constructors. Those were necessary because each
-singleton used to carry both explicit and implicit versions of any children
-nodes. However, this leads to exponential overhead! Now, the magic (i.e., a
-use of `unsafeCoerce`) in `singInstance` gets rid of the need for storing
-implicit singletons. The smart constructors did some of the work of managing
-the stored implicits, so they are no longer needed.
-
-* `SingE` and `SingRep` are gone. If you need to carry an implicit singleton,
-use `SingI`. Otherwise, you probably want `SingKind`.
-
-* The Template Haskell functions are now exported from `Data.Singletons.TH`.
-
-* The Prelude singletons are now exported from `Data.Singletons.Prelude`.
+* In obscure scenarios, GHC "forgets" constraints on functions. This should
+  happen only with certain uses where the constraint is needed inside of a
+  `case` or lambda-expression. Having type inference on result types nearby
+  makes this more likely to bite.
+* Inference dependent on functional dependencies is unpredictably bad. The
+  problem is that a use of an associated type family tied to a class with
+  fundeps doesn't provoke the fundep to kick in. This is GHC's problem, in
+  the end.
diff --git a/singletons.cabal b/singletons.cabal
--- a/singletons.cabal
+++ b/singletons.cabal
@@ -1,5 +1,5 @@
 name:           singletons
-version:        1.1.2.1
+version:        2.0
                 -- Remember to bump version in the Makefile as well
 cabal-version:  >= 1.10
 synopsis:       A framework for generating singleton types
@@ -9,17 +9,17 @@
 maintainer:     Richard Eisenberg <eir@cis.upenn.edu>, Jan Stolarek <jan.stolarek@p.lodz.pl>
 bug-reports:    https://github.com/goldfirere/singletons/issues
 stability:      experimental
-tested-with:    GHC ==7.8.3
+tested-with:    GHC >= 7.10.2
 extra-source-files: README.md, CHANGES.md,
                     tests/compile-and-dump/buildGoldenFiles.awk,
                     tests/compile-and-dump/GradingClient/*.hs,
                     tests/compile-and-dump/InsertionSort/*.hs,
                     tests/compile-and-dump/Promote/*.hs,
                     tests/compile-and-dump/Singletons/*.hs
-                    tests/compile-and-dump/GradingClient/*.ghc78.template,
-                    tests/compile-and-dump/InsertionSort/*.ghc78.template,
-                    tests/compile-and-dump/Promote/*.ghc78.template,
-                    tests/compile-and-dump/Singletons/*.ghc78.template
+                    tests/compile-and-dump/GradingClient/*.ghc710.template,
+                    tests/compile-and-dump/InsertionSort/*.ghc710.template,
+                    tests/compile-and-dump/Promote/*.ghc710.template,
+                    tests/compile-and-dump/Singletons/*.ghc710.template
 license:        BSD3
 license-file:   LICENSE
 build-type:     Simple
@@ -38,17 +38,18 @@
 source-repository this
   type:     git
   location: https://github.com/goldfirere/singletons.git
-  tag:      v1.1.2.1
+  tag:      v2.0
 
 library
   hs-source-dirs:     src
-  build-depends:      base >= 4.7 && < 5,
-                      mtl >= 2.1.1,
+  build-depends:      base >= 4.7.0.1 && < 5,
+                      mtl >= 2.1.2,
                       template-haskell,
                       containers >= 0.5,
-                      th-desugar >= 1.5.2 && < 1.6
+                      th-desugar >= 1.5.4.1 && < 1.6,
+                      syb >= 0.4
   default-language:   Haskell2010
-  default-extensions: TemplateHaskell
+  other-extensions:   TemplateHaskell
         -- TemplateHaskell must be listed in cabal file to work with
         -- ghc7.8
   exposed-modules:    Data.Singletons,
@@ -59,10 +60,12 @@
                       Data.Singletons.Prelude.Base,
                       Data.Singletons.Prelude.Bool,
                       Data.Singletons.Prelude.Either,
+                      Data.Singletons.Prelude.Enum,
                       Data.Singletons.Prelude.Eq,
                       Data.Singletons.Prelude.Ord,
                       Data.Singletons.Prelude.List,
                       Data.Singletons.Prelude.Maybe,
+                      Data.Singletons.Prelude.Num
                       Data.Singletons.Prelude.Tuple,
                       Data.Promotion.Prelude,
                       Data.Promotion.TH,
@@ -71,24 +74,26 @@
                       Data.Promotion.Prelude.Either,
                       Data.Promotion.Prelude.Eq,
                       Data.Promotion.Prelude.Ord,
-                      Data.Promotion.Prelude.Bounded,
+                      Data.Promotion.Prelude.Enum,
                       Data.Promotion.Prelude.List,
                       Data.Promotion.Prelude.Maybe,
+                      Data.Promotion.Prelude.Num,
                       Data.Promotion.Prelude.Tuple,
-                      Data.Singletons.Types,
                       Data.Singletons.TypeLits,
                       Data.Singletons.Decide,
-                      Data.Singletons.Void,
                       Data.Singletons.SuppressUnusedWarnings
 
-  other-modules:      Data.Singletons.Promote,
+  other-modules:      Data.Singletons.Deriving.Infer,
+                      Data.Singletons.Deriving.Bounded,
+                      Data.Singletons.Deriving.Enum,
+                      Data.Singletons.Deriving.Ord,
+                      Data.Singletons.Promote,
                       Data.Singletons.Promote.Monad,
                       Data.Singletons.Promote.Eq,
-                      Data.Singletons.Promote.Ord,
-                      Data.Singletons.Promote.Bounded,
                       Data.Singletons.Promote.Type,
                       Data.Singletons.Promote.Defun,
                       Data.Singletons.Util,
+                      Data.Singletons.Partition,
                       Data.Singletons.Prelude.Instances,
                       Data.Singletons.Names,
                       Data.Singletons.Single.Monad,
@@ -96,6 +101,7 @@
                       Data.Singletons.Single.Eq,
                       Data.Singletons.Single.Data,
                       Data.Singletons.Single,
+                      Data.Singletons.TypeLits.Internal,
                       Data.Singletons.Syntax
 
   ghc-options:        -Wall
@@ -108,10 +114,10 @@
   main-is:            SingletonsTestSuite.hs
   other-modules:      SingletonsTestSuiteUtils
 
-  build-depends:      base >= 4.6 && < 5,
-                      constraints,
+  build-depends:      base >= 4.7.0.1 && < 5,
                       filepath >= 1.3,
                       process >= 1.1,
                       tasty >= 0.6,
                       tasty-golden >= 2.2,
-                      Cabal >= 1.16
+                      Cabal >= 1.16,
+                      directory >= 1
diff --git a/src/Data/Promotion/Prelude.hs b/src/Data/Promotion/Prelude.hs
--- a/src/Data/Promotion/Prelude.hs
+++ b/src/Data/Promotion/Prelude.hs
@@ -32,16 +32,19 @@
   -- * Promoted comparisons
   module Data.Promotion.Prelude.Ord,
 
-  -- * Promoted bounds
-  module Data.Promotion.Prelude.Bounded,
+  -- * Promoted enumerations
+  -- | As a matter of convenience, the promoted Prelude does /not/ export
+  -- promoted @succ@ and @pred@, due to likely conflicts with
+  -- unary numbers. Please import 'Data.Promotion.Prelude.Enum' directly if
+  -- you want these.
+  module Data.Promotion.Prelude.Enum,
 
-  -- * Promoted arithmetic operations
-  Nat, (:+), (:-), (:*), (:^),
+  -- * Promoted numbers
+  module Data.Promotion.Prelude.Num,
 
   -- ** Miscellaneous functions
   Id, Const, (:.), type ($), type ($!), Flip, AsTypeOf, Until, Seq,
 
-
   -- * List operations
   Map, (:++), Filter,
   Head, Last, Tail, Init, Null, Length, (:!!),
@@ -68,7 +71,7 @@
   Zip, Zip3, ZipWith, ZipWith3, Unzip, Unzip3,
 
   -- * Other datatypes
-  KProxy(..),
+  Proxy(..), KProxy(..),
 
   -- * Defunctionalization symbols
   FalseSym0, TrueSym0,
@@ -92,8 +95,7 @@
   CurrySym0, CurrySym1, CurrySym2, CurrySym3,
   UncurrySym0, UncurrySym1, UncurrySym2,
 
-  (:+$), (:+$$), (:-$), (:-$$),
-  (:*$), (:*$$), (:^$), (:^$$),
+  (:^$), (:^$$),
 
   IdSym0, IdSym1, ConstSym0, ConstSym1, ConstSym2,
   (:.$), (:.$$), (:.$$$),
@@ -151,7 +153,7 @@
   (:!!$), (:!!$$), (:!!$$$),
   ) where
 
-import Data.Singletons.Types ( KProxy(..) )
+import Data.Proxy ( Proxy(..), KProxy(..) )
 import Data.Promotion.Prelude.Base
 import Data.Promotion.Prelude.Bool
 import Data.Promotion.Prelude.Either
@@ -160,5 +162,7 @@
 import Data.Promotion.Prelude.Tuple
 import Data.Promotion.Prelude.Eq
 import Data.Promotion.Prelude.Ord
-import Data.Promotion.Prelude.Bounded
+import Data.Promotion.Prelude.Enum
+  hiding (Succ, Pred, SuccSym0, SuccSym1, PredSym0, PredSym1)
+import Data.Promotion.Prelude.Num
 import Data.Singletons.TypeLits
diff --git a/src/Data/Promotion/Prelude/Base.hs b/src/Data/Promotion/Prelude/Base.hs
--- a/src/Data/Promotion/Prelude/Base.hs
+++ b/src/Data/Promotion/Prelude/Base.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, TemplateHaskell, KindSignatures, PolyKinds, TypeOperators,
+{-# LANGUAGE TemplateHaskell, KindSignatures, PolyKinds, TypeOperators,
              DataKinds, ScopedTypeVariables, TypeFamilies, GADTs,
              UndecidableInstances #-}
 
@@ -29,14 +29,14 @@
   -- * Defunctionalization symbols
   FoldrSym0, FoldrSym1, FoldrSym2, FoldrSym3,
   MapSym0, MapSym1, MapSym2,
-  (:++$), (:++$$),
+  (:++$), (:++$$), (:++$$$),
   OtherwiseSym0,
   IdSym0, IdSym1,
   ConstSym0, ConstSym1, ConstSym2,
-  (:.$), (:.$$), (:.$$$),
+  (:.$), (:.$$), (:.$$$), (:.$$$$),
   type ($$), type ($$$), type ($$$$),
   type ($!$), type ($!$$), type ($!$$$),
-  FlipSym0, FlipSym1, FlipSym2,
+  FlipSym0, FlipSym1, FlipSym2, FlipSym3,
   UntilSym0, UntilSym1, UntilSym2, UntilSym3,
   AsTypeOfSym0, AsTypeOfSym1, AsTypeOfSym2,
   SeqSym0, SeqSym1, SeqSym2
diff --git a/src/Data/Promotion/Prelude/Bounded.hs b/src/Data/Promotion/Prelude/Bounded.hs
deleted file mode 100644
--- a/src/Data/Promotion/Prelude/Bounded.hs
+++ /dev/null
@@ -1,34 +0,0 @@
-{-# LANGUAGE TemplateHaskell, DataKinds, PolyKinds, ScopedTypeVariables,
-             TypeFamilies, TypeOperators, GADTs, UndecidableInstances,
-             FlexibleContexts, DefaultSignatures #-}
-
------------------------------------------------------------------------------
--- |
--- Module      :  Data.Promotion.Prelude.Bounded
--- Copyright   :  (C) 2014 Jan Stolarek
--- License     :  BSD-style (see LICENSE)
--- Maintainer  :  Jan Stolarek (jan.stolarek@p.lodz.pl)
--- Stability   :  experimental
--- Portability :  non-portable
---
--- Defines the promoted version of Bounded, 'PBounded'
---
------------------------------------------------------------------------------
-
-module Data.Promotion.Prelude.Bounded (
-  PBounded(..),
-
-  -- ** Defunctionalization symbols
-  MaxBoundSym0,
-  MinBoundSym0
-  ) where
-
-import Data.Singletons.Promote
-import Data.Singletons.Util
-
-$(promoteOnly [d|
-  class Bounded a  where
-    minBound, maxBound :: a
-  |])
-
-$(promoteBoundedInstances boundedBasicTypes)
diff --git a/src/Data/Promotion/Prelude/Enum.hs b/src/Data/Promotion/Prelude/Enum.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Promotion/Prelude/Enum.hs
@@ -0,0 +1,36 @@
+{-# LANGUAGE TemplateHaskell, PolyKinds, DataKinds, TypeFamilies,
+             UndecidableInstances, GADTs #-}
+
+-- Suppress orphan instance warning for PEnum KProxy. This will go away once #25
+-- is fixed and instance declaration for Enum Nat is moved to
+-- Data.Singletons.Prelude.Enum module.
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Promotion.Prelude.Enum
+-- Copyright   :  (C) 2014 Jan Stolarek, Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Jan Stolarek (jan.stolarek@p.lodz.pl)
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Exports promoted versions of 'Enum' and 'Bounded'
+--
+-----------------------------------------------------------------------------
+
+module Data.Promotion.Prelude.Enum (
+  PBounded(..), PEnum(..),
+
+  -- ** Defunctionalization symbols
+  MinBoundSym0,
+  MaxBoundSym0,
+  SuccSym0, SuccSym1,
+  PredSym0, PredSym1,
+  ToEnumSym0, ToEnumSym1,
+  FromEnumSym0, FromEnumSym1,
+  EnumFromToSym0, EnumFromToSym1, EnumFromToSym2,
+  EnumFromThenToSym0, EnumFromThenToSym1, EnumFromThenToSym2,
+  EnumFromThenToSym3
+  ) where
+
+import Data.Singletons.Prelude.Enum
diff --git a/src/Data/Promotion/Prelude/List.hs b/src/Data/Promotion/Prelude/List.hs
--- a/src/Data/Promotion/Prelude/List.hs
+++ b/src/Data/Promotion/Prelude/List.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, TypeOperators, DataKinds, PolyKinds, TypeFamilies,
+{-# LANGUAGE TypeOperators, DataKinds, PolyKinds, TypeFamilies,
              TemplateHaskell, GADTs, UndecidableInstances, RankNTypes,
              ScopedTypeVariables, MultiWayIf #-}
 
@@ -104,7 +104,7 @@
   NilSym0,
   (:$), (:$$), (:$$$),
 
-  (:++$$), (:++$), HeadSym0, HeadSym1, LastSym0, LastSym1,
+  (:++$$$), (:++$$), (:++$), HeadSym0, HeadSym1, LastSym0, LastSym1,
   TailSym0, TailSym1, InitSym0, InitSym1, NullSym0, NullSym1,
 
   MapSym0, MapSym1, MapSym2, ReverseSym0, ReverseSym1,
@@ -148,7 +148,7 @@
   ZipSym0, ZipSym1, ZipSym2,
   Zip3Sym0, Zip3Sym1, Zip3Sym2, Zip3Sym3,
   ZipWithSym0, ZipWithSym1, ZipWithSym2, ZipWithSym3,
-  ZipWith3Sym0, ZipWith3Sym1, ZipWith3Sym2, ZipWith3Sym3,
+  ZipWith3Sym0, ZipWith3Sym1, ZipWith3Sym2, ZipWith3Sym3, ZipWith3Sym4,
   UnzipSym0, UnzipSym1,
   Unzip3Sym0, Unzip3Sym1,
   Unzip4Sym0, Unzip4Sym1,
@@ -183,7 +183,7 @@
   DropWhileEndSym0, DropWhileEndSym1, DropWhileEndSym2,
   SpanSym0, SpanSym1, SpanSym2,
   BreakSym0, BreakSym1, BreakSym2,
-  StripPrefixSym0, StripPrefixSym1,
+  StripPrefixSym0, StripPrefixSym1, StripPrefixSym2,
   MaximumSym0, MaximumSym1,
   MinimumSym0, MinimumSym1,
   GroupSym0, GroupSym1,
@@ -205,10 +205,10 @@
   Zip6Sym0, Zip6Sym1, Zip6Sym2, Zip6Sym3, Zip6Sym4, Zip6Sym5, Zip6Sym6,
   Zip7Sym0, Zip7Sym1, Zip7Sym2, Zip7Sym3, Zip7Sym4, Zip7Sym5, Zip7Sym6, Zip7Sym7,
 
-  ZipWith4Sym0, ZipWith4Sym1, ZipWith4Sym2, ZipWith4Sym3, ZipWith4Sym4,
-  ZipWith5Sym0, ZipWith5Sym1, ZipWith5Sym2, ZipWith5Sym3, ZipWith5Sym4, ZipWith5Sym5,
-  ZipWith6Sym0, ZipWith6Sym1, ZipWith6Sym2, ZipWith6Sym3, ZipWith6Sym4, ZipWith6Sym5, ZipWith6Sym6,
-  ZipWith7Sym0, ZipWith7Sym1, ZipWith7Sym2, ZipWith7Sym3, ZipWith7Sym4, ZipWith7Sym5, ZipWith7Sym6, ZipWith7Sym7,
+  ZipWith4Sym0, ZipWith4Sym1, ZipWith4Sym2, ZipWith4Sym3, ZipWith4Sym4, ZipWith4Sym5,
+  ZipWith5Sym0, ZipWith5Sym1, ZipWith5Sym2, ZipWith5Sym3, ZipWith5Sym4, ZipWith5Sym5, ZipWith5Sym6,
+  ZipWith6Sym0, ZipWith6Sym1, ZipWith6Sym2, ZipWith6Sym3, ZipWith6Sym4, ZipWith6Sym5, ZipWith6Sym6, ZipWith6Sym7,
+  ZipWith7Sym0, ZipWith7Sym1, ZipWith7Sym2, ZipWith7Sym3, ZipWith7Sym4, ZipWith7Sym5, ZipWith7Sym6, ZipWith7Sym7, ZipWith7Sym8,
 
   NubSym0, NubSym1,
   NubBySym0, NubBySym1, NubBySym2,
@@ -225,19 +225,20 @@
   ) where
 
 import Data.Singletons.Prelude.Base
-import Data.Singletons.Prelude.Bool
 import Data.Singletons.Prelude.Eq
 import Data.Promotion.Prelude.Ord
 import Data.Singletons.Prelude.List
 import Data.Singletons.Prelude.Maybe
 import Data.Singletons.Prelude.Tuple
+import Data.Singletons.Prelude.Bool
 import Data.Singletons.TH
 import Data.Singletons.TypeLits
+import Data.Singletons.Prelude.Num
 
 import Data.Maybe (listToMaybe)
 -- these imports are required fir functions that singletonize but are used
 -- in this module by a function that can't be singletonized
-import Data.List  (deleteBy, sortBy, insertBy)
+import Data.List  (sortBy, insertBy, deleteBy)
 
 $(promoteOnly [d|
 -- Can't be promoted because of limitations of Int promotion
@@ -327,15 +328,14 @@
 --  splitAt                :: Int -> [a] -> ([a],[a])
 --  splitAt n xs           =  (take n xs, drop n xs)
 
-  -- Implementation changed to use case expression to work around #60
   take                   :: Nat -> [a] -> [a]
+  take n _      | n <= 0 =  []
   take _ []              =  []
-  take 0 (_:_)           =  []
   take n (x:xs)          =  x : take (n-1) xs
 
   drop                   :: Nat -> [a] -> [a]
+  drop n xs     | n <= 0 =  xs
   drop _ []              =  []
-  drop 0 xs@(_:_)        =  xs
   drop n (_:xs)          =  drop (n-1) xs
 
   splitAt                :: Nat -> [a] -> ([a],[a])
@@ -430,7 +430,6 @@
                      | otherwise = (ts, x:fs)
 
 -- Can't be promoted because of limitations of Int promotion.
--- Also, #60 and th-desugar #6 get in the way.
 -- Below is a re-implementation using Nat
 --  (!!)                    :: [a] -> Int -> a
 --  xs     !! n | n < 0 =  error "Data.Singletons.List.!!: negative index"
@@ -439,9 +438,10 @@
 --  (_:xs) !! n         =  xs !! (n-1)
 
   (!!)                    :: [a] -> Nat -> a
-  []     !! _ = error "Data.Singletons.List.!!: index too large"
-  (x:xs) !! n = if | n == 0    -> x
-                   | otherwise -> xs !! (n-1)
+  _      !! n | n < 0 =  error "Data.Singletons.List.!!: negative index"
+  []     !! _         =  error "Data.Singletons.List.!!: index too large"
+  (x:_)  !! 0         =  x
+  (_:xs) !! n         =  xs !! (n-1)
 
 -- These three rely on findIndices, which does not promote.
 -- Since we have our own implementation of findIndices these are perfectly valid
diff --git a/src/Data/Promotion/Prelude/Num.hs b/src/Data/Promotion/Prelude/Num.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Promotion/Prelude/Num.hs
@@ -0,0 +1,30 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Promotion.Prelude.Num
+-- Copyright   :  (C) 2014 Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu)
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Defines and exports promoted and singleton versions of definitions from
+-- GHC.Num.
+--
+----------------------------------------------------------------------------
+
+module Data.Promotion.Prelude.Num (
+  PNum(..), Subtract,
+
+  -- ** Defunctionalization symbols
+  (:+$), (:+$$), (:+$$$),
+  (:-$), (:-$$), (:-$$$),
+  (:*$), (:*$$), (:*$$$),
+  NegateSym0, NegateSym1,
+  AbsSym0, AbsSym1,
+  SignumSym0, SignumSym1,
+  FromIntegerSym0, FromIntegerSym1,
+  SubtractSym0, SubtractSym1, SubtractSym2
+  ) where
+
+import Data.Singletons.Prelude.Num
+import Data.Singletons.TypeLits ()   -- for the Num instance!
diff --git a/src/Data/Promotion/TH.hs b/src/Data/Promotion/TH.hs
--- a/src/Data/Promotion/TH.hs
+++ b/src/Data/Promotion/TH.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE ExplicitNamespaces, CPP #-}
+{-# LANGUAGE ExplicitNamespaces #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -27,6 +27,9 @@
   -- ** Functions to generate @Bounded@ instances
   promoteBoundedInstances, promoteBoundedInstance,
 
+  -- ** Functions to generate @Enum@ instances
+  promoteEnumInstances, promoteEnumInstance,
+
   -- ** defunctionalization
   TyFun, Apply, type (@@),
 
@@ -37,7 +40,7 @@
   PEq(..), If, (:&&),
   POrd(..),
   Any,
-  Proxy(..), KProxy(..), ThenCmp,
+  Proxy(..), KProxy(..), ThenCmp, Foldl,
 
   Error, ErrorSym0,
   TrueSym0, FalseSym0,
@@ -49,12 +52,13 @@
   Tuple5Sym0, Tuple5Sym1, Tuple5Sym2, Tuple5Sym3, Tuple5Sym4, Tuple5Sym5,
   Tuple6Sym0, Tuple6Sym1, Tuple6Sym2, Tuple6Sym3, Tuple6Sym4, Tuple6Sym5, Tuple6Sym6,
   Tuple7Sym0, Tuple7Sym1, Tuple7Sym2, Tuple7Sym3, Tuple7Sym4, Tuple7Sym5, Tuple7Sym6, Tuple7Sym7,
+  ThenCmpSym0, FoldlSym0,
 
   SuppressUnusedWarnings(..)
 
  ) where
 
-import Data.Singletons.Types ( Proxy(..) )
+import Data.Proxy
 import Data.Singletons
 import Data.Singletons.Promote
 import Data.Singletons.Prelude.Instances
diff --git a/src/Data/Singletons.hs b/src/Data/Singletons.hs
--- a/src/Data/Singletons.hs
+++ b/src/Data/Singletons.hs
@@ -1,5 +1,5 @@
 {-# LANGUAGE MagicHash, RankNTypes, PolyKinds, GADTs, DataKinds,
-             FlexibleContexts, CPP, TypeFamilies, TypeOperators,
+             FlexibleContexts, TypeFamilies, TypeOperators,
              UndecidableInstances #-}
 
 -----------------------------------------------------------------------------
@@ -22,11 +22,6 @@
 --
 ----------------------------------------------------------------------------
 
-#if __GLASGOW_HASKELL__ < 707
-  -- optimizing instances of SDecide cause GHC to die (#8467)
-{-# OPTIONS_GHC -O0 #-}
-#endif
-
 module Data.Singletons (
   -- * Main singleton definitions
 
@@ -40,26 +35,25 @@
   SingInstance(..), SomeSing(..),
   singInstance, withSingI, withSomeSing, singByProxy,
 
-#if __GLASGOW_HASKELL__ >= 707
   singByProxy#,
-#endif
   withSing, singThat,
 
   -- ** Defunctionalization
-  TyFun, TyCon1, TyCon2, TyCon3, TyCon4, TyCon5, TyCon6, TyCon7,
+  TyFun, TyCon1, TyCon2, TyCon3, TyCon4, TyCon5, TyCon6, TyCon7, TyCon8,
   Apply, type (@@),
 
   -- ** Defunctionalized singletons
   -- | When calling a higher-order singleton function, you need to use a
   -- @singFun...@ function to wrap it. See 'singFun1'.
   singFun1, singFun2, singFun3, singFun4, singFun5, singFun6, singFun7,
+  singFun8,
   unSingFun1, unSingFun2, unSingFun3, unSingFun4, unSingFun5,
-  unSingFun6, unSingFun7,
+  unSingFun6, unSingFun7, unSingFun8,
 
--- | These type synonyms are exported only to improve error messages; users
+  -- | These type synonyms are exported only to improve error messages; users
   -- should not have to mention them.
   SingFunction1, SingFunction2, SingFunction3, SingFunction4, SingFunction5,
-  SingFunction6, SingFunction7, 
+  SingFunction6, SingFunction7, SingFunction8,
 
   -- * Auxiliary functions
   bugInGHC,
@@ -67,10 +61,8 @@
   ) where
 
 import Unsafe.Coerce
-import Data.Singletons.Types
-#if __GLASGOW_HASKELL__ >= 707
+import Data.Proxy ( Proxy(..), KProxy(..) )
 import GHC.Exts ( Proxy# )
-#endif
 
 -- | Convenient synonym to refer to the kind of a type variable:
 -- @type KindOf (a :: k) = ('KProxy :: KProxy k)@
@@ -79,7 +71,7 @@
 ----------------------------------------------------------------------
 ---- Sing & friends --------------------------------------------------
 ----------------------------------------------------------------------
-                        
+
 -- | The singleton kind-indexed data family.
 data family Sing (a :: k)
 
@@ -125,7 +117,7 @@
 ----------------------------------------------------------------------
 ---- SingInstance ----------------------------------------------------
 ----------------------------------------------------------------------
-                  
+
 -- | A 'SingInstance' wraps up a 'SingI' instance for explicit handling.
 data SingInstance (a :: k) where
   SingInstance :: SingI a => SingInstance a
@@ -170,6 +162,7 @@
 data TyCon5 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 k6 -> *) -> *) -> *) -> *) -> *
 data TyCon6 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 (TyFun k6 k7 -> *) -> *) -> *) -> *) -> *) -> *
 data TyCon7 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7 -> k8) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 (TyFun k6 (TyFun k7 k8 -> *) -> *) -> *) -> *) -> *) -> *) -> *
+data TyCon8 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7 -> k8 -> k9) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 (TyFun k6 (TyFun k7 (TyFun k8 k9 -> *) -> *) -> *) -> *) -> *) -> *) -> *) -> *
 
 -- | Type level function application
 type family Apply (f :: TyFun k1 k2 -> *) (x :: k1) :: k2
@@ -180,6 +173,7 @@
 type instance Apply (TyCon5 f) x = TyCon4 (f x)
 type instance Apply (TyCon6 f) x = TyCon5 (f x)
 type instance Apply (TyCon7 f) x = TyCon6 (f x)
+type instance Apply (TyCon8 f) x = TyCon7 (f x)
 
 -- | An infix synonym for `Apply`
 type a @@ b = Apply a b
@@ -205,7 +199,7 @@
 -- a higher-order function. You will often need an explicit type
 -- annotation to get this to work. For example:
 --
--- > falses = sMap (singFun1 sNot :: Sing NotSym0)
+-- > falses = sMap (singFun1 (Proxy :: Proxy NotSym0) sNot)
 -- >               (STrue `SCons` STrue `SCons` SNil)
 --
 -- There are a family of @singFun...@ functions, keyed by the number
@@ -237,6 +231,10 @@
 singFun7 :: Proxy f -> SingFunction7 f -> Sing f
 singFun7 _ f = SLambda (\x -> singFun6 Proxy (f x))
 
+type SingFunction8 f = forall t. Sing t -> SingFunction7 (f @@ t)
+singFun8 :: Proxy f -> SingFunction8 f -> Sing f
+singFun8 _ f = SLambda (\x -> singFun7 Proxy (f x))
+
 -- | This is the inverse of 'singFun1', and likewise for the other
 -- @unSingFun...@ functions.
 unSingFun1 :: Proxy f -> Sing f -> SingFunction1 f
@@ -260,6 +258,9 @@
 unSingFun7 :: Proxy f -> Sing f -> SingFunction7 f
 unSingFun7 _ sf x = unSingFun6 Proxy (sf `applySing` x)
 
+unSingFun8 :: Proxy f -> Sing f -> SingFunction8 f
+unSingFun8 _ sf x = unSingFun7 Proxy (sf `applySing` x)
+
 ----------------------------------------------------------------------
 ---- Convenience -----------------------------------------------------
 ----------------------------------------------------------------------
@@ -300,11 +301,9 @@
 singByProxy :: SingI a => proxy a -> Sing a
 singByProxy _ = sing
 
-#if __GLASGOW_HASKELL__ >= 707
 -- | Allows creation of a singleton when a @proxy#@ is at hand.
 singByProxy# :: SingI a => Proxy# a -> Sing a
 singByProxy# _ = sing
-#endif
 
 -- | GHC 7.8 sometimes warns about incomplete pattern matches when no such
 -- patterns are possible, due to GADT constraints.
@@ -313,4 +312,3 @@
 -- 'bugInGHC' as its right-hand side.
 bugInGHC :: forall a. a
 bugInGHC = error "Bug encountered in GHC -- this should never happen"
-
diff --git a/src/Data/Singletons/CustomStar.hs b/src/Data/Singletons/CustomStar.hs
--- a/src/Data/Singletons/CustomStar.hs
+++ b/src/Data/Singletons/CustomStar.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE DataKinds, TypeFamilies, KindSignatures, CPP, TemplateHaskell #-}
+{-# LANGUAGE DataKinds, TypeFamilies, KindSignatures, TemplateHaskell, CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -25,10 +25,12 @@
 
 import Language.Haskell.TH
 import Data.Singletons.Util
+import Data.Singletons.Deriving.Ord
 import Data.Singletons.Promote
 import Data.Singletons.Promote.Monad
 import Data.Singletons.Single.Monad
 import Data.Singletons.Single.Data
+import Data.Singletons.Single
 import Data.Singletons.Syntax
 import Data.Singletons.Names
 import Control.Monad
@@ -37,10 +39,6 @@
 import Data.Singletons.Prelude.Eq
 import Data.Singletons.Prelude.Bool
 
-#if __GLASGOW_HASKELL__ < 709
-import Control.Applicative
-#endif
-
 -- | Produce a representation and singleton for the collection of types given.
 --
 -- A datatype @Rep@ is created, with one constructor per type in the declared
@@ -76,9 +74,13 @@
   let repDecl = DDataD Data [] repName [] ctors
                        [''Eq, ''Show, ''Read]
   fakeCtors <- zipWithM (mkCtor False) names kinds
-  let dataDecl = DataDecl Data repName [] fakeCtors [''Show, ''Read , ''Eq, ''Ord]
-  promDecls      <- promoteM_ [] $ promoteDataDec dataDecl
-  singletonDecls <- singDecsM [] $ singDataD dataDecl
+  let dataDecl = DataDecl Data repName [] fakeCtors [''Show, ''Read , ''Eq]
+  ordInst <- mkOrdInstance (DConT repName) fakeCtors
+  (pOrdInst, promDecls) <- promoteM [] $ do promoteDataDec dataDecl
+                                            promoteInstanceDec mempty ordInst
+  singletonDecls <- singDecsM [] $ do decs1 <- singDataD dataDecl
+                                      dec2  <- singInstD pOrdInst
+                                      return (dec2 : decs1)
   return $ decsToTH $ repDecl :
                       promDecls ++
                       singletonDecls
diff --git a/src/Data/Singletons/Decide.hs b/src/Data/Singletons/Decide.hs
--- a/src/Data/Singletons/Decide.hs
+++ b/src/Data/Singletons/Decide.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, RankNTypes, PolyKinds, DataKinds, TypeOperators,
+{-# LANGUAGE RankNTypes, PolyKinds, DataKinds, TypeOperators,
              TypeFamilies, FlexibleContexts, UndecidableInstances, GADTs #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
@@ -24,8 +24,8 @@
   ) where
 
 import Data.Singletons
-import Data.Singletons.Types
-import Data.Singletons.Void
+import Data.Type.Equality
+import Data.Void
 
 ----------------------------------------------------------------------
 ---- SDecide ---------------------------------------------------------
@@ -40,7 +40,7 @@
 -- cannot exist.
 data Decision a = Proved a               -- ^ Witness for @a@
                 | Disproved (Refuted a)  -- ^ Proof that no @a@ exists
-                  
+
 -- | Members of the 'SDecide' "kind" class support decidable equality. Instances
 -- of this class are generated alongside singleton definitions for datatypes that
 -- derive an 'Eq' instance.
diff --git a/src/Data/Singletons/Deriving/Bounded.hs b/src/Data/Singletons/Deriving/Bounded.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/Deriving/Bounded.hs
@@ -0,0 +1,57 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.Deriving.Bounded
+-- Copyright   :  (C) 2015 Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Implements deriving of Bounded instances
+--
+----------------------------------------------------------------------------
+
+module Data.Singletons.Deriving.Bounded where
+
+import Language.Haskell.TH.Syntax
+import Language.Haskell.TH.Ppr
+import Language.Haskell.TH.Desugar
+import Data.Singletons.Names
+import Data.Singletons.Util
+import Data.Singletons.Syntax
+import Data.Singletons.Deriving.Infer
+import Control.Monad
+
+-- monadic only for failure and parallelism with other functions
+-- that make instances
+mkBoundedInstance :: Quasi q => DType -> [DCon] -> q UInstDecl
+mkBoundedInstance ty cons = do
+  -- We can derive instance of Bounded if datatype is an enumeration (all
+  -- constructors must be nullary) or has only one constructor. See Section 11
+  -- of Haskell 2010 Language Report.
+  -- Note that order of conditions below is important.
+  when (null cons
+       || (any (\(DCon _ _ _ f) -> not . null . tysOfConFields $ f) cons
+            && (not . null . tail $ cons))) $
+       fail ("Can't derive Bounded instance for "
+             ++ pprint (typeToTH ty) ++ ".")
+  -- at this point we know that either we have a datatype that has only one
+  -- constructor or a datatype where each constructor is nullary
+  let (DCon _ _ minName fields) = head cons
+      (DCon _ _ maxName _)      = last cons
+      fieldsCount   = length $ tysOfConFields fields
+      (minRHS, maxRHS) = case fieldsCount of
+        0 -> (DConE minName, DConE maxName)
+        _ ->
+          let minEqnRHS = foldExp (DConE minName)
+                                  (replicate fieldsCount (DVarE minBoundName))
+              maxEqnRHS = foldExp (DConE maxName)
+                                  (replicate fieldsCount (DVarE maxBoundName))
+          in (minEqnRHS, maxEqnRHS)
+
+      mk_rhs rhs = UFunction [DClause [] rhs]
+  return $ InstDecl { id_cxt = inferConstraints (DConPr boundedName) cons
+                    , id_name = boundedName
+                    , id_arg_tys = [ty]
+                    , id_meths = [ (minBoundName, mk_rhs minRHS)
+                                 , (maxBoundName, mk_rhs maxRHS) ] }
diff --git a/src/Data/Singletons/Deriving/Enum.hs b/src/Data/Singletons/Deriving/Enum.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/Deriving/Enum.hs
@@ -0,0 +1,51 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.Deriving.Enum
+-- Copyright   :  (C) 2015 Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu)
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Implements deriving of Enum instances
+--
+----------------------------------------------------------------------------
+
+module Data.Singletons.Deriving.Enum ( mkEnumInstance ) where
+
+import Language.Haskell.TH.Syntax
+import Language.Haskell.TH.Ppr
+import Language.Haskell.TH.Desugar
+import Data.Singletons.Syntax
+import Data.Singletons.Util
+import Data.Singletons.Names
+import Control.Monad
+
+-- monadic for failure only
+mkEnumInstance :: Quasi q => DType -> [DCon] -> q UInstDecl
+mkEnumInstance ty cons = do
+  when (null cons ||
+        any (\(DCon tvbs cxt _ f) -> or [ not $ null $ tysOfConFields f
+                                        , not $ null tvbs
+                                        , not $ null cxt ]) cons) $
+    fail ("Can't derive Enum instance for " ++ pprint (typeToTH ty) ++ ".")
+  n <- qNewName "n"
+  let to_enum = UFunction [DClause [DVarPa n] (to_enum_rhs cons [0..])]
+      to_enum_rhs [] _ = DVarE errorName `DAppE` DLitE (StringL "toEnum: bad argument")
+      to_enum_rhs (DCon _ _ name _ : rest) (num:nums) =
+        DCaseE (DVarE equalsName `DAppE` DVarE n `DAppE` DLitE (IntegerL num))
+          [ DMatch (DConPa trueName []) (DConE name)
+          , DMatch (DConPa falseName []) (to_enum_rhs rest nums) ]
+      to_enum_rhs _ _ = error "Internal error: exhausted infinite list in to_enum_rhs"
+
+      from_enum = UFunction (zipWith (\i con -> DClause [DConPa (extractName con) []]
+                                                        (DLitE (IntegerL i)))
+                                     [0..] cons)
+  return (InstDecl { id_cxt     = []
+                   , id_name    = singletonsEnumName
+                      -- need to use singletons's Enum class to get the types
+                      -- to use Nat instead of Int
+
+                   , id_arg_tys = [ty]
+                   , id_meths   = [ (singletonsToEnumName, to_enum)
+                                  , (singletonsFromEnumName, from_enum) ] })
diff --git a/src/Data/Singletons/Deriving/Infer.hs b/src/Data/Singletons/Deriving/Infer.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/Deriving/Infer.hs
@@ -0,0 +1,24 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.Deriving.Infer
+-- Copyright   :  (C) 2015 Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Infers constraints for a `deriving` class
+--
+----------------------------------------------------------------------------
+
+module Data.Singletons.Deriving.Infer ( inferConstraints ) where
+
+import Language.Haskell.TH.Desugar
+import Data.Singletons.Util
+import Data.List
+import Data.Generics.Twins
+
+inferConstraints :: DPred -> [DCon] -> DCxt
+inferConstraints pr = nubBy geq . concatMap infer_ct
+  where
+    infer_ct (DCon _ _ _ fields) = map (pr `DAppPr`) (tysOfConFields fields)
diff --git a/src/Data/Singletons/Deriving/Ord.hs b/src/Data/Singletons/Deriving/Ord.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/Deriving/Ord.hs
@@ -0,0 +1,65 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.Deriving.Ord
+-- Copyright   :  (C) 2015 Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Implements deriving of Ord instances
+--
+----------------------------------------------------------------------------
+
+module Data.Singletons.Deriving.Ord ( mkOrdInstance ) where
+
+import Language.Haskell.TH.Desugar
+import Data.Singletons.Names
+import Data.Singletons.Util
+import Language.Haskell.TH.Syntax
+import Data.Singletons.Deriving.Infer
+import Data.Singletons.Syntax
+
+-- | Make a *non-singleton* Ord instance
+mkOrdInstance :: Quasi q => DType -> [DCon] -> q UInstDecl
+mkOrdInstance ty cons = do
+  let constraints = inferConstraints (DConPr ordName) cons
+  compare_eq_clauses <- mapM mk_equal_clause cons
+  let compare_noneq_clauses = map (uncurry mk_nonequal_clause)
+                                  [ (con1, con2)
+                                  | con1 <- zip cons [1..]
+                                  , con2 <- zip cons [1..]
+                                  , extractName (fst con1) /=
+                                    extractName (fst con2) ]
+  return (InstDecl { id_cxt = constraints
+                   , id_name = ordName
+                   , id_arg_tys = [ty]
+                   , id_meths = [( compareName
+                                 , UFunction (compare_eq_clauses ++
+                                              compare_noneq_clauses) )] })
+
+mk_equal_clause :: Quasi q => DCon -> q DClause
+mk_equal_clause (DCon _tvbs _cxt name fields) = do
+  let tys = tysOfConFields fields
+  a_names <- mapM (const $ newUniqueName "a") tys
+  b_names <- mapM (const $ newUniqueName "b") tys
+  let pat1 = DConPa name (map DVarPa a_names)
+      pat2 = DConPa name (map DVarPa b_names)
+  return $ DClause [pat1, pat2] (DVarE foldlName `DAppE`
+                                 DVarE thenCmpName `DAppE`
+                                 DConE cmpEQName `DAppE`
+                                 mkListE (zipWith
+                                          (\a b -> DVarE compareName `DAppE` DVarE a
+                                                                     `DAppE` DVarE b)
+                                          a_names b_names))
+
+mk_nonequal_clause :: (DCon, Int) -> (DCon, Int) -> DClause
+mk_nonequal_clause (DCon _tvbs1 _cxt1 name1 fields1, n1)
+                   (DCon _tvbs2 _cxt2 name2 fields2, n2) =
+  DClause [pat1, pat2] (case n1 `compare` n2 of
+                          LT -> DConE cmpLTName
+                          EQ -> DConE cmpEQName
+                          GT -> DConE cmpGTName)
+  where
+    pat1 = DConPa name1 (map (const DWildPa) (tysOfConFields fields1))
+    pat2 = DConPa name2 (map (const DWildPa) (tysOfConFields fields2))
diff --git a/src/Data/Singletons/Names.hs b/src/Data/Singletons/Names.hs
--- a/src/Data/Singletons/Names.hs
+++ b/src/Data/Singletons/Names.hs
@@ -6,27 +6,27 @@
 Defining names and manipulations on names for use in promotion and singling.
 -}
 
-{-# LANGUAGE CPP, TemplateHaskell #-}
+{-# LANGUAGE TemplateHaskell #-}
 
 module Data.Singletons.Names where
 
 import Data.Singletons
 import Data.Singletons.SuppressUnusedWarnings
-import Data.Singletons.Types
 import Data.Singletons.Decide
 import Language.Haskell.TH.Syntax
 import Language.Haskell.TH.Desugar
-import GHC.TypeLits ( Symbol )
+import GHC.TypeLits ( Nat, Symbol )
 import GHC.Exts ( Any )
 import Data.Typeable ( TypeRep )
 import Data.Singletons.Util
+import Data.Proxy ( Proxy(..) )
+import Control.Monad
 
-anyTypeName, boolName, andName, tyEqName, tyCompareName, tyminBoundName,
-  tymaxBoundName, repName,
+anyTypeName, boolName, andName, tyEqName, compareName, minBoundName,
+  maxBoundName, repName,
   nilName, consName, listName, tyFunName,
-  applyName, symbolName, undefinedName, typeRepName, stringName,
-  eqName, ordName, boundedName, orderingName, ordLTSymName, ordEQSymName,
-  ordGTSymName,
+  applyName, natName, symbolName, undefinedName, typeRepName, stringName,
+  eqName, ordName, boundedName, orderingName,
   singFamilyName, singIName, singMethName, demoteRepName,
   singKindClassName, sEqClassName, sEqMethName, sconsName, snilName,
   sIfName, kProxyDataName, kProxyTypeName, proxyTypeName, proxyDataName,
@@ -34,21 +34,26 @@
   sListName, sDecideClassName, sDecideMethName,
   provedName, disprovedName, reflName, toSingName, fromSingName,
   equalityName, applySingName, suppressClassName, suppressMethodName,
-  tyThenCmpName, kindOfName :: Name
+  thenCmpName,
+  kindOfName, tyFromIntegerName, tyNegateName, sFromIntegerName,
+  sNegateName, errorName, foldlName, cmpEQName, cmpLTName, cmpGTName,
+  singletonsToEnumName, singletonsFromEnumName, enumName, singletonsEnumName,
+  equalsName :: Name
 anyTypeName = ''Any
 boolName = ''Bool
 andName = '(&&)
-tyCompareName = mkName "Compare"
-tyminBoundName = mkName "MinBound"
-tymaxBoundName = mkName "MaxBound"
-tyEqName = mkName ":=="
-repName = mkName "Rep"
+compareName = 'compare
+minBoundName = 'minBound
+maxBoundName = 'maxBound
+tyEqName = mk_name_tc "Data.Singletons.Prelude.Eq" ":=="
+repName = mkName "Rep"   -- this is actually defined in client code!
 nilName = '[]
 consName = '(:)
 listName = ''[]
 tyFunName = ''TyFun
 applyName = ''Apply
 symbolName = ''Symbol
+natName = ''Nat
 undefinedName = 'undefined
 typeRepName = ''TypeRep
 stringName = ''String
@@ -56,9 +61,6 @@
 ordName = ''Ord
 boundedName = ''Bounded
 orderingName = ''Ordering
-ordLTSymName = mkName "LTSym0"
-ordEQSymName = mkName "EQSym0"
-ordGTSymName = mkName "GTSym0"
 singFamilyName = ''Sing
 singIName = ''SingI
 singMethName = 'sing
@@ -66,18 +68,18 @@
 fromSingName = 'fromSing
 demoteRepName = ''DemoteRep
 singKindClassName = ''SingKind
-sEqClassName = mkName "SEq"
-sEqMethName = mkName "%:=="
-sIfName = mkName "sIf"
-sconsName = mkName "SCons"
-snilName = mkName "SNil"
+sEqClassName = mk_name_tc "Data.Singletons.Prelude.Eq" "SEq"
+sEqMethName = mk_name_v "Data.Singletons.Prelude.Eq" "%:=="
+sIfName = mk_name_v "Data.Singletons.Prelude.Bool" "sIf"
+sconsName = mk_name_d "Data.Singletons.Prelude.Instances" "SCons"
+snilName = mk_name_d "Data.Singletons.Prelude.Instances" "SNil"
 kProxyDataName = 'KProxy
 kProxyTypeName = ''KProxy
 someSingTypeName = ''SomeSing
 someSingDataName = 'SomeSing
 proxyTypeName = ''Proxy
 proxyDataName = 'Proxy
-sListName = mkName "SList"
+sListName = mk_name_tc "Data.Singletons.Prelude.Instances" "SList"
 sDecideClassName = ''SDecide
 sDecideMethName = '(%~)
 provedName = 'Proved
@@ -87,12 +89,43 @@
 applySingName = 'applySing
 suppressClassName = ''SuppressUnusedWarnings
 suppressMethodName = 'suppressUnusedWarnings
-tyThenCmpName = mkName "ThenCmp"
+thenCmpName = mk_name_v "Data.Singletons.Prelude.Ord" "thenCmp"
 kindOfName = ''KindOf
+tyFromIntegerName = mk_name_tc "Data.Singletons.Prelude.Num" "FromInteger"
+tyNegateName = mk_name_tc "Data.Singletons.Prelude.Num" "Negate"
+sFromIntegerName = mk_name_v "Data.Singletons.Prelude.Num" "sFromInteger"
+sNegateName = mk_name_v "Data.Singletons.Prelude.Num" "sNegate"
+errorName = 'error
+foldlName = 'foldl
+cmpEQName = 'EQ
+cmpLTName = 'LT
+cmpGTName = 'GT
+singletonsToEnumName = mk_name_v "Data.Singletons.Prelude.Enum" "toEnum"
+singletonsFromEnumName = mk_name_v "Data.Singletons.Prelude.Enum" "fromEnum"
+enumName = ''Enum
+singletonsEnumName = mk_name_tc "Data.Singletons.Prelude.Enum" "Enum"
+equalsName = '(==)
 
-mkTupleName :: Int -> Name
-mkTupleName n = mkName $ "STuple" ++ (show n)
+singPkg :: String
+singPkg = $( (LitE . StringL . loc_package) `liftM` location )
 
+mk_name_tc :: String -> String -> Name
+mk_name_tc = mkNameG_tc singPkg
+
+mk_name_d :: String -> String -> Name
+mk_name_d = mkNameG_d singPkg
+
+mk_name_v :: String -> String -> Name
+mk_name_v = mkNameG_v singPkg
+
+mkTupleTypeName :: Int -> Name
+mkTupleTypeName n = mk_name_tc "Data.Singletons.Prelude.Instances" $
+                    "STuple" ++ (show n)
+
+mkTupleDataName :: Int -> Name
+mkTupleDataName n = mk_name_d "Data.Singletons.Prelude.Instances" $
+                    "STuple" ++ (show n)
+
 -- used when a value name appears in a pattern context
 -- works only for proper variables (lower-case names)
 promoteValNameLhs :: Name -> Name
@@ -124,12 +157,11 @@
     | name == nilName
     = mkName $ "NilSym" ++ (show sat)
 
-    | Just degree <- tupleNameDegree_maybe name
-    = mkName $ "Tuple" ++ show degree ++ "Sym" ++ (show sat)
-
        -- treat unboxed tuples like tuples
-    | Just degree <- unboxedTupleNameDegree_maybe name
-    = mkName $ "Tuple" ++ show degree ++ "Sym" ++ (show sat)
+    | Just degree <- tupleNameDegree_maybe name `mplus`
+                     unboxedTupleNameDegree_maybe name
+    = mk_name_tc "Data.Singletons.Prelude.Instances" $
+                 "Tuple" ++ show degree ++ "Sym" ++ (show sat)
 
     | otherwise
     = let capped = toUpcaseStr noPrefix name in
@@ -145,7 +177,7 @@
 classTvsName :: Name -> Name
 classTvsName = suffixName "TyVars" "^^^"
 
-mkTyName :: DsMonad q => Name -> q Name
+mkTyName :: Quasi q => Name -> q Name
 mkTyName tmName = do
   let nameStr  = nameBase tmName
       symbolic = not (isHsLetter (head nameStr))
@@ -163,53 +195,21 @@
 andTySym :: DType
 andTySym = promoteValRhs andName
 
--- make a Name with an unknown kind into a DTyVarBndr.
--- Uses a fresh kind variable for GHC 7.6.3 and PlainTV for 7.8+
--- because 7.8+ has kind inference
-inferKindTV :: DsMonad q => Name -> q DTyVarBndr
-inferKindTV n = do
-#if __GLASGOW_HASKELL__ < 707
-  ki <- fmap DVarK $ qNewName "k"
-  return $ DKindedTV n _ki
-#else
-  return $ DPlainTV n
-#endif
-
-inferMaybeKindTV :: DsMonad q => Name -> Maybe DKind -> q DTyVarBndr
-inferMaybeKindTV n Nothing =
-#if __GLASGOW_HASKELL__ < 707
-  do k <- qNewName "k"
-     return $ DKindedTV n (DVarK k)
-#else
-  return $ DPlainTV n
-#endif
-inferMaybeKindTV n (Just k) = return $ DKindedTV n k
-
--- similar to above, this is for annotating the result kind of
--- a closed type family. Makes it polymorphic in 7.6.3, inferred
--- in 7.8
-unknownResult :: DKind -> Maybe DKind
-#if __GLASGOW_HASKELL__ < 707
-unknownResult = Just
-#else
-unknownResult = const Nothing
-#endif
-
 -- Singletons
 
 singDataConName :: Name -> Name
 singDataConName nm
   | nm == nilName                                  = snilName
   | nm == consName                                 = sconsName
-  | Just degree <- tupleNameDegree_maybe nm        = mkTupleName degree
-  | Just degree <- unboxedTupleNameDegree_maybe nm = mkTupleName degree
+  | Just degree <- tupleNameDegree_maybe nm        = mkTupleDataName degree
+  | Just degree <- unboxedTupleNameDegree_maybe nm = mkTupleDataName degree
   | otherwise                                      = prefixUCName "S" ":%" nm
 
 singTyConName :: Name -> Name
 singTyConName name
   | name == listName                                 = sListName
-  | Just degree <- tupleNameDegree_maybe name        = mkTupleName degree
-  | Just degree <- unboxedTupleNameDegree_maybe name = mkTupleName degree
+  | Just degree <- tupleNameDegree_maybe name        = mkTupleTypeName degree
+  | Just degree <- unboxedTupleNameDegree_maybe name = mkTupleTypeName degree
   | otherwise                                        = prefixUCName "S" ":%" name
 
 singClassName :: Name -> Name
@@ -240,7 +240,25 @@
 apply :: DType -> DType -> DType
 apply t1 t2 = DAppT (DAppT (DConT applyName) t1) t2
 
+mkListE :: [DExp] -> DExp
+mkListE =
+  foldr (\h t -> DConE consName `DAppE` h `DAppE` t) (DConE nilName)
+
 -- apply a type to a list of types using Apply type family
 -- This is defined here, not in Utils, to avoid cyclic dependencies
 foldApply :: DType -> [DType] -> DType
 foldApply = foldl apply
+
+-- make and equality predicate
+mkEqPred :: DType -> DType -> DPred
+mkEqPred ty1 ty2 = foldl DAppPr (DConPr equalityName) [ty1, ty2]
+
+-- create a bunch of kproxy vars, and constrain them all to be 'KProxy
+mkKProxies :: Quasi q
+           => [Name]   -- for the kinds of the kproxies
+           -> q ([DTyVarBndr], DCxt)
+mkKProxies ns = do
+  kproxies <- mapM (const $ qNewName "kproxy") ns
+  return ( zipWith (\kp kv -> DKindedTV kp (DConK kProxyTypeName [DVarK kv]))
+                   kproxies ns
+         , map (\kp -> mkEqPred (DVarT kp) (DConT kProxyDataName)) kproxies )
diff --git a/src/Data/Singletons/Partition.hs b/src/Data/Singletons/Partition.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/Partition.hs
@@ -0,0 +1,111 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.Partition
+-- Copyright   :  (C) 2015 Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Partitions a list of declarations into its bits
+--
+----------------------------------------------------------------------------
+
+module Data.Singletons.Partition where
+
+import Prelude hiding ( exp )
+import Data.Singletons.Syntax
+import Data.Singletons.Deriving.Ord
+import Data.Singletons.Deriving.Bounded
+import Data.Singletons.Deriving.Enum
+import Data.Singletons.Names
+import Language.Haskell.TH.Syntax
+import Language.Haskell.TH.Ppr
+import Language.Haskell.TH.Desugar
+import Data.Singletons.Util
+
+import Data.Monoid
+import Control.Monad
+import Data.Maybe
+
+data PartitionedDecs =
+  PDecs { pd_let_decs :: [DLetDec]
+        , pd_class_decs :: [UClassDecl]
+        , pd_instance_decs :: [UInstDecl]
+        , pd_data_decs :: [DataDecl]
+        }
+
+instance Monoid PartitionedDecs where
+  mempty = PDecs [] [] [] []
+  mappend (PDecs a1 b1 c1 d1) (PDecs a2 b2 c2 d2) =
+    PDecs (a1 <> a2) (b1 <> b2) (c1 <> c2) (d1 <> d2)
+
+-- | Split up a @[DDec]@ into its pieces, extracting 'Ord' instances
+-- from deriving clauses
+partitionDecs :: Quasi m => [DDec] -> m PartitionedDecs
+partitionDecs = concatMapM partitionDec
+
+partitionDec :: Quasi m => DDec -> m PartitionedDecs
+partitionDec (DLetDec letdec) = return $ mempty { pd_let_decs = [letdec] }
+
+partitionDec (DDataD nd _cxt name tvbs cons derivings) = do
+  (derivings', derived_instances) <- partitionWithM part_derivings derivings
+  return $ mempty { pd_data_decs = [DataDecl nd name tvbs cons derivings']
+                  , pd_instance_decs = derived_instances }
+  where
+    ty = foldType (DConT name) (map tvbToType tvbs)
+    part_derivings :: Quasi m => Name -> m (Either Name UInstDecl)
+    part_derivings deriv_name
+      | deriv_name == ordName
+      = Right <$> mkOrdInstance ty cons
+      | deriv_name == boundedName
+      = Right <$> mkBoundedInstance ty cons
+      | deriv_name == enumName
+      = Right <$> mkEnumInstance ty cons
+      | otherwise
+      = return (Left deriv_name)
+
+partitionDec (DClassD cxt name tvbs fds decs) = do
+  env <- concatMapM partitionClassDec decs
+  return $ mempty { pd_class_decs = [ClassDecl { cd_cxt  = cxt
+                                               , cd_name = name
+                                               , cd_tvbs = tvbs
+                                               , cd_fds  = fds
+                                               , cd_lde  = env }] }
+partitionDec (DInstanceD cxt ty decs) = do
+  defns <- liftM catMaybes $ mapM partitionInstanceDec decs
+  (name, tys) <- split_app_tys [] ty
+  return $ mempty { pd_instance_decs = [InstDecl { id_cxt = cxt
+                                                 , id_name = name
+                                                 , id_arg_tys = tys
+                                                 , id_meths = defns }] }
+  where
+    split_app_tys acc (DAppT t1 t2) = split_app_tys (t2:acc) t1
+    split_app_tys acc (DConT name)  = return (name, acc)
+    split_app_tys acc (DSigT t _)   = split_app_tys acc t
+    split_app_tys _ _ = fail $ "Illegal instance head: " ++ show ty
+partitionDec (DRoleAnnotD {}) = return mempty  -- ignore these
+partitionDec (DPragmaD {}) = return mempty
+partitionDec dec =
+  fail $ "Declaration cannot be promoted: " ++ pprint (decToTH dec)
+
+partitionClassDec :: Monad m => DDec -> m ULetDecEnv
+partitionClassDec (DLetDec (DSigD name ty)) = return $ typeBinding name ty
+partitionClassDec (DLetDec (DValD (DVarPa name) exp)) =
+  return $ valueBinding name (UValue exp)
+partitionClassDec (DLetDec (DFunD name clauses)) =
+  return $ valueBinding name (UFunction clauses)
+partitionClassDec (DLetDec (DInfixD fixity name)) =
+  return $ infixDecl fixity name
+partitionClassDec (DPragmaD {}) = return mempty
+partitionClassDec _ =
+  fail "Only method declarations can be promoted within a class."
+
+partitionInstanceDec :: Monad m => DDec -> m (Maybe (Name, ULetDecRHS))
+partitionInstanceDec (DLetDec (DValD (DVarPa name) exp)) =
+  return $ Just (name, UValue exp)
+partitionInstanceDec (DLetDec (DFunD name clauses)) =
+  return $ Just (name, UFunction clauses)
+partitionInstanceDec (DPragmaD {}) = return Nothing
+partitionInstanceDec _ =
+  fail "Only method bodies can be promoted within an instance."
diff --git a/src/Data/Singletons/Prelude.hs b/src/Data/Singletons/Prelude.hs
--- a/src/Data/Singletons/Prelude.hs
+++ b/src/Data/Singletons/Prelude.hs
@@ -90,6 +90,16 @@
   -- * Singleton comparisons
   module Data.Singletons.Prelude.Ord,
 
+  -- * Singleton Enum and Bounded
+  -- | As a matter of convenience, the singletons Prelude does /not/ export
+  -- promoted/singletonized @succ@ and @pred@, due to likely conflicts with
+  -- unary numbers. Please import 'Data.Singletons.Prelude.Enum' directly if
+  -- you want these.
+  module Data.Singletons.Prelude.Enum,
+
+  -- * Singletons numbers
+  module Data.Singletons.Prelude.Num,
+
   -- ** Miscellaneous functions
   Id, sId, Const, sConst, (:.), (%:.), type ($), (%$), type ($!), (%$!),
   Flip, sFlip, AsTypeOf, sAsTypeOf,
@@ -193,4 +203,7 @@
 import Data.Singletons.Prelude.Eq
 import Data.Singletons.Prelude.Ord
 import Data.Singletons.Prelude.Instances
+import Data.Singletons.Prelude.Enum
+  hiding (Succ, Pred, SuccSym0, SuccSym1, PredSym0, PredSym1, sSucc, sPred)
+import Data.Singletons.Prelude.Num
 import Data.Singletons.TypeLits
diff --git a/src/Data/Singletons/Prelude/Base.hs b/src/Data/Singletons/Prelude/Base.hs
--- a/src/Data/Singletons/Prelude/Base.hs
+++ b/src/Data/Singletons/Prelude/Base.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, TemplateHaskell, KindSignatures, PolyKinds, TypeOperators,
+{-# LANGUAGE TemplateHaskell, KindSignatures, PolyKinds, TypeOperators,
              DataKinds, ScopedTypeVariables, TypeFamilies, GADTs,
              UndecidableInstances, BangPatterns #-}
 
@@ -31,20 +31,21 @@
   -- * Defunctionalization symbols
   FoldrSym0, FoldrSym1, FoldrSym2, FoldrSym3,
   MapSym0, MapSym1, MapSym2,
-  (:++$), (:++$$),
+  (:++$), (:++$$), (:++$$$),
   OtherwiseSym0,
   IdSym0, IdSym1,
   ConstSym0, ConstSym1, ConstSym2,
-  (:.$), (:.$$), (:.$$$),
+  (:.$), (:.$$), (:.$$$), (:.$$$$),
   type ($$), type ($$$), type ($$$$),
   type ($!$), type ($!$$), type ($!$$$),
-  FlipSym0, FlipSym1, FlipSym2,
+  FlipSym0, FlipSym1, FlipSym2, FlipSym3,
   AsTypeOfSym0, AsTypeOfSym1, AsTypeOfSym2,
   SeqSym0, SeqSym1, SeqSym2
   ) where
 
 import Data.Singletons.Prelude.Instances
-import Data.Singletons.TH
+import Data.Singletons.Single
+import Data.Singletons
 import Data.Singletons.Prelude.Bool
 
 -- Promoted and singletonized versions of "otherwise" are imported and
@@ -65,6 +66,7 @@
   (++)                    :: [a] -> [a] -> [a]
   (++) []     ys          = ys
   (++) (x:xs) ys          = x : xs ++ ys
+  infixr 5 ++
 
   id                      :: a -> a
   id x                    =  x
@@ -74,6 +76,7 @@
 
   (.)    :: (b -> c) -> (a -> b) -> a -> c
   (.) f g = \x -> f (g x)
+  infixr 9 .
 
   flip                    :: (a -> b -> c) -> b -> a -> c
   flip f x y              =  f y x
@@ -85,12 +88,14 @@
   -- place to do it.
   seq :: a -> b -> b
   seq _ x = x
+  infixr 0 `seq`
  |])
 
 -- ($) is a special case, because its kind-inference data constructors
 -- clash with (:). See #29.
 type family (f :: TyFun a b -> *) $ (x :: a) :: b
 type instance f $ x = f @@ x
+infixr 0 $
 
 data ($$) :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *
 type instance Apply ($$) arg = ($$$) arg
@@ -103,9 +108,11 @@
 (%$) :: forall (f :: TyFun a b -> *) (x :: a).
         Sing f -> Sing x -> Sing (($$) @@ f @@ x)
 f %$ x = applySing f x
+infixr 0 %$
 
 type family (f :: TyFun a b -> *) $! (x :: a) :: b
 type instance f $! x = f @@ x
+infixr 0 $!
 
 data ($!$) :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *
 type instance Apply ($!$) arg = ($!$$) arg
@@ -118,3 +125,4 @@
 (%$!) :: forall (f :: TyFun a b -> *) (x :: a).
         Sing f -> Sing x -> Sing (($!$) @@ f @@ x)
 f %$! x = applySing f x
+infixr 0 %$!
diff --git a/src/Data/Singletons/Prelude/Bool.hs b/src/Data/Singletons/Prelude/Bool.hs
--- a/src/Data/Singletons/Prelude/Bool.hs
+++ b/src/Data/Singletons/Prelude/Bool.hs
@@ -1,9 +1,5 @@
 {-# LANGUAGE TemplateHaskell, DataKinds, PolyKinds, TypeFamilies, TypeOperators,
-             GADTs, CPP, ScopedTypeVariables, DeriveDataTypeable #-}
-
-#if __GLASGOW_HASKELL__ < 707
-{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-#endif
+             GADTs, ScopedTypeVariables, DeriveDataTypeable, UndecidableInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -61,7 +57,7 @@
 import Data.Singletons
 import Data.Singletons.Prelude.Instances
 import Data.Singletons.Single
-import Data.Singletons.Types
+import Data.Type.Bool ( If )
 
 $(singletons [d|
   bool_ :: a -> a -> Bool -> a
@@ -73,10 +69,12 @@
   (&&) :: Bool -> Bool -> Bool
   False && _ = False
   True  && x = x
+  infixr 3 &&
 
   (||) :: Bool -> Bool -> Bool
   False || x = x
   True  || _ = True
+  infixr 2 ||
 
   not :: Bool -> Bool
   not False = True
diff --git a/src/Data/Singletons/Prelude/Either.hs b/src/Data/Singletons/Prelude/Either.hs
--- a/src/Data/Singletons/Prelude/Either.hs
+++ b/src/Data/Singletons/Prelude/Either.hs
@@ -1,9 +1,5 @@
 {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeFamilies, GADTs,
-             DataKinds, PolyKinds, RankNTypes, UndecidableInstances, CPP #-}
-
-#if __GLASGOW_HASKELL__ < 707
-{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-#endif
+             DataKinds, PolyKinds, RankNTypes, UndecidableInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
diff --git a/src/Data/Singletons/Prelude/Enum.hs b/src/Data/Singletons/Prelude/Enum.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/Prelude/Enum.hs
@@ -0,0 +1,137 @@
+{-# LANGUAGE TemplateHaskell, DataKinds, PolyKinds, ScopedTypeVariables,
+             TypeFamilies, TypeOperators, GADTs, UndecidableInstances,
+             FlexibleContexts, DefaultSignatures, BangPatterns,
+             InstanceSigs #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.Prelude.Enum
+-- Copyright   :  (C) 2014 Jan Stolarek, Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Jan Stolarek (jan.stolarek@p.lodz.pl)
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Defines the promoted and singleton version of Bounded, 'PBounded'
+-- and 'SBounded'
+--
+-----------------------------------------------------------------------------
+
+module Data.Singletons.Prelude.Enum (
+  PBounded(..), SBounded(..),
+  PEnum(..), SEnum(..),
+
+  -- ** Defunctionalization symbols
+  MinBoundSym0,
+  MaxBoundSym0,
+  SuccSym0, SuccSym1,
+  PredSym0, PredSym1,
+  ToEnumSym0, ToEnumSym1,
+  FromEnumSym0, FromEnumSym1,
+  EnumFromToSym0, EnumFromToSym1, EnumFromToSym2,
+  EnumFromThenToSym0, EnumFromThenToSym1, EnumFromThenToSym2,
+  EnumFromThenToSym3
+
+  ) where
+
+import Data.Singletons.Single
+import Data.Singletons.Util
+import Data.Singletons.Prelude.Num
+import Data.Singletons.Prelude.Base
+import Data.Singletons.Prelude.Ord
+import Data.Singletons.Prelude.Eq
+import Data.Singletons.Prelude.Instances
+import Data.Singletons.TypeLits
+
+$(singletonsOnly [d|
+  class Bounded a where
+    minBound, maxBound :: a
+  |])
+
+$(singBoundedInstances boundedBasicTypes)
+
+$(singletonsOnly [d|
+  class  Enum a   where
+      -- | the successor of a value.  For numeric types, 'succ' adds 1.
+      succ                :: a -> a
+      -- | the predecessor of a value.  For numeric types, 'pred' subtracts 1.
+      pred                :: a -> a
+      -- | Convert from a 'Nat'.
+      toEnum              :: Nat -> a
+      -- | Convert to a 'Nat'.
+      fromEnum            :: a -> Nat
+
+      -- The following use infinite lists, and are not promotable:
+      -- -- | Used in Haskell's translation of @[n..]@.
+      -- enumFrom            :: a -> [a]
+      -- -- | Used in Haskell's translation of @[n,n'..]@.
+      -- enumFromThen        :: a -> a -> [a]
+
+      -- | Used in Haskell's translation of @[n..m]@.
+      enumFromTo          :: a -> a -> [a]
+      -- | Used in Haskell's translation of @[n,n'..m]@.
+      enumFromThenTo      :: a -> a -> a -> [a]
+
+      succ                   = toEnum . (1 +)  . fromEnum
+      pred                   = toEnum . (subtract 1) . fromEnum
+      -- enumFrom x             = map toEnum [fromEnum x ..]
+      -- enumFromThen x y       = map toEnum [fromEnum x, fromEnum y ..]
+      enumFromTo x y         = map toEnum [fromEnum x .. fromEnum y]
+      enumFromThenTo x1 x2 y = map toEnum [fromEnum x1, fromEnum x2 .. fromEnum y]
+
+  -- Nat instance for Enum
+  eftNat :: Nat -> Nat -> [Nat]
+  -- [x1..x2]
+  eftNat x0 y | (x0 > y)  = []
+              | otherwise = go x0
+                 where
+                   go x = x : if (x == y) then [] else go (x + 1)
+
+  efdtNat :: Nat -> Nat -> Nat -> [Nat]
+  -- [x1,x2..y]
+  efdtNat x1 x2 y
+   | x2 >= x1  = efdtNatUp x1 x2 y
+   | otherwise = efdtNatDn x1 x2 y
+
+  -- Requires x2 >= x1
+  efdtNatUp :: Nat -> Nat -> Nat -> [Nat]
+  efdtNatUp x1 x2 y    -- Be careful about overflow!
+   | y < x2    = if y < x1 then [] else [x1]
+   | otherwise = -- Common case: x1 <= x2 <= y
+                 let delta = x2 - x1 -- >= 0
+                     y' = y - delta  -- x1 <= y' <= y; hence y' is representable
+
+                     -- Invariant: x <= y
+                     -- Note that: z <= y' => z + delta won't overflow
+                     -- so we are guaranteed not to overflow if/when we recurse
+                     go_up x | x > y'    = [x]
+                             | otherwise = x : go_up (x + delta)
+                 in x1 : go_up x2
+
+  -- Requires x2 <= x1
+  efdtNatDn :: Nat -> Nat -> Nat -> [Nat]
+  efdtNatDn x1 x2 y    -- Be careful about underflow!
+   | y > x2    = if y > x1 then [] else [x1]
+   | otherwise = -- Common case: x1 >= x2 >= y
+                 let delta = x2 - x1 -- <= 0
+                     y' = y - delta  -- y <= y' <= x1; hence y' is representable
+
+                     -- Invariant: x >= y
+                     -- Note that: z >= y' => z + delta won't underflow
+                     -- so we are guaranteed not to underflow if/when we recurse
+                     go_dn x | x < y'    = [x]
+                             | otherwise = x : go_dn (x + delta)
+     in x1 : go_dn x2
+
+  instance  Enum Nat  where
+      succ x = x + 1
+      pred x = x - 1
+
+      toEnum   x = x
+      fromEnum x = x
+
+      enumFromTo = eftNat
+      enumFromThenTo = efdtNat
+  |])
+
+$(singEnumInstances enumBasicTypes)
diff --git a/src/Data/Singletons/Prelude/Eq.hs b/src/Data/Singletons/Prelude/Eq.hs
--- a/src/Data/Singletons/Prelude/Eq.hs
+++ b/src/Data/Singletons/Prelude/Eq.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE TypeOperators, DataKinds, PolyKinds, TypeFamilies,
              RankNTypes, FlexibleContexts, TemplateHaskell,
-             UndecidableInstances, GADTs, CPP, DefaultSignatures #-}
+             UndecidableInstances, GADTs, DefaultSignatures #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -26,24 +26,23 @@
 import Data.Singletons.Prelude.Instances
 import Data.Singletons.Util
 import Data.Singletons.Promote
-
-#if __GLASGOW_HASKELL__ >= 707
 import Data.Type.Equality
-#endif
 
--- | The promoted analogue of 'Eq'. If you supply no definition for '(:==)' under
--- GHC 7.8+, then it defaults to a use of '(==)', from @Data.Type.Equality@.
+-- NB: These must be defined by hand because of the custom handling of the
+-- default for (:==) to use Data.Type.Equality.==
+
+-- | The promoted analogue of 'Eq'. If you supply no definition for '(:==)',
+-- then it defaults to a use of '(==)', from @Data.Type.Equality@.
 class kproxy ~ 'KProxy => PEq (kproxy :: KProxy a) where
   type (:==) (x :: a) (y :: a) :: Bool
   type (:/=) (x :: a) (y :: a) :: Bool
 
-#if __GLASGOW_HASKELL__ < 707
-  type (x :: a) :== (y :: a) = Not (x :/= y)
-#else
   type (x :: a) :== (y :: a) = x == y
-#endif
   type (x :: a) :/= (y :: a) = Not (x :== y)
 
+infix 4 :==
+infix 4 :/=
+
 $(genDefunSymbols [''(:==), ''(:/=)])
 
 -- | The singleton analogue of 'Eq'. Unlike the definition for 'Eq', it is required
@@ -51,6 +50,7 @@
 class (kparam ~ 'KProxy) => SEq (kparam :: KProxy k) where
   -- | Boolean equality on singletons
   (%:==) :: forall (a :: k) (b :: k). Sing a -> Sing b -> Sing (a :== b)
+  infix 4 %:==
 
   -- | Boolean disequality on singletons
   (%:/=) :: forall (a :: k) (b :: k). Sing a -> Sing b -> Sing (a :/= b)
@@ -58,5 +58,6 @@
                     ((a :/= b) ~ Not (a :== b))
                  => Sing a -> Sing b -> Sing (a :/= b)
   a %:/= b = sNot (a %:== b)
+  infix 4 %:/=
 
 $(singEqInstances basicTypes)
diff --git a/src/Data/Singletons/Prelude/Instances.hs b/src/Data/Singletons/Prelude/Instances.hs
--- a/src/Data/Singletons/Prelude/Instances.hs
+++ b/src/Data/Singletons/Prelude/Instances.hs
@@ -8,14 +8,9 @@
 
 -}
 
-{-# LANGUAGE CPP, RankNTypes, DataKinds, PolyKinds, GADTs, TypeFamilies,
+{-# LANGUAGE RankNTypes, DataKinds, PolyKinds, GADTs, TypeFamilies,
              FlexibleContexts, TemplateHaskell, ScopedTypeVariables,
              UndecidableInstances, TypeOperators, FlexibleInstances #-}
-#if __GLASGOW_HASKELL__ < 707
-  -- optimizing instances of SDecide cause GHC to die (#8467)
-{-# OPTIONS_GHC -O0 #-}
-#endif
-
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
 module Data.Singletons.Prelude.Instances where
@@ -26,3 +21,14 @@
 -- some useful singletons
 $(genSingletons basicTypes)
 $(singDecideInstances basicTypes)
+
+-- basic definitions we need right away
+
+$(singletonsOnly [d|
+  foldl        :: forall a b. (b -> a -> b) -> b -> [a] -> b
+  foldl f z0 xs0 = lgo z0 xs0
+               where
+                 lgo :: b -> [a] -> b
+                 lgo z []     =  z
+                 lgo z (x:xs) = lgo (f z x) xs
+  |])
diff --git a/src/Data/Singletons/Prelude/List.hs b/src/Data/Singletons/Prelude/List.hs
--- a/src/Data/Singletons/Prelude/List.hs
+++ b/src/Data/Singletons/Prelude/List.hs
@@ -1,10 +1,7 @@
-{-# LANGUAGE CPP, TypeOperators, DataKinds, PolyKinds, TypeFamilies,
+{-# LANGUAGE TypeOperators, DataKinds, PolyKinds, TypeFamilies,
              TemplateHaskell, GADTs, UndecidableInstances, RankNTypes,
              ScopedTypeVariables, FlexibleContexts #-}
-
-#if __GLASGOW_HASKELL__ < 707
-{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-#endif
+{-# OPTIONS_GHC -O0 #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Singletons.Prelude.List
@@ -104,7 +101,7 @@
   NilSym0,
   (:$), (:$$), (:$$$),
 
-  (:++$$), (:++$), HeadSym0, HeadSym1, LastSym0, LastSym1,
+  (:++$$$), (:++$$), (:++$), HeadSym0, HeadSym1, LastSym0, LastSym1,
   TailSym0, TailSym1, InitSym0, InitSym1, NullSym0, NullSym1,
 
   MapSym0, MapSym1, MapSym2, ReverseSym0, ReverseSym1,
@@ -148,7 +145,7 @@
   ZipSym0, ZipSym1, ZipSym2,
   Zip3Sym0, Zip3Sym1, Zip3Sym2, Zip3Sym3,
   ZipWithSym0, ZipWithSym1, ZipWithSym2, ZipWithSym3,
-  ZipWith3Sym0, ZipWith3Sym1, ZipWith3Sym2, ZipWith3Sym3,
+  ZipWith3Sym0, ZipWith3Sym1, ZipWith3Sym2, ZipWith3Sym3, ZipWith3Sym4,
   UnzipSym0, UnzipSym1,
   Unzip3Sym0, Unzip3Sym1,
   Unzip4Sym0, Unzip4Sym1,
@@ -191,11 +188,9 @@
   head []      = error "Data.Singletons.List.head: empty list"
 
   last :: [a] -> a
-  last []      =  error "Data.Singletons.List.last: empty list"
-  last (x:xs)  =  last' x xs
-    where last' :: a -> [a] -> a
-          last' y []     = y
-          last' _ (y:ys) = last' y ys
+  last []       =  error "Data.Singletons.List.last: empty list"
+  last [x]      =  x
+  last (_:x:xs) =  last (x:xs)
 
   tail :: [a] -> [a]
   tail (_ : t) = t
@@ -248,13 +243,6 @@
               interleave' f (y:ys) r = let (us,zs) = interleave' (f . (y:)) ys r
                                        in  (y:us, f (t:y:us) : zs)
 
-  foldl        :: (b -> a -> b) -> b -> [a] -> b
-  foldl f z0 xs0 = lgo z0 xs0
-               where
-                 lgo :: b -> [a] -> b
-                 lgo z []     =  z
-                 lgo z (x:xs) = lgo (f z x) xs
-
   foldl'           :: forall a b. (b -> a -> b) -> b -> [a] -> b
   foldl' f z0 xs0 = lgo z0 xs0
       where lgo :: b -> [a] -> b
@@ -458,6 +446,7 @@
 
   (\\)                    :: (Eq a) => [a] -> [a] -> [a]
   (\\)                    =  foldl (flip delete)
+  infix 5 \\
 
   deleteBy                :: (a -> a -> Bool) -> a -> [a] -> [a]
   deleteBy _  _ []        = []
@@ -496,4 +485,3 @@
                                          LT -> x
 
   |])
-
diff --git a/src/Data/Singletons/Prelude/Maybe.hs b/src/Data/Singletons/Prelude/Maybe.hs
--- a/src/Data/Singletons/Prelude/Maybe.hs
+++ b/src/Data/Singletons/Prelude/Maybe.hs
@@ -1,10 +1,6 @@
 {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeFamilies,
              DataKinds, PolyKinds, UndecidableInstances, GADTs,
-             RankNTypes, CPP #-}
-
-#if __GLASGOW_HASKELL__ < 707
-{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-#endif
+             RankNTypes #-}
 
 -----------------------------------------------------------------------------
 -- |
diff --git a/src/Data/Singletons/Prelude/Num.hs b/src/Data/Singletons/Prelude/Num.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/Prelude/Num.hs
@@ -0,0 +1,130 @@
+{-# LANGUAGE TemplateHaskell, PolyKinds, DataKinds, TypeFamilies,
+             TypeOperators, GADTs, ScopedTypeVariables, UndecidableInstances,
+             DefaultSignatures, FlexibleContexts
+  #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.Prelude.Num
+-- Copyright   :  (C) 2014 Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu)
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Defines and exports promoted and singleton versions of definitions from
+-- GHC.Num.
+--
+----------------------------------------------------------------------------
+
+module Data.Singletons.Prelude.Num (
+  PNum(..), SNum(..), Subtract, sSubtract,
+
+  -- ** Defunctionalization symbols
+  (:+$), (:+$$), (:+$$$),
+  (:-$), (:-$$), (:-$$$),
+  (:*$), (:*$$), (:*$$$),
+  NegateSym0, NegateSym1,
+  AbsSym0, AbsSym1,
+  SignumSym0, SignumSym1,
+  FromIntegerSym0, FromIntegerSym1,
+  SubtractSym0, SubtractSym1, SubtractSym2
+  ) where
+
+import Data.Singletons.Single
+import Data.Singletons
+import Data.Singletons.TypeLits.Internal
+import Data.Singletons.Decide
+import GHC.TypeLits
+import Data.Proxy
+import Unsafe.Coerce
+
+$(singletonsOnly [d|
+  -- | Basic numeric class.
+  --
+  -- Minimal complete definition: all except 'negate' or @(-)@
+  class  Num a  where
+      (+), (-), (*)       :: a -> a -> a
+      infixl 6 +
+      infixl 6 -
+      infixl 6 *
+      -- | Unary negation.
+      negate              :: a -> a
+      -- | Absolute value.
+      abs                 :: a -> a
+      -- | Sign of a number.
+      -- The functions 'abs' and 'signum' should satisfy the law:
+      --
+      -- > abs x * signum x == x
+      --
+      -- For real numbers, the 'signum' is either @-1@ (negative), @0@ (zero)
+      -- or @1@ (positive).
+      signum              :: a -> a
+      -- | Conversion from a 'Nat'.
+      fromInteger         :: Nat -> a
+
+      x - y               = x + negate y
+
+      negate x            = 0 - x
+  |])
+
+-- PNum instance
+type family SignumNat (a :: Nat) :: Nat where
+  SignumNat 0 = 0
+  SignumNat x = 1
+
+instance PNum ('KProxy :: KProxy Nat) where
+  type a :+ b = a + b
+  type a :- b = a - b
+  type a :* b = a * b
+  type Negate (a :: Nat) = Error "Cannot negate a natural number"
+  type Abs (a :: Nat) = a
+  type Signum a = SignumNat a
+  type FromInteger a = a
+
+-- SNum instance
+instance SNum ('KProxy :: KProxy Nat) where
+  sa %:+ sb =
+    let a = fromSing sa
+        b = fromSing sb
+        ex = someNatVal (a + b)
+    in
+    case ex of
+      Just (SomeNat (_ :: Proxy ab)) -> unsafeCoerce (SNat :: Sing ab)
+      Nothing                        -> error "Two naturals added to a negative?"
+
+  sa %:- sb =
+    let a = fromSing sa
+        b = fromSing sb
+        ex = someNatVal (a - b)
+    in
+    case ex of
+      Just (SomeNat (_ :: Proxy ab)) -> unsafeCoerce (SNat :: Sing ab)
+      Nothing                        ->
+        error "Negative natural-number singletons are naturally not allowed."
+
+  sa %:* sb =
+    let a = fromSing sa
+        b = fromSing sb
+        ex = someNatVal (a * b)
+    in
+    case ex of
+      Just (SomeNat (_ :: Proxy ab)) -> unsafeCoerce (SNat :: Sing ab)
+      Nothing                        ->
+        error "Two naturals multiplied to a negative?"
+
+  sNegate _ = error "Cannot call sNegate on a natural number singleton."
+
+  sAbs x = x
+
+  sSignum sx =
+    case sx %~ (sing :: Sing 0) of
+      Proved Refl -> sing :: Sing 0
+      Disproved _ -> unsafeCoerce (sing :: Sing 1)
+
+  sFromInteger x = x
+
+$(singletonsOnly [d|
+  subtract :: Num a => a -> a -> a
+  subtract x y = y - x
+  |])
diff --git a/src/Data/Singletons/Prelude/Ord.hs b/src/Data/Singletons/Prelude/Ord.hs
--- a/src/Data/Singletons/Prelude/Ord.hs
+++ b/src/Data/Singletons/Prelude/Ord.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE TemplateHaskell, DataKinds, PolyKinds, ScopedTypeVariables,
              TypeFamilies, TypeOperators, GADTs, UndecidableInstances,
-             FlexibleContexts, DefaultSignatures #-}
+             FlexibleContexts, DefaultSignatures, InstanceSigs #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -37,18 +37,20 @@
   MinSym0, MinSym1, MinSym2
   ) where
 
-import Data.Singletons.Promote
 import Data.Singletons.Single
 import Data.Singletons.Prelude.Eq
 import Data.Singletons.Prelude.Instances
 import Data.Singletons.Prelude.Bool
-import Data.Singletons
 import Data.Singletons.Util
 
-$(promoteOnly [d|
+$(singletonsOnly [d|
   class  (Eq a) => Ord a  where
     compare              :: a -> a -> Ordering
     (<), (<=), (>), (>=) :: a -> a -> Bool
+    infix 4 <=
+    infix 4 <
+    infix 4 >
+    infix 4 >=
     max, min             :: a -> a -> a
 
     compare x y = if x == y then EQ
@@ -58,68 +60,18 @@
                   else if x <= y then LT
                   else GT
 
-    x <  y = case compare x y of { LT -> True;  _ -> False }
-    x <= y = case compare x y of { GT -> False; _ -> True }
-    x >  y = case compare x y of { GT -> True;  _ -> False }
-    x >= y = case compare x y of { LT -> False; _ -> True }
+    x <  y = case compare x y of { LT -> True;  EQ -> False; GT -> False }
+    x <= y = case compare x y of { LT -> True;  EQ -> True;  GT -> False }
+    x >  y = case compare x y of { LT -> False; EQ -> False; GT -> True }
+    x >= y = case compare x y of { LT -> False; EQ -> True;  GT -> True }
 
         -- These two default methods use '<=' rather than 'compare'
         -- because the latter is often more expensive
     max x y = if x <= y then y else x
     min x y = if x <= y then x else y
     -- Not handled by TH: {-# MINIMAL compare | (<=) #-}
-  |])
 
-type family CaseOrdering (ord :: Ordering) (lt :: k) (eq :: k) (gt :: k) :: k
-type instance CaseOrdering 'LT lt eq gt = lt
-type instance CaseOrdering 'EQ lt eq gt = eq
-type instance CaseOrdering 'GT lt eq gt = gt
-
-class (kproxy ~ 'KProxy, SEq ('KProxy :: KProxy a))
-      => SOrd (kproxy :: KProxy a) where
-  sCompare :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (Compare x y)
-  (%:<)    :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (x :< y)
-  (%:<=)   :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (x :<= y)
-  (%:>)    :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (x :> y)
-  (%:>=)   :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (x :>= y)
-  sMax      :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (Max x y)
-  sMin      :: forall (x :: a) (y :: a). Sing x -> Sing y -> Sing (Min x y)
-
-  default sCompare :: forall (x :: a) (y :: a).
-                      (Compare x y ~ If (x :== y) 'EQ (If (x :<= y) 'LT 'GT))
-                   => Sing x -> Sing y -> Sing (Compare x y)
-  sCompare x y = sIf (x %:== y) SEQ
-                     (sIf (x %:<= y) SLT SGT)
-
-  default (%:<) :: forall (x :: a) (y :: a).
-                   ((x :< y) ~ CaseOrdering (Compare x y) 'True 'False 'False)
-                => Sing x -> Sing y -> Sing (x :< y)
-  x %:< y = case sCompare x y of { SLT -> STrue; SEQ -> SFalse; SGT -> SFalse }
-
-  default (%:<=) :: forall (x :: a) (y :: a).
-                    ((x :<= y) ~ CaseOrdering (Compare x y) 'True 'True 'False)
-                 => Sing x -> Sing y -> Sing (x :<= y)
-  x %:<= y = case sCompare x y of { SLT -> STrue; SEQ -> STrue; SGT -> SFalse }
-
-  default (%:>) :: forall (x :: a) (y :: a).
-                   ((x :> y) ~ CaseOrdering (Compare x y) 'False 'False 'True)
-                => Sing x -> Sing y -> Sing (x :> y)
-  x %:> y = case sCompare x y of { SLT -> SFalse; SEQ -> SFalse; SGT -> STrue }
-
-  default (%:>=) :: forall (x :: a) (y :: a).
-                    ((x :>= y) ~ CaseOrdering (Compare x y) 'False 'True 'True)
-                 => Sing x -> Sing y -> Sing (x :>= y)
-  x %:>= y = case sCompare x y of { SLT -> SFalse; SEQ -> STrue; SGT -> STrue }
-
-  default sMax :: forall (x :: a) (y :: a).
-                  (Max x y ~ If (x :<= y) y x)
-               => Sing x -> Sing y -> Sing (Max x y)
-  sMax x y = sIf (x %:<= y) y x
-
-  default sMin :: forall (x :: a) (y :: a).
-                  (Min x y ~ If (x :<= y) x y)
-               => Sing x -> Sing y -> Sing (Min x y)
-  sMin x y = sIf (x %:<= y) x y
+  |])
 
 $(singletons [d|
   thenCmp :: Ordering -> Ordering -> Ordering
@@ -128,4 +80,4 @@
   thenCmp GT _ = GT
   |])
 
-$(promoteOrdInstances basicTypes)
+$(singOrdInstances basicTypes)
diff --git a/src/Data/Singletons/Prelude/Tuple.hs b/src/Data/Singletons/Prelude/Tuple.hs
--- a/src/Data/Singletons/Prelude/Tuple.hs
+++ b/src/Data/Singletons/Prelude/Tuple.hs
@@ -1,9 +1,5 @@
 {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, DataKinds, PolyKinds,
-             RankNTypes, TypeFamilies, GADTs, CPP, UndecidableInstances #-}
-
-#if __GLASGOW_HASKELL__ < 707
-{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-#endif
+             RankNTypes, TypeFamilies, GADTs, UndecidableInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
diff --git a/src/Data/Singletons/Promote.hs b/src/Data/Singletons/Promote.hs
--- a/src/Data/Singletons/Promote.hs
+++ b/src/Data/Singletons/Promote.hs
@@ -7,32 +7,29 @@
 type level. It is an internal module to the singletons package.
 -}
 
-{-# LANGUAGE TemplateHaskell, CPP, MultiWayIf, LambdaCase, TupleSections #-}
+{-# LANGUAGE TemplateHaskell, MultiWayIf, LambdaCase, TupleSections, CPP #-}
 
 module Data.Singletons.Promote where
 
 import Language.Haskell.TH hiding ( Q, cxt )
-import Language.Haskell.TH.Syntax ( qNewName )
+import Language.Haskell.TH.Syntax ( Quasi(..) )
 import Language.Haskell.TH.Desugar
-import Language.Haskell.TH.Desugar.Lift ()
 import Data.Singletons.Names
 import Data.Singletons.Promote.Monad
 import Data.Singletons.Promote.Eq
-import Data.Singletons.Promote.Ord
-import Data.Singletons.Promote.Bounded
 import Data.Singletons.Promote.Defun
 import Data.Singletons.Promote.Type
+import Data.Singletons.Deriving.Ord
+import Data.Singletons.Deriving.Bounded
+import Data.Singletons.Deriving.Enum
+import Data.Singletons.Partition
 import Data.Singletons.Util
 import Data.Singletons.Syntax
 import Prelude hiding (exp)
 import Control.Monad
-import Data.Maybe
 import qualified Data.Map.Strict as Map
 import Data.Map.Strict ( Map )
-
-#if __GLASGOW_HASKELL__ < 709
-import Control.Applicative
-#endif
+import Data.Maybe
 
 -- | Generate promoted definitions from a type that is already defined.
 -- This is generally only useful with classes.
@@ -52,7 +49,9 @@
   promDecls <- promoteM_ decls $ promoteDecs ddecls
   return $ decls ++ decsToTH promDecls
 
--- | Promote each declaration, discarding the originals.
+-- | Promote each declaration, discarding the originals. Note that a promoted
+-- datatype uses the same definition as an original datatype, so this will
+-- not work with datatypes. Classes, instances, and functions are all fine.
 promoteOnly :: DsMonad q => q [Dec] -> q [Dec]
 promoteOnly qdec = do
   decls  <- qdec
@@ -72,56 +71,50 @@
 promoteEqInstances :: DsMonad q => [Name] -> q [Dec]
 promoteEqInstances = concatMapM promoteEqInstance
 
--- | Produce instances for 'Compare' from the given types
+-- | Produce instances for 'POrd' from the given types
 promoteOrdInstances :: DsMonad q => [Name] -> q [Dec]
 promoteOrdInstances = concatMapM promoteOrdInstance
 
--- | Produce instances for 'MinBound' and 'MaxBound' from the given types
+-- | Produce an instance for 'POrd' from the given type
+promoteOrdInstance :: DsMonad q => Name -> q [Dec]
+promoteOrdInstance = promoteInstance mkOrdInstance "Ord"
+
+-- | Produce instances for 'PBounded' from the given types
 promoteBoundedInstances :: DsMonad q => [Name] -> q [Dec]
 promoteBoundedInstances = concatMapM promoteBoundedInstance
 
+-- | Produce an instance for 'PBounded' from the given type
+promoteBoundedInstance :: DsMonad q => Name -> q [Dec]
+promoteBoundedInstance = promoteInstance mkBoundedInstance "Bounded"
+
+-- | Produce instances for 'PEnum' from the given types
+promoteEnumInstances :: DsMonad q => [Name] -> q [Dec]
+promoteEnumInstances = concatMapM promoteEnumInstance
+
+-- | Produce an instance for 'PEnum' from the given type
+promoteEnumInstance :: DsMonad q => Name -> q [Dec]
+promoteEnumInstance = promoteInstance mkEnumInstance "Enum"
+
 -- | Produce an instance for '(:==)' (type-level equality) from the given type
 promoteEqInstance :: DsMonad q => Name -> q [Dec]
 promoteEqInstance name = do
   (_tvbs, cons) <- getDataD "I cannot make an instance of (:==) for it." name
   cons' <- mapM dsCon cons
-#if __GLASGOW_HASKELL__ >= 707
   vars <- replicateM (length _tvbs) (qNewName "k")
   kind <- promoteType (foldType (DConT name) (map DVarT vars))
   inst_decs <- mkEqTypeInstance kind cons'
   return $ decsToTH inst_decs
-#else
-  let pairs = [(c1, c2) | c1 <- cons, c2 <- cons]
-  mapM (fmap decsToTH . mkEqTypeInstance) pairs
-#endif
 
--- | Produce an instance for 'Compare' from the given type
-promoteOrdInstance :: DsMonad q => Name -> q [Dec]
-promoteOrdInstance name = do
-  (_tvbs, cons) <- getDataD "I cannot make an instance of Ord for it." name
-  cons' <- mapM dsCon cons
-#if __GLASGOW_HASKELL__ >= 707
-  vars <- replicateM (length _tvbs) (qNewName "k")
-  kind <- promoteType (foldType (DConT name) (map DVarT vars))
-  inst_decs <- mkOrdTypeInstance kind cons'
-  return $ decsToTH inst_decs
-#else
-  fail "promoteOrdInstance not implemented for GHC 7.6"
-#endif
-
--- | Produce an instance for 'MinBound' and 'MaxBound' from the given type
-promoteBoundedInstance :: DsMonad q => Name -> q [Dec]
-promoteBoundedInstance name = do
-  (_tvbs, cons) <- getDataD "I cannot make an instance of Bounded for it." name
+promoteInstance :: DsMonad q => (DType -> [DCon] -> q UInstDecl)
+                -> String -> Name -> q [Dec]
+promoteInstance mk_inst class_name name = do
+  (tvbs, cons) <- getDataD ("I cannot make an instance of " ++ class_name
+                            ++ " for it.") name
   cons' <- mapM dsCon cons
-#if __GLASGOW_HASKELL__ >= 707
-  vars <- replicateM (length _tvbs) (qNewName "k")
-  kind <- promoteType (foldType (DConT name) (map DVarT vars))
-  inst_decs <- mkBoundedTypeInstance kind cons'
-  return $ decsToTH inst_decs
-#else
-  fail "promoteBoundedInstance not implemented for GHC 7.6"
-#endif
+  tvbs' <- mapM dsTvb tvbs
+  raw_inst <- mk_inst (foldType (DConT name) (map tvbToType tvbs')) cons'
+  decs <- promoteM_ [] $ void $ promoteInstanceDec Map.empty raw_inst
+  return $ decsToTH decs
 
 promoteInfo :: DInfo -> PrM ()
 promoteInfo (DTyConI dec _instances) = promoteDecs [dec]
@@ -170,9 +163,9 @@
 
 -- Promote a list of top-level declarations.
 promoteDecs :: [DDec] -> PrM ()
-promoteDecs decls = do
+promoteDecs raw_decls = do
+  decls <- expand raw_decls     -- expand type synonyms
   checkForRepInDecls decls
-  -- See Note [Promoting declarations in two stages]
   PDecs { pd_let_decs              = let_decs
         , pd_class_decs            = classes
         , pd_instance_decs         = insts
@@ -180,8 +173,9 @@
 
     -- promoteLetDecs returns LetBinds, which we don't need at top level
   _ <- promoteLetDecs noPrefix let_decs
-  (cls_tvb_env, meth_sigs) <- concatMapM promoteClassDec classes
-  mapM_ (promoteInstanceDec cls_tvb_env meth_sigs) insts
+  mapM_ promoteClassDec classes
+  let all_meth_sigs = foldMap (lde_types . cd_lde) classes
+  mapM_ (promoteInstanceDec all_meth_sigs) insts
   promoteDataDecs datas
 
 promoteDataDecs :: [DataDecl] -> PrM ()
@@ -193,13 +187,14 @@
     extract_rec_selectors :: DataDecl -> PrM [DLetDec]
     extract_rec_selectors (DataDecl _nd data_name tvbs cons _derivings) =
       let arg_ty = foldType (DConT data_name)
-                            (map (DVarT . extractTvbName) tvbs)
+                            (map tvbToType tvbs)
       in
       concatMapM (getRecordSelectors arg_ty) cons
 
 -- curious about ALetDecEnv? See the LetDecEnv module for an explanation.
 promoteLetDecs :: (String, String) -- (alpha, symb) prefixes to use
                -> [DLetDec] -> PrM ([LetBind], ALetDecEnv)
+  -- See Note [Promoting declarations in two stages]
 promoteLetDecs prefixes decls = do
   let_dec_env <- buildLetDecEnv decls
   all_locals <- allLocals
@@ -226,79 +221,55 @@
 --  * for each nullary data constructor we generate a type synonym
 promoteDataDec :: DataDecl -> PrM ()
 promoteDataDec (DataDecl _nd name tvbs ctors derivings) = do
-#if __GLASGOW_HASKELL__ < 707
-  when (_nd == Newtype) $
-    fail $ "Newtypes don't promote under GHC 7.6. " ++
-           "Use <<data>> instead or upgrade GHC."
-#endif
   -- deriving Eq instance
-  _kvs <- replicateM (length tvbs) (qNewName "k")
-  _kind <- promoteType (foldType (DConT name) (map DVarT _kvs))
+  kvs <- replicateM (length tvbs) (qNewName "k")
+  kind <- promoteType (foldType (DConT name) (map DVarT kvs))
   when (elem eqName derivings) $ do
-#if __GLASGOW_HASKELL__ >= 707
-    eq_decs <- mkEqTypeInstance _kind ctors
-#else
-    let pairs = [ (c1, c2) | c1 <- ctors, c2 <- ctors ]
-    eq_decs <- mapM mkEqTypeInstance pairs
-#endif
+    eq_decs <- mkEqTypeInstance kind ctors
     emitDecs eq_decs
 
-  -- deriving Ord instance
-  when (elem ordName derivings) $ do
-#if __GLASGOW_HASKELL__ >= 707
-    ord_decs <- mkOrdTypeInstance _kind ctors
-#else
-    fail "Ord deriving not yet implemented in GHC 7.6"
-#endif
-    emitDecs ord_decs
-
-  -- deriving Bounded instance
-  when (elem boundedName derivings) $ do
-#if __GLASGOW_HASKELL__ >= 707
-    bounded_decs <- mkBoundedTypeInstance _kind ctors
-#else
-    fail "Bounded deriving not yet implemented in GHC 7.6"
-#endif
-    emitDecs bounded_decs
-
   ctorSyms <- buildDefunSymsDataD name tvbs ctors
   emitDecs ctorSyms
 
-promoteClassDec :: ClassDecl
-                -> PrM ( Map Name [Name]    -- from class names to tyvar lists
-                       , Map Name DType )   -- returns method signatures
-promoteClassDec (ClassDecl cxt cls_name tvbs
-                           (LetDecEnv { lde_defns = defaults
-                                      , lde_types = meth_sigs
-                                      , lde_infix = infix_decls })) = do
-  let tvbNames = map extractTvbName tvbs
-      pClsName = promoteClassName cls_name
-  kproxies <- mapM (const $ qNewName "kproxy") tvbs
+promoteClassDec :: UClassDecl
+                -> PrM AClassDecl
+promoteClassDec decl@(ClassDecl { cd_cxt  = cxt
+                                , cd_name = cls_name
+                                , cd_tvbs = tvbs
+                                , cd_fds  = fundeps
+                                , cd_lde  = lde@LetDecEnv
+                                    { lde_defns = defaults
+                                    , lde_types = meth_sigs
+                                    , lde_infix = infix_decls } }) = do
+  let pClsName = promoteClassName cls_name
+  (ptvbs, proxyCxt) <- mkKProxies (map extractTvbName tvbs)
   pCxt <- mapM promote_superclass_pred cxt
-  let proxyCxt = map (\kp -> foldl DAppPr (DConPr equalityName)
-                                   [DVarT kp, DConT kProxyDataName]) kproxies
-      cxt'  = pCxt ++ proxyCxt
-      ptvbs = zipWith (\proxy tvbName -> DKindedTV proxy
-                                           (DConK kProxyTypeName [DVarK tvbName]))
-                      kproxies tvbNames
-  sig_decs     <- mapM (uncurry promote_sig) (Map.toList meth_sigs)
+  let cxt'  = pCxt ++ proxyCxt
+  sig_decs <- mapM (uncurry promote_sig) (Map.toList meth_sigs)
      -- the first arg to promoteMethod is a kind subst. We actually don't
      -- want to subst for default instances, so we pass Map.empty
-  default_decs <- concatMapM (promoteMethod Map.empty meth_sigs)
-                             (Map.toList defaults)
+  let defaults_list  = Map.toList defaults
+      defaults_names = map fst defaults_list
+  (default_decs, ann_rhss, prom_rhss)
+    <- mapAndUnzip3M (promoteMethod Map.empty meth_sigs) defaults_list
+
   let infix_decls' = catMaybes $ map (uncurry promoteInfixDecl) infix_decls
-  emitDecs [ DClassD cxt' pClsName ptvbs [] (sig_decs ++
-                                             default_decs ++
-                                             infix_decls') ]
-  return ( Map.singleton cls_name tvbNames
-         , meth_sigs )
+
+  -- no need to do anything to the fundeps. They work as is!
+  emitDecs [DClassD cxt' pClsName ptvbs fundeps
+                    (sig_decs ++ default_decs ++ infix_decls')]
+  let defaults_list' = zip defaults_names ann_rhss
+      proms          = zip defaults_names prom_rhss
+  return (decl { cd_lde = lde { lde_defns = Map.fromList defaults_list'
+                              , lde_proms = Map.fromList proms } })
   where
     promote_sig :: Name -> DType -> PrM DDec
     promote_sig name ty = do
       let proName = promoteValNameLhs name
-      (argKs, resK) <- snocView `liftM` (mapM promoteType (snd $ unravel ty))
+      (argKs, resK) <- promoteUnraveled ty
       args <- mapM (const $ qNewName "arg") argKs
       emitDecsM $ defunctionalize proName (map Just argKs) (Just resK)
+
       return $ DFamilyD TypeFam proName
                         (zipWith DKindedTV args argKs)
                         (Just resK)
@@ -312,122 +283,100 @@
                               ++ show name
       go (DConPr name)  = return $ DConPr (promoteClassName name)
 
-promoteInstanceDec :: Map Name [Name] -> Map Name DType -> InstDecl -> PrM ()
-promoteInstanceDec cls_tvb_env meth_sigs
-                   (InstDecl cls_name inst_tys meths) = do
+-- returns (unpromoted method name, ALetDecRHS) pairs
+promoteInstanceDec :: Map Name DType -> UInstDecl -> PrM AInstDecl
+promoteInstanceDec meth_sigs
+                   decl@(InstDecl { id_name     = cls_name
+                                  , id_arg_tys  = inst_tys
+                                  , id_meths    = meths }) = do
   cls_tvb_names <- lookup_cls_tvb_names
   inst_kis <- mapM promoteType inst_tys
   let subst = Map.fromList $ zip cls_tvb_names inst_kis
-  meths' <- concatMapM (promoteMethod subst meth_sigs) meths
+  (meths', ann_rhss, _) <- mapAndUnzip3M (promoteMethod subst meth_sigs) meths
   emitDecs [DInstanceD [] (foldType (DConT pClsName)
                                     (map kindParam inst_kis)) meths']
+  return (decl { id_meths = zip (map fst meths) ann_rhss })
   where
     pClsName = promoteClassName cls_name
 
-    lookup_cls_tvb_names :: PrM [String]
-    lookup_cls_tvb_names = case Map.lookup cls_name cls_tvb_env of
-      Nothing -> do
-        m_dinfo <- dsReify pClsName
-        case m_dinfo of
-          Just (DTyConI (DClassD _cxt _name cls_tvbs _fds _decs) _insts) -> do
-            mapM extract_kv_name cls_tvbs
-          _ -> fail $ "Cannot find class declaration for " ++ show cls_name
-          -- See Note [Bad Names in reification]
-      Just tvb_names -> return $ map nameBase tvb_names
+    lookup_cls_tvb_names :: PrM [Name]
+    lookup_cls_tvb_names = do
+      mb_info <- dsReify pClsName
+      case mb_info of
+        Just (DTyConI (DClassD _ _ tvbs _ _) _) -> return (map extract_kv_name tvbs)
+        _ -> do
+          mb_info' <- dsReify cls_name
+          case mb_info' of
+            Just (DTyConI (DClassD _ _ tvbs _ _) _) -> return (map extractTvbName tvbs)
+            _ -> fail $ "Cannot find class declaration annotation for " ++ show cls_name
 
-    extract_kv_name :: DTyVarBndr -> PrM String
-    extract_kv_name (DKindedTV _kpVar (DConK _kpType [DVarK kv])) =
-      -- See Note [Bad Names in reification]
-      return $ nameBase kv
-    extract_kv_name tvb =
-      fail $ "Unexpected parameter to promoted class: " ++ show tvb
+    extract_kv_name :: DTyVarBndr -> Name
+    extract_kv_name (DKindedTV _ (DConK _kproxy [DVarK kv_name])) = kv_name
+    extract_kv_name tvb = error $ "Internal error: extract_kv_name\n" ++ show tvb
 
--- Note [Bad Names in reification]
--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--- For reasons I (RAE) don't understand, reifying a class and reifying an
--- associated type family sometimes produce *different* Names for the
--- associated type/kind variables. This wreaks havoc with the type subst
--- algorithm in promoteMethod. The solution? Ickily compare nameBases
--- instead of proper Names. See also GHC#9081.
+-- promoteMethod needs to substitute in a method's kind because GHC does not do
+-- enough kind checking of associated types. See GHC#9063. When that bug is fixed,
+-- the substitution code can be removed.
+-- Bug is fixed, but only in HEAD, naturally. When we stop supporting 7.8,
+-- this can be rewritten more cleanly, I imagine.
+-- UPDATE: GHC 7.10.2 didn't fully solve GHC#9063. Urgh.
 
--- See Note [Bad Names in reification]
-promoteMethod :: Map String DKind   -- instantiations for class tyvars
+promoteMethod :: Map Name DKind     -- instantiations for class tyvars
               -> Map Name DType     -- method types
-              -> (Name, ULetDecRHS) -> PrM [DDec]
+              -> (Name, ULetDecRHS)
+              -> PrM (DDec, ALetDecRHS, DType)
+                 -- returns (type instance, ALetDecRHS, promoted RHS)
 promoteMethod subst sigs_map (meth_name, meth_rhs) = do
-  (payload, _defuns, _ann_rhs)
+  ((_, _, _, eqns), _defuns, ann_rhs)
     <- promoteLetDecRHS sigs_map noPrefix meth_name meth_rhs
-  let eqns = payload_to_eqns payload
   (arg_kis, res_ki) <- lookup_meth_ty
-  let meth_arg_kis' = map subst_ki arg_kis
-      meth_res_ki'  = subst_ki res_ki
-      eqns'         = map (apply_kis meth_arg_kis' meth_res_ki') eqns
-  return $ map (DTySynInstD proName) eqns'
+  meth_arg_tvs <- mapM (const $ qNewName "a") arg_kis
+  let meth_arg_kis' = map (substKind subst) arg_kis
+      meth_res_ki'  = substKind subst res_ki
+      helperNameBase = case nameBase proName of
+                         first:_ | not (isHsLetter first) -> "TFHelper"
+                         alpha                            -> alpha
+  helperName <- newUniqueName helperNameBase
+  emitDecs [DClosedTypeFamilyD helperName
+                               (zipWith DKindedTV meth_arg_tvs meth_arg_kis')
+                               (Just meth_res_ki') eqns]
+  emitDecsM (defunctionalize helperName (map Just meth_arg_kis') (Just meth_res_ki'))
+  return ( DTySynInstD
+             proName
+             (DTySynEqn (zipWith (DSigT . DVarT) meth_arg_tvs meth_arg_kis')
+                        (foldApply (promoteValRhs helperName) (map DVarT meth_arg_tvs)))
+         , ann_rhs
+         , DConT (promoteTySym helperName 0) )
   where
     proName = promoteValNameLhs meth_name
 
-    payload_to_eqns (Left (_name, tvbs, rhs)) =
-      [DTySynEqn (map tvb_to_ty tvbs) rhs]
-    payload_to_eqns (Right (_name, _tvbs, _res_ki, eqns)) = eqns
-
-    tvb_to_ty (DPlainTV n)     = DVarT n
-    tvb_to_ty (DKindedTV n ki) = DVarT n `DSigT` ki
-
     lookup_meth_ty :: PrM ([DKind], DKind)
     lookup_meth_ty = case Map.lookup meth_name sigs_map of
       Nothing -> do
-          -- lookup the promoted name, just in case the term-level one
-          -- isn't defined
-        m_dinfo <- dsReify proName
-        case m_dinfo of
-          Just (DTyConI (DFamilyD _flav _name tvbs (Just res)) _insts) -> do
-            arg_kis <- mapM (expect_just . extractTvbKind) tvbs
-            return (arg_kis, res)
-          _ -> fail $ "Cannot find type of " ++ show proName
-      Just ty -> do
-        let (_, tys) = unravel ty
-        kis <- mapM promoteType tys
-        return $ snocView kis
-
-    expect_just :: Maybe a -> PrM a
-    expect_just (Just x) = return x
-    expect_just Nothing =
-      fail "Internal error: unknown kind of a promoted class method."
-
-    subst_ki :: DKind -> DKind
-    subst_ki (DForallK {}) =
-      error "Higher-rank kind encountered in instance method promotion."
-    subst_ki (DVarK n) =
-      -- See Note [Bad Names in reification]
-      case Map.lookup (nameBase n) subst of
-        Just ki -> ki
-        Nothing -> DVarK n
-    subst_ki (DConK con kis) = DConK con (map subst_ki kis)
-    subst_ki (DArrowK k1 k2) = DArrowK (subst_ki k1) (subst_ki k2)
-    subst_ki DStarK = DStarK
-
-    apply_kis :: [DKind] -> DKind -> DTySynEqn -> DTySynEqn
-    apply_kis arg_kis res_ki (DTySynEqn lhs rhs) =
-      DTySynEqn (zipWith apply_ki lhs arg_kis) (apply_ki rhs res_ki)
-
-    apply_ki :: DType -> DKind -> DType
-    apply_ki = DSigT
+        mb_info <- dsReify proName
+        case mb_info of
+          Just (DTyConI (DFamilyD _ _ tvbs mb_res_ki) _)
+            -> return ( map (default_to_star . extractTvbKind) tvbs
+                      , default_to_star mb_res_ki )
+          _ -> fail $ "Cannot find type annotation for " ++ show proName
+      Just ty -> promoteUnraveled ty
 
+    default_to_star Nothing  = DStarK
+    default_to_star (Just k) = k
 
 promoteLetDecEnv :: (String, String) -> ULetDecEnv -> PrM ([DDec], ALetDecEnv)
 promoteLetDecEnv prefixes (LetDecEnv { lde_defns = value_env
                                      , lde_types = type_env
                                      , lde_infix = infix_decls }) = do
-    -- deal with the infix_decls, to get them out of the way
   let infix_decls'  = catMaybes $ map (uncurry promoteInfixDecl) infix_decls
 
     -- promote all the declarations, producing annotated declarations
-      (names, rhss) = unzip $ Map.toList value_env
+  let (names, rhss) = unzip $ Map.toList value_env
   (payloads, defun_decss, ann_rhss)
     <- fmap unzip3 $ zipWithM (promoteLetDecRHS type_env prefixes) names rhss
 
   emitDecs $ concat defun_decss
-  let decs = map payload_to_dec payloads
+  let decs = map payload_to_dec payloads ++ infix_decls'
 
     -- build the ALetDecEnv
   let let_dec_env' = LetDecEnv { lde_defns = Map.fromList $ zip names ann_rhss
@@ -435,45 +384,40 @@
                                , lde_infix = infix_decls
                                , lde_proms = Map.empty }  -- filled in promoteLetDecs
 
-  return (infix_decls' ++ decs, let_dec_env')
+  return (decs, let_dec_env')
   where
-    payload_to_dec (Left  (name, tvbs, ty)) = DTySynD name tvbs ty
-    payload_to_dec (Right (name, tvbs, m_ki, eqns)) =
-      DClosedTypeFamilyD name tvbs m_ki eqns
+    payload_to_dec (name, tvbs, m_ki, eqns) = DClosedTypeFamilyD name tvbs m_ki eqns
 
 promoteInfixDecl :: Fixity -> Name -> Maybe DDec
 promoteInfixDecl fixity name
-  | isUpcase name = Nothing   -- no need to promote the decl
-  | otherwise     = Just $ DLetDec $ DInfixD fixity (promoteValNameLhs name)
-
+ | isUpcase name = Nothing   -- no need to promote the decl
+ | otherwise     = Just $ DLetDec $ DInfixD fixity (promoteValNameLhs name)
 
 -- This function is used both to promote class method defaults and normal
 -- let bindings. Thus, it can't quite do all the work locally and returns
--- an unwiedly intermediate structure. Perhaps a better design is available.
+-- an intermediate structure. Perhaps a better design is available.
 promoteLetDecRHS :: Map Name DType       -- local type env't
                  -> (String, String)     -- let-binding prefixes
                  -> Name                 -- name of the thing being promoted
                  -> ULetDecRHS           -- body of the thing
-                 -> PrM ( Either
-                            (Name, [DTyVarBndr], DType) -- "type synonym"
-                            (Name, [DTyVarBndr], Maybe DKind, [DTySynEqn])
-                                                        -- "type family"
+                 -> PrM ( (Name, [DTyVarBndr], Maybe DKind, [DTySynEqn]) -- "type family"
                         , [DDec]        -- defunctionalization
                         , ALetDecRHS )  -- annotated RHS
 promoteLetDecRHS type_env prefixes name (UValue exp) = do
-  (res_kind, mk_rhs, num_arrows)
+  (res_kind, num_arrows)
     <- case Map.lookup name type_env of
-         Nothing -> return (Nothing, id, 0)
+         Nothing -> return (Nothing, 0)
          Just ty -> do
            ki <- promoteType ty
-           return (Just ki, (`DSigT` ki), countArgs ty)
+           return (Just ki, countArgs ty)
   case num_arrows of
     0 -> do
       all_locals <- allLocals
       (exp', ann_exp) <- promoteExp exp
       let proName = promoteValNameLhsPrefix prefixes name
       defuns <- defunctionalize proName (map (const Nothing) all_locals) res_kind
-      return ( Left (proName, map DPlainTV all_locals, mk_rhs exp')
+      return ( ( proName, map DPlainTV all_locals, res_kind
+               , [DTySynEqn (map DVarT all_locals) exp'] )
              , defuns
              , AValue (foldType (DConT proName) (map DVarT all_locals))
                       num_arrows ann_exp )
@@ -487,21 +431,12 @@
 promoteLetDecRHS type_env prefixes name (UFunction clauses) = do
   numArgs <- count_args clauses
   (m_argKs, m_resK, ty_num_args) <- case Map.lookup name type_env of
-#if __GLASGOW_HASKELL__ < 707
-      -- we require a type signature here because GHC 7.6.3 doesn't support
-      -- kind inference for type families
-    Nothing -> fail ("No type signature for function \"" ++
-                     (nameBase name) ++ "\". Cannot promote in GHC 7.6.3.\n" ++
-                     "Either add a type signature or upgrade GHC.")
-#else
     Nothing -> return (replicate numArgs Nothing, Nothing, numArgs)
-#endif
     Just ty -> do
       -- promoteType turns arrows into TyFun. So, we unravel first to
       -- avoid this behavior. Note the use of ravelTyFun in resultK
       -- to make the return kind work out
-      kis <- mapM promoteType (snd $ unravel ty)
-      let (argKs, resultK) = snocView kis
+      (argKs, resultK) <- promoteUnraveled ty
       -- invariant: countArgs ty == length argKs
       return (map Just argKs, Just resultK, length argKs)
 
@@ -509,15 +444,14 @@
   all_locals <- allLocals
   defun_decs <- defunctionalize proName
                 (map (const Nothing) all_locals ++ m_argKs) m_resK
-  local_tvbs <- mapM inferKindTV all_locals
+  let local_tvbs = map DPlainTV all_locals
   tyvarNames <- mapM (const $ qNewName "a") m_argKs
   expClauses <- mapM (etaExpand (ty_num_args - numArgs)) clauses
   (eqns, ann_clauses) <- mapAndUnzipM promoteClause expClauses
   prom_fun <- lookupVarE name
-  args <- zipWithM inferMaybeKindTV tyvarNames m_argKs
-  let all_args = local_tvbs ++ args
-  resultK <- inferKind m_resK
-  return ( Right (proName, all_args, resultK, eqns)
+  let args     = zipWith inferMaybeKindTV tyvarNames m_argKs
+      all_args = local_tvbs ++ args
+  return ( (proName, all_args, m_resK, eqns)
          , defun_decs
          , AFunction prom_fun ty_num_args ann_clauses )
 
@@ -536,71 +470,75 @@
 promoteClause (DClause pats exp) = do
   -- promoting the patterns creates variable bindings. These are passed
   -- to the function promoted the RHS
-  (types, new_vars) <- evalForPair $ mapM promotePat pats
+  ((types, pats'), new_vars) <- evalForPair $ mapAndUnzipM promotePat pats
   (ty, ann_exp) <- lambdaBind new_vars $ promoteExp exp
   all_locals <- allLocals   -- these are bound *outside* of this clause
   return ( DTySynEqn (map DVarT all_locals ++ types) ty
-         , ADClause new_vars pats ann_exp )
+         , ADClause new_vars pats' ann_exp )
 
 promoteMatch :: DType -> DMatch -> PrM (DTySynEqn, ADMatch)
 promoteMatch prom_case (DMatch pat exp) = do
   -- promoting the patterns creates variable bindings. These are passed
   -- to the function promoted the RHS
-  (ty, new_vars) <- evalForPair $ promotePat pat
+  ((ty, pat'), new_vars) <- evalForPair $ promotePat pat
   (rhs, ann_exp) <- lambdaBind new_vars $ promoteExp exp
   all_locals <- allLocals
   return $ ( DTySynEqn (map DVarT all_locals ++ [ty]) rhs
-           , ADMatch new_vars prom_case pat ann_exp)
+           , ADMatch new_vars prom_case pat' ann_exp)
 
 -- promotes a term pattern into a type pattern, accumulating bound variable names
-promotePat :: DPat -> QWithAux VarPromotions PrM DType
-promotePat (DLitPa lit) = promoteLit lit
+-- See Note [No wildcards in singletons]
+promotePat :: DPat -> QWithAux VarPromotions PrM (DType, DPat)
+promotePat (DLitPa lit) = do
+  lit' <- promoteLitPat lit
+  return (lit', DLitPa lit)
 promotePat (DVarPa name) = do
       -- term vars can be symbols... type vars can't!
   tyName <- mkTyName name
   addElement (name, tyName)
-  return $ DVarT tyName
+  return (DVarT tyName, DVarPa name)
 promotePat (DConPa name pats) = do
-  types <- mapM promotePat pats
+  (types, pats') <- mapAndUnzipM promotePat pats
   let name' = unboxed_tuple_to_tuple name
-  return $ foldType (DConT name') types
+  return (foldType (DConT name') types, DConPa name pats')
   where
     unboxed_tuple_to_tuple n
       | Just deg <- unboxedTupleNameDegree_maybe n = tupleDataName deg
       | otherwise                                  = n
 promotePat (DTildePa pat) = do
   qReportWarning "Lazy pattern converted into regular pattern in promotion"
-  promotePat pat
+  (ty, pat') <- promotePat pat
+  return (ty, DTildePa pat')
 promotePat (DBangPa pat) = do
   qReportWarning "Strict pattern converted into regular pattern in promotion"
-  promotePat pat
+  (ty, pat') <- promotePat pat
+  return (ty, DBangPa pat')
 promotePat DWildPa = do
-  name <- qNewName "z"
-  return $ DVarT name
+  name <- newUniqueName "_z"
+  tyName <- mkTyName name
+  addElement (name, tyName)
+  return (DVarT tyName, DVarPa name)
 
 promoteExp :: DExp -> PrM (DType, ADExp)
 promoteExp (DVarE name) = fmap (, ADVarE name) $ lookupVarE name
 promoteExp (DConE name) = return $ (promoteValRhs name, ADConE name)
-promoteExp (DLitE lit)  = fmap (, ADLitE lit) $ promoteLit lit
+promoteExp (DLitE lit)  = fmap (, ADLitE lit) $ promoteLitExp lit
 promoteExp (DAppE exp1 exp2) = do
   (exp1', ann_exp1) <- promoteExp exp1
   (exp2', ann_exp2) <- promoteExp exp2
   return (apply exp1' exp2', ADAppE ann_exp1 ann_exp2)
 promoteExp (DLamE names exp) = do
   lambdaName <- newUniqueName "Lambda"
-  resultKVarName  <- qNewName "r"
   tyNames <- mapM mkTyName names
   let var_proms = zip names tyNames
   (rhs, ann_exp) <- lambdaBind var_proms $ promoteExp exp
   tyFamLamTypes <- mapM (const $ qNewName "t") names
   all_locals <- allLocals
   let all_args = all_locals ++ tyFamLamTypes
-  tvbs <- mapM inferKindTV all_args
-  let resultK       = DVarK resultKVarName
-      m_resultK     = unknownResult resultK
+      tvbs     = map DPlainTV all_args
   emitDecs [DClosedTypeFamilyD lambdaName
                                tvbs
-                               m_resultK
+                               Nothing
                                [DTySynEqn (map DVarT (all_locals ++ tyNames))
                                           rhs]]
   emitDecsM $ defunctionalize lambdaName (map (const Nothing) all_args) Nothing
@@ -615,11 +553,12 @@
   (eqns, ann_matches) <- mapAndUnzipM (promoteMatch prom_case) matches
   tyvarName  <- qNewName "t"
   let all_args = all_locals ++ [tyvarName]
-  tvbs  <- mapM inferKindTV all_args
-  resultK    <- fmap DVarK $ qNewName "r"
-  emitDecs [DClosedTypeFamilyD caseTFName tvbs (unknownResult resultK) eqns]
-  return ( prom_case `DAppT` exp'
-         , ADCaseE ann_exp ann_matches )
+      tvbs     = map DPlainTV all_args
+  emitDecs [DClosedTypeFamilyD caseTFName tvbs Nothing eqns]
+    -- See Note [Annotate case return type] in Single
+  let applied_case = prom_case `DAppT` exp'
+  return ( applied_case
+         , ADCaseE ann_exp exp' ann_matches applied_case )
 promoteExp (DLetE decs exp) = do
   unique <- qNewUnique
   let letPrefixes = uniquePrefixes "Let" ":<<<" unique
@@ -630,12 +569,23 @@
   (exp', ann_exp) <- promoteExp exp
   ty' <- promoteType ty
   return (DSigT exp' ty', ADSigE ann_exp ty)
-promoteExp (DStaticE _) = fail "Promoting static expressions not yet supported"
+promoteExp e@(DStaticE _) = fail ("Static expressions cannot be promoted: " ++ show e)
 
-promoteLit :: Monad m => Lit -> m DType
-promoteLit (IntegerL n)
-  | n >= 0    = return $ DLitT (NumTyLit n)
-  | otherwise = fail ("Promoting negative integers not supported: " ++ (show n))
-promoteLit (StringL str) = return $ DLitT (StrTyLit str)
-promoteLit lit =
+promoteLitExp :: Monad m => Lit -> m DType
+promoteLitExp (IntegerL n)
+  | n >= 0    = return $ (DConT tyFromIntegerName `DAppT` DLitT (NumTyLit n))
+  | otherwise = return $ (DConT tyNegateName `DAppT`
+                          (DConT tyFromIntegerName `DAppT` DLitT (NumTyLit (-n))))
+promoteLitExp (StringL str) = return $ DLitT (StrTyLit str)
+promoteLitExp lit =
+  fail ("Only string and natural number literals can be promoted: " ++ show lit)
+
+promoteLitPat :: Monad m => Lit -> m DType
+promoteLitPat (IntegerL n)
+  | n >= 0    = return $ (DLitT (NumTyLit n))
+  | otherwise =
+    fail $ "Negative literal patterns are not allowed,\n" ++
+           "because literal patterns are promoted to natural numbers."
+promoteLitPat (StringL str) = return $ DLitT (StrTyLit str)
+promoteLitPat lit =
   fail ("Only string and natural number literals can be promoted: " ++ show lit)
diff --git a/src/Data/Singletons/Promote/Bounded.hs b/src/Data/Singletons/Promote/Bounded.hs
deleted file mode 100644
--- a/src/Data/Singletons/Promote/Bounded.hs
+++ /dev/null
@@ -1,53 +0,0 @@
-{-# LANGUAGE TemplateHaskell #-}
-
------------------------------------------------------------------------------
--- |
--- Module      :  Data.Singletons.Promote.Bounded
--- Copyright   :  (C) 2014 Jan Stolarek
--- License     :  BSD-style (see LICENSE)
--- Maintainer  :  Jan Stolarek (jan.stolarek@p.lodz.pl)
--- Stability   :  experimental
--- Portability :  non-portable
---
--- Implements deriving of promoted Bounded instances
---
-----------------------------------------------------------------------------
-
-module Data.Singletons.Promote.Bounded where
-
-import Language.Haskell.TH.Desugar
-import Data.Singletons.Names
-import Data.Singletons.Util
-import Control.Monad
-
-mkBoundedTypeInstance :: DsMonad q => DKind -> [DCon] -> q [DDec]
-mkBoundedTypeInstance kind@(DConK name _) cons = do
-  -- We can derive instance of Bounded if datatype is an enumeration (all
-  -- constructors must be nullary) or has only one constructor. See Section 11
-  -- of Haskell 2010 Language Report.
-  -- Note that order of conditions below is important.
-  when (null cons
-       || (any (\(DCon _ _ _ f) -> not . null . tysOfConFields $ f) cons
-            && (not . null . tail $ cons))) $
-       fail ("Can't derive promoted Bounded instance for " ++ show name
-             ++ " datatype.")
-  -- at this point we know that either we have a datatype that has only one
-  -- constructor or a datatype where each constructor is nullary
-  let (DCon _ _ minName fields) = head cons
-      (DCon _ _ maxName _)      = last cons
-      pbounded_name = promoteClassName boundedName
-      fieldsCount   = length $ tysOfConFields fields
-      (minRHS, maxRHS) = case fieldsCount of
-        0 -> (DConT minName, DConT maxName)
-        _ ->
-          let minEqnRHS = foldType (DConT minName)
-                                   (replicate fieldsCount (DConT tyminBoundName))
-              maxEqnRHS = foldType (DConT maxName)
-                                   (replicate fieldsCount (DConT tymaxBoundName))
-          in (minEqnRHS, maxEqnRHS)
-  return $ [ DInstanceD [] (DConT pbounded_name `DAppT` kindParam kind)
-             [ DTySynInstD tyminBoundName (DTySynEqn [] minRHS)
-             , DTySynInstD tymaxBoundName (DTySynEqn [] maxRHS)
-             ]
-           ]
-mkBoundedTypeInstance _ _ = fail "Error deriving Bounded instance"
diff --git a/src/Data/Singletons/Promote/Defun.hs b/src/Data/Singletons/Promote/Defun.hs
--- a/src/Data/Singletons/Promote/Defun.hs
+++ b/src/Data/Singletons/Promote/Defun.hs
@@ -48,7 +48,7 @@
 
 buildDefunSymsDataD :: Name -> [DTyVarBndr] -> [DCon] -> PrM [DDec]
 buildDefunSymsDataD tyName tvbs ctors = do
-  let res_ty = foldType (DConT tyName) (map (DVarT . extractTvbName) tvbs)
+  let res_ty = foldType (DConT tyName) (map tvbToType tvbs)
   res_ki <- promoteType res_ty
   concatMapM (promoteCtor res_ki) ctors
   where
@@ -137,14 +137,13 @@
           tyfun_param = mk_tvb fst_name m_tyfun
           arg_names   = map extractTvbName arg_params
           params      = arg_params ++ [tyfun_param]
-          con_eq_ct   = foldl DAppPr (DConPr equalityName)
-                          [ DConT kindOfName `DAppT`
-                              (foldType (DConT data_name) (map DVarT arg_names)
-                               `apply`
-                               (DVarT extra_name))
-                          , DConT kindOfName `DAppT`
-                            foldType (DConT next_name) (map DVarT (arg_names ++ [extra_name]))
-                          ]
+          con_eq_ct   = mkEqPred
+                          (DConT kindOfName `DAppT`
+                            (foldType (DConT data_name) (map DVarT arg_names)
+                             `apply`
+                             (DVarT extra_name)))
+                          (DConT kindOfName `DAppT`
+                           foldType (DConT next_name) (map DVarT (arg_names ++ [extra_name])))
           con_decl    = DCon [DPlainTV extra_name]
                              [con_eq_ct]
                              con_name
diff --git a/src/Data/Singletons/Promote/Eq.hs b/src/Data/Singletons/Promote/Eq.hs
--- a/src/Data/Singletons/Promote/Eq.hs
+++ b/src/Data/Singletons/Promote/Eq.hs
@@ -7,8 +7,6 @@
 family instances.
 -}
 
-{-# LANGUAGE CPP #-}
-
 module Data.Singletons.Promote.Eq where
 
 import Language.Haskell.TH.Syntax
@@ -17,19 +15,9 @@
 import Data.Singletons.Util
 import Control.Monad
 
--- Why do we have two different versions of this code? Because GHC 7.6, which
--- doesn't allow any overlap among type family equations, needs O(n^2) instances.
--- Yuck. But, GHC 7.8 can get away with only O(n) equations in a closed type
--- family. The difference is significant enough to make it worth maintaining two
--- different generation functions, in RAE's opinion.
---
--- If we wish to change this, delete the 7.8 code -- the 7.6 code should work
--- just fine under 7.8.
-
-#if __GLASGOW_HASKELL__ >= 707
 -- produce a closed type family helper and the instance
 -- for (:==) over the given list of ctors
-mkEqTypeInstance :: DsMonad q => DKind -> [DCon] -> q [DDec]
+mkEqTypeInstance :: Quasi q => DKind -> [DCon] -> q [DDec]
 mkEqTypeInstance kind cons = do
   helperName <- newUniqueName "Equals"
   aName <- qNewName "a"
@@ -47,10 +35,10 @@
                                                        [DVarT aName, DVarT bName]))
       inst = DInstanceD [] ((DConT $ promoteClassName eqName) `DAppT`
                             kindParam kind) [eqInst]
-                                     
+
   return [closedFam, inst]
 
-  where mk_branch :: DsMonad q => DCon -> q DTySynEqn
+  where mk_branch :: Quasi q => DCon -> q DTySynEqn
         mk_branch con = do
           let (name, numArgs) = extractNameArgs con
           lnames <- replicateM numArgs (qNewName "a")
@@ -63,7 +51,7 @@
               result = tyAll results
           return $ DTySynEqn [ltype, rtype] result
 
-        false_case :: DsMonad q => q DTySynEqn
+        false_case :: Quasi q => q DTySynEqn
         false_case = do
           lvar <- qNewName "a"
           rvar <- qNewName "b"
@@ -75,36 +63,3 @@
         tyAll [one] = one
         tyAll (h:t) = foldType (DConT $ promoteValNameLhs andName) [h, (tyAll t)]
            -- I could use the Apply nonsense here, but there's no reason to
-
-#else
-
--- produce the type instance for (:==) for the given pair of constructors
-mkEqTypeInstance :: DsMonad q => (DCon, DCon) -> q DDec
-mkEqTypeInstance (c1, c2) =
-  if c1 == c2
-  then do
-    let (name, numArgs) = extractNameArgs c1
-    lnames <- replicateM numArgs (qNewName "a")
-    rnames <- replicateM numArgs (qNewName "b")
-    let lvars = map DVarT lnames
-        rvars = map DVarT rnames
-    return $ DTySynInstD tyEqName $ DTySynEqn
-      [foldType (DConT name) lvars,
-       foldType (DConT name) rvars]
-      (tyAll (zipWith (\l r -> foldType (DConT tyEqName) [l, r])
-                      lvars rvars))
-  else do
-    let (lname, lNumArgs) = extractNameArgs c1
-        (rname, rNumArgs) = extractNameArgs c2
-    lnames <- replicateM lNumArgs (qNewName "a")
-    rnames <- replicateM rNumArgs (qNewName "b")
-    return $ DTySynInstD tyEqName $ DTySynEqn
-      [foldType (DConT lname) (map DVarT lnames),
-       foldType (DConT rname) (map DVarT rnames)]
-      falseTySym
-  where tyAll :: [DType] -> DType -- "all" at the type level
-        tyAll [] = trueTySym
-        tyAll [one] = one
-        tyAll (h:t) = foldType (DConT $ promoteValNameLhs andName) [h, (tyAll t)]
-
-#endif
diff --git a/src/Data/Singletons/Promote/Monad.hs b/src/Data/Singletons/Promote/Monad.hs
--- a/src/Data/Singletons/Promote/Monad.hs
+++ b/src/Data/Singletons/Promote/Monad.hs
@@ -9,8 +9,8 @@
 of DDec, and is wrapped around a Q.
 -}
 
-{-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving, CPP,
-             FlexibleContexts, TypeFamilies, KindSignatures #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving,
+             FlexibleContexts, TypeFamilies, KindSignatures, CPP #-}
 
 module Data.Singletons.Promote.Monad (
   PrM, promoteM, promoteM_, promoteMDecs, VarPromotions,
@@ -24,14 +24,9 @@
 import Data.Map.Strict ( Map )
 import Language.Haskell.TH.Syntax hiding ( lift )
 import Language.Haskell.TH.Desugar
-import Data.Singletons.Util
 import Data.Singletons.Names
 import Data.Singletons.Syntax
 
-#if __GLASGOW_HASKELL__ < 709
-import Control.Applicative
-#endif
-
 type LetExpansions = Map Name DType  -- from **term-level** name
 
 -- environment during promotion
@@ -48,39 +43,9 @@
 
 -- the promotion monad
 newtype PrM a = PrM (ReaderT PrEnv (WriterT [DDec] Q) a)
-  deriving ( Functor, Applicative, Monad
+  deriving ( Functor, Applicative, Monad, Quasi
            , MonadReader PrEnv, MonadWriter [DDec] )
 
-liftPrM :: Q a -> PrM a
-liftPrM = PrM . lift . lift
-
-instance Quasi PrM where
-  qNewName          = liftPrM `comp1` qNewName
-  qReport           = liftPrM `comp2` qReport
-  qLookupName       = liftPrM `comp2` qLookupName
-  qReify            = liftPrM `comp1` qReify
-  qReifyInstances   = liftPrM `comp2` qReifyInstances
-  qLocation         = liftPrM qLocation
-  qRunIO            = liftPrM `comp1` qRunIO
-  qAddDependentFile = liftPrM `comp1` qAddDependentFile
-#if __GLASGOW_HASKELL__ >= 707
-  qReifyRoles       = liftPrM `comp1` qReifyRoles
-  qReifyAnnotations = liftPrM `comp1` qReifyAnnotations
-  qReifyModule      = liftPrM `comp1` qReifyModule
-  qAddTopDecls      = liftPrM `comp1` qAddTopDecls
-  qAddModFinalizer  = liftPrM `comp1` qAddModFinalizer
-  qGetQ             = liftPrM qGetQ
-  qPutQ             = liftPrM `comp1` qPutQ
-#endif
-
-  qRecover (PrM handler) (PrM body) = do
-    env <- ask
-    (result, aux) <- liftPrM $
-                     qRecover (runWriterT $ runReaderT handler env)
-                              (runWriterT $ runReaderT body env)
-    tell aux
-    return result
-
 instance DsMonad PrM where
   localDeclarations = asks pr_local_decls
 
@@ -144,4 +109,3 @@
 promoteMDecs locals thing = do
   (decs1, decs2) <- promoteM locals thing
   return $ decs1 ++ decs2
-
diff --git a/src/Data/Singletons/Promote/Ord.hs b/src/Data/Singletons/Promote/Ord.hs
deleted file mode 100644
--- a/src/Data/Singletons/Promote/Ord.hs
+++ /dev/null
@@ -1,240 +0,0 @@
-{-# LANGUAGE TemplateHaskell #-}
-
------------------------------------------------------------------------------
--- |
--- Module      :  Data.Singletons.Promote.Ord
--- Copyright   :  (C) 2014 Jan Stolarek
--- License     :  BSD-style (see LICENSE)
--- Maintainer  :  Jan Stolarek (jan.stolarek@p.lodz.pl)
--- Stability   :  experimental
--- Portability :  non-portable
---
--- Implements deriving of promoted Ord instances
---
-----------------------------------------------------------------------------
-
-module Data.Singletons.Promote.Ord where
-
-import Language.Haskell.TH.Syntax
-import Language.Haskell.TH.Desugar
-import Data.Singletons.Names
-import Data.Singletons.Util
-
-mkOrdTypeInstance :: DsMonad q => DKind -> [DCon] -> q [DDec]
-mkOrdTypeInstance kind cons = do
-  let tagged_cons = zip cons [1..]
-      con_pairs   = [ (c1, c2) | c1 <- tagged_cons, c2 <- tagged_cons ]
-  eqns <- mapM mkOrdTySynEqn con_pairs
-  let tyfam_insts = map (DTySynInstD tyCompareName) eqns
-      pord_name   = promoteClassName ordName
-      pord_inst   = DInstanceD [] (DConT pord_name `DAppT` kindParam kind)
-                               tyfam_insts
-  return [pord_inst]
-
-mkOrdTySynEqn :: DsMonad q => ((DCon, Int), (DCon, Int)) -> q DTySynEqn
-mkOrdTySynEqn ((c1, n1), (c2, n2)) = do
-  let DCon _tvbs1 _cxt1 con_name1 con_fields1 = c1
-      DCon _tvbs2 _cxt2 con_name2 con_fields2 = c2
-  lhs_names <- mapM (const $ qNewName "lhs") (tysOfConFields con_fields1)
-  rhs_names <- mapM (const $ qNewName "rhs") (tysOfConFields con_fields2)
-  let lhs_ty = foldType (DConT con_name1) (map DVarT lhs_names)
-      rhs_ty = foldType (DConT con_name2) (map DVarT rhs_names)
-      result = case n1 `compare` n2 of
-        EQ -> let cmps   = zipWith (\lhs rhs ->
-                                     foldType (DConT tyCompareName) [ DVarT lhs
-                                                                    , DVarT rhs ])
-                           lhs_names rhs_names
-              in
-              foldl (\l r -> foldType (DConT tyThenCmpName) [l, r])
-                    (DConT 'EQ) cmps
-
-        LT -> DConT 'LT
-        GT -> DConT 'GT
-  return $ DTySynEqn [lhs_ty, rhs_ty] result
-
-{-
--- Note [Deriving Ord]
--- ~~~~~~~~~~~~~~~~~~~
---
--- We derive instances of Ord by generating promoted instance of Compare.  Under
--- GHC 7.8 this is done by generating a closed type family that does tha
--- comparing for given datatype and then making appropriate instance of Compare
--- open type family. There are two interesting points in this
--- algorithm. Firstly we minimize the number of equations required to compare
--- all existing data constructors. To do this we use a catch-all equations. For
--- example for this data type:
---
---  data Foo = A | B | C | D | E | F deriving (Eq,Ord)
---
--- We generate equations:
---
---  CompareFoo A A = EQ
---  CompareFoo A a = LT -- catch-all case
---  CompareFoo B A = GT
---  CompareFoo B B = EQ
---  CompareFoo B a = LT -- catch-all case
---
--- This however would be very inefficient for the last constructor:
---
---  CompareFoo F A = GT
---  CompareFoo F B = GT
---  CompareFoo F C = GT
---  CompareFoo F D = GT
---  CompareFoo F E = GT
---  CompareFoo F F = EQ
---
--- So once we get past half of the constructors we reverse the order in which we
--- test second constructor passed to Compare:
---
---  CompareFoo F F = EQ
---  CompareFoo F a = GT
---  CompareFoo E F = LT
---  CompareFoo E E = EQ
---  CompareFoo E a = GT
---
--- Second interesting point in our algorithm is comparing identical
--- constructors. Obviously if they store no data they are equal. But if
--- constructor has any fields then they must be compared by calling Compare on
--- every field until we get LT or GT result. To do this we generate a helper
--- type function that does all the comparing. For example (,,) constructor has
--- three fields and we generate this code:
---
--- type family OrderingEqualCase (t1 :: Ordering)
---                               (t2 :: Ordering)
---                               (t3 :: Ordering) :: Ordering where
---   OrderingEqualCase LTSym0 a      b      = LTSym0
---   OrderingEqualCase GTSym0 a      b      = GTSym0
---   OrderingEqualCase EQSym0 LTSym0 b      = LTSym0
---   OrderingEqualCase EQSym0 GTSym0 b      = GTSym0
---   OrderingEqualCase EQSym0 EQSym0 LTSym0 = LTSym0
---   OrderingEqualCase EQSym0 EQSym0 GTSym0 = GTSym0
---   OrderingEqualCase EQSym0 EQSym0 EQSym0 = EQSym0
---
---  type family Compare_helper (a :: (k1,k2,k3)) (b :: (k1,k2,k3) :: Ordering where
---    Compare_helper (a1,a2,a3) (b1,b2,b3) =
---      OrderingEqualCase (Compare a1 b1) (Compare a2 b2) (Compare a3 b3)
---
----- Notice that we perform only necessary comparisons. If we can determine
----- ordering based on comparing first field we ignore the remaining fields
----- (although this implementation requires that we actually compare all fields
----- at the call site).
-
-mkOrdTypeInstance :: DsMonad q => DKind -> [DCon] -> q [DDec]
-mkOrdTypeInstance kind cons = do
-  let taggedCons   = zip cons [1..]
-      l            = length cons
-      half         = l `div` 2 + l `mod` 2
-      combinations = [ (x,y) | x@(_, t1) <- taggedCons
-                             , y@(_, t2) <- taggedCons
-                             , (t1 <= half && t2 <= t1 + 1) ||
-                               (t1 >  half && t2 >= t1 - 1) ]
-      groupedCombs = groupBy equalFirstTags combinations
-      equalFirstTags ((_,t1),_) ((_,t2),_) = t1 == t2
-      reverseOrder [] = []
-      reverseOrder xs@(((_,t),_):_) = if t > half
-                                      then reverse xs
-                                      else xs
-      consPairs    = concat (map reverseOrder groupedCombs)
-  helperName <- newUniqueName "Compare"
-  aName <- qNewName "a"
-  bName <- qNewName "b"
-  (compareEqns, eqDecs) <- evalForPair $ mapM (mkCompareEqn half) consPairs
-  let closedFam = DClosedTypeFamilyD helperName
-                                     [ DKindedTV aName kind
-                                     , DKindedTV bName kind ]
-                                     (Just (DConK orderingName []))
-                                     compareEqns
-      compareInst = DTySynInstD tyCompareName
-                               (DTySynEqn [ DSigT (DVarT aName) kind
-                                          , DSigT (DVarT bName) kind ]
-                                          (foldType (DConT helperName)
-                                                    [DVarT aName, DVarT bName]))
-  return (closedFam : compareInst : eqDecs)
-
-  where mkCompareEqn :: DsMonad q => Int -> ((DCon, Int), (DCon, Int))
-                                -> QWithAux [DDec] q DTySynEqn
-        mkCompareEqn half ((con1, tag1), (con2, tag2))
-            | tag1 > tag2 && tag1 <= half =
-                mkCompareEqnHelper con1 (Just con2) gtT
-            | tag1 < tag2 && tag1 >  half = do
-                mkCompareEqnHelper con1 (Just con2) ltT
-            | tag1 < tag2 && tag1 <= half =
-                mkCompareEqnHelper con1 Nothing ltT
-            | tag1 > tag2 && tag1 >  half =
-                mkCompareEqnHelper con1 Nothing gtT
-            | otherwise =
-                mkCompareEqual con1
-
-        eqT = DConT ordEQSymName
-        ltT = DConT ordLTSymName
-        gtT = DConT ordGTSymName
-
-        mkCompareEqnHelper :: DsMonad q => DCon -> Maybe DCon -> DType -> q DTySynEqn
-        mkCompareEqnHelper con1 con2 result = do
-            let (name1, numArgs1) = extractNameArgs con1
-            (name2, numArgs2) <- case con2 of
-                  Just c  -> let (n, numArgs) = extractNameArgs c
-                             in  return (DConT n, numArgs)
-                  Nothing -> qNewName "z" >>= (\n -> return (DVarT n, 0))
-            lnames <- replicateM numArgs1 (qNewName "a")
-            rnames <- replicateM numArgs2 (qNewName "b")
-            let lvars = map DVarT lnames
-                rvars = map DVarT rnames
-                ltype = foldType (DConT name1) lvars
-                rtype = foldType name2 rvars
-            return $ DTySynEqn [ltype, rtype] result
-
-        mkCompareEqual :: DsMonad q => DCon -> QWithAux [DDec] q DTySynEqn
-        mkCompareEqual con = do
-            let (name, numArgs) = extractNameArgs con
-            case numArgs of
-              -- If constructor has no fields it is equal to itself
-              0 -> return $ DTySynEqn [DConT name, DConT name] eqT
-              -- But if it has fields we have to compare them one by one
-              _ -> do
-                helperName <- newUniqueName "OrderingEqualCase"
-                -- Build helper type family that does the comparison
-                buildHelperTyFam numArgs helperName
-
-                -- Call the helper function
-                lnames <- replicateM numArgs (qNewName "a")
-                rnames <- replicateM numArgs (qNewName "b")
-                let lvars      = map DVarT lnames
-                    rvars      = map DVarT rnames
-                    ltype      = foldType (DConT name) lvars
-                    rtype      = foldType (DConT name) rvars
-                    callParams = zipWith (\l r -> foldType (DConT tyCompareName) [l,r])
-                                          lvars rvars
-                    call = foldType (DConT helperName) callParams
-                return $ DTySynEqn [ltype, rtype] call
-            where
-                  buildHelperTyFam :: DsMonad q => Int -> Name -> QWithAux [DDec] q ()
-                  buildHelperTyFam numArgs helperName = do
-                    let orderingKCon = DConK orderingName []
-                    (patterns, results) <- buildEqnPats numArgs ([[]], [eqT])
-                    tyFamParamNames <- replicateM numArgs (qNewName "a")
-                    let eqns = map (uncurry DTySynEqn) (zip patterns results)
-                        closedFam = DClosedTypeFamilyD helperName
-                                      (zipWith DKindedTV tyFamParamNames
-                                              (repeat orderingKCon))
-                                      (Just orderingKCon)
-                                      eqns
-                    addElement closedFam
-                    return ()
-
-                  buildEqnPats :: DsMonad q => Int -> ([[DType]], [DType])
-                                          -> q ([[DType]], [DType])
-                  buildEqnPats 0 acc = return acc
-                  buildEqnPats n acc = do
-                    let eqns    = fst acc
-                        results = snd acc
-                        eqnNo   = length (head eqns)
-                        newEqs  = map (eqT :) eqns
-                    names <- replicateM eqnNo (qNewName "a")
-                    let tys   = map DVarT names
-                        ltRow = ltT : tys
-                        gtRow = gtT : tys
-                    buildEqnPats (n-1) ( ltRow : gtRow : newEqs
-                                       , ltT : gtT : results )
-
--}
diff --git a/src/Data/Singletons/Promote/Type.hs b/src/Data/Singletons/Promote/Type.hs
--- a/src/Data/Singletons/Promote/Type.hs
+++ b/src/Data/Singletons/Promote/Type.hs
@@ -6,7 +6,7 @@
 This file implements promotion of types into kinds.
 -}
 
-module Data.Singletons.Promote.Type ( promoteType ) where
+module Data.Singletons.Promote.Type ( promoteType, promoteUnraveled ) where
 
 import Language.Haskell.TH.Desugar
 import Data.Singletons.Names
@@ -48,3 +48,11 @@
     go args     hd = fail $ "Illegal Haskell construct encountered:\n" ++
                             "headed by: " ++ show hd ++ "\n" ++
                             "applied to: " ++ show args
+
+promoteUnraveled :: Monad m => DType -> m ([DKind], DKind)
+promoteUnraveled ty = do
+  arg_kis <- mapM promoteType arg_tys
+  res_ki  <- promoteType res_ty
+  return (arg_kis, res_ki)
+  where
+    (_, _, arg_tys, res_ty) = unravel ty
diff --git a/src/Data/Singletons/Single.hs b/src/Data/Singletons/Single.hs
--- a/src/Data/Singletons/Single.hs
+++ b/src/Data/Singletons/Single.hs
@@ -6,30 +6,33 @@
 This file contains functions to refine constructs to work with singleton
 types. It is an internal module to the singletons package.
 -}
-{-# LANGUAGE TemplateHaskell, CPP, TupleSections, ParallelListComp #-}
+{-# LANGUAGE TemplateHaskell, TupleSections, ParallelListComp, CPP #-}
 
 module Data.Singletons.Single where
 
 import Prelude hiding ( exp )
 import Language.Haskell.TH hiding ( cxt )
-import Language.Haskell.TH.Syntax ( qNewName )
+import Language.Haskell.TH.Syntax (Quasi(..))
+import Data.Singletons.Deriving.Ord
+import Data.Singletons.Deriving.Bounded
+import Data.Singletons.Deriving.Enum
 import Data.Singletons.Util
 import Data.Singletons.Promote
-import Data.Singletons.Promote.Monad ( promoteM, promoteM_ )
+import Data.Singletons.Promote.Monad ( promoteM )
+import Data.Singletons.Promote.Type
 import Data.Singletons.Names
 import Data.Singletons.Single.Monad
 import Data.Singletons.Single.Type
 import Data.Singletons.Single.Data
 import Data.Singletons.Single.Eq
 import Data.Singletons.Syntax
+import Data.Singletons.Partition
 import Language.Haskell.TH.Desugar
 import qualified Data.Map.Strict as Map
 import Data.Map.Strict ( Map )
+import Data.Maybe
 import Control.Monad
-
-#if __GLASGOW_HASKELL__ < 709
-import Control.Applicative
-#endif
+import Data.List
 
 {-
 How singletons works
@@ -45,7 +48,7 @@
 use the "SLambda" instance of Sing. To apply singleton functions, we use the
 applySing function.
 
-That, in an of itself, wouldn't be too hard, but it's really annoying from
+That, in and of itself, wouldn't be too hard, but it's really annoying from
 the user standpoint. After dutifully singling `map`, a user doesn't want to
 have to use two `applySing`s to actually use it. So, any let-bound identifier
 is eta-expanded so that the singled type has the same number of arrows as
@@ -62,7 +65,7 @@
 because SLambda is a *newtype* instance, not a *data* instance.
 
 Note that to maintain the desired invariant, we must also be careful to eta-
-contract constructors. This is the point of buildLets.
+contract constructors. This is the point of buildDataLets.
 -}
 
 -- | Generate singleton definitions from a type that is already defined.
@@ -88,7 +91,9 @@
   return (decs ++ singDecs)
 
 -- | Make promoted and singleton versions of all declarations given, discarding
--- the original declarations.
+-- the original declarations. Note that a singleton based on a datatype needs
+-- the original datatype, so this will fail if it sees any datatype declarations.
+-- Classes, instances, and functions are all fine.
 singletonsOnly :: DsMonad q => q [Dec] -> q [Dec]
 singletonsOnly = (>>= wrapDesugar singTopLevelDecs)
 
@@ -114,18 +119,10 @@
 singEqInstanceOnly name = singEqualityInstance sEqClassDesc name
 
 -- | Create instances of 'SDecide' for each type in the list.
---
--- Note that, due to a bug in GHC 7.6.3 (and lower) optimizing instances
--- for SDecide can make GHC hang. You may want to put
--- @{-# OPTIONS_GHC -O0 #-}@ in your file.
 singDecideInstances :: DsMonad q => [Name] -> q [Dec]
 singDecideInstances = concatMapM singDecideInstance
 
 -- | Create instance of 'SDecide' for the given type.
---
--- Note that, due to a bug in GHC 7.6.3 (and lower) optimizing instances
--- for SDecide can make GHC hang. You may want to put
--- @{-# OPTIONS_GHC -O0 #-}@ in your file.
 singDecideInstance :: DsMonad q => Name -> q [Dec]
 singDecideInstance name = singEqualityInstance sDecideClassDesc name
 
@@ -144,11 +141,47 @@
   eqInstance <- mkEqualityInstance kind scons desc
   return $ decToTH eqInstance
 
+-- | Create instances of 'SOrd' for the given types
+singOrdInstances :: DsMonad q => [Name] -> q [Dec]
+singOrdInstances = concatMapM singOrdInstance
+
+-- | Create instance of 'SOrd' for the given type
+singOrdInstance :: DsMonad q => Name -> q [Dec]
+singOrdInstance = singInstance mkOrdInstance "Ord"
+
+-- | Create instances of 'SBounded' for the given types
+singBoundedInstances :: DsMonad q => [Name] -> q [Dec]
+singBoundedInstances = concatMapM singBoundedInstance
+
+-- | Create instance of 'SBounded' for the given type
+singBoundedInstance :: DsMonad q => Name -> q [Dec]
+singBoundedInstance = singInstance mkBoundedInstance "Bounded"
+
+-- | Create instances of 'SEnum' for the given types
+singEnumInstances :: DsMonad q => [Name] -> q [Dec]
+singEnumInstances = concatMapM singEnumInstance
+
+-- | Create instance of 'SEnum' for the given type
+singEnumInstance :: DsMonad q => Name -> q [Dec]
+singEnumInstance = singInstance mkEnumInstance "Enum"
+
+singInstance :: DsMonad q
+             => (DType -> [DCon] -> q UInstDecl)
+             -> String -> Name -> q [Dec]
+singInstance mk_inst inst_name name = do
+  (tvbs, cons) <- getDataD ("I cannot make an instance of " ++ inst_name
+                            ++ " for it.") name
+  dtvbs <- mapM dsTvb tvbs
+  dcons <- mapM dsCon cons
+  raw_inst <- mk_inst (foldType (DConT name) (map tvbToType dtvbs)) dcons
+  (a_inst, decs) <- promoteM [] $
+                    promoteInstanceDec Map.empty raw_inst
+  decs' <- singDecsM [] $ (:[]) <$> singInstD a_inst
+  return $ decsToTH (decs ++ decs')
+
 singInfo :: DsMonad q => DInfo -> q [DDec]
-singInfo (DTyConI dec Nothing) = do -- TODO: document this special case
+singInfo (DTyConI dec _) =
   singTopLevelDecs [] [dec]
-singInfo (DTyConI {}) =
-  fail "Singling of things with instances not yet supported" -- TODO: fix
 singInfo (DPrimTyConI _name _numArgs _unlifted) =
   fail "Singling of primitive type constructors not supported"
 singInfo (DVarI _name _ty _mdec _fixity) =
@@ -157,25 +190,31 @@
   fail "Singling of type variable info not supported"
 
 singTopLevelDecs :: DsMonad q => [Dec] -> [DDec] -> q [DDec]
-singTopLevelDecs locals decls = do
+singTopLevelDecs locals raw_decls = do
+  decls <- withLocalDeclarations locals $ expand raw_decls     -- expand type synonyms
   PDecs { pd_let_decs              = letDecls
         , pd_class_decs            = classes
         , pd_instance_decs         = insts
         , pd_data_decs             = datas }    <- partitionDecs decls
 
-  when (not (null classes) || not (null insts)) $
-    qReportError "Classes and instances may not yet be made into singletons."
+  ((letDecEnv, classes', insts'), promDecls) <- promoteM locals $ do
+    promoteDataDecs datas
+    (_, letDecEnv) <- promoteLetDecs noPrefix letDecls
+    classes' <- mapM promoteClassDec classes
+    let meth_sigs = foldMap (lde_types . cd_lde) classes
+    insts' <- mapM (promoteInstanceDec meth_sigs) insts
+    return (letDecEnv, classes', insts')
 
-  dataDecls' <- promoteM_ locals $ promoteDataDecs datas
-  ((_, letDecEnv), letDecls') <- promoteM locals $
-                                 promoteLetDecs noPrefix letDecls
   singDecsM locals $ do
     let letBinds = concatMap buildDataLets datas
                 ++ concatMap buildMethLets classes
-    (newLetDecls, newDataDecls) <- bindLets letBinds $
-                                   singLetDecEnv TopLevel letDecEnv $
-                                   concatMapM singDataD datas
-    return $ dataDecls' ++ letDecls' ++ (map DLetDec newLetDecls) ++ newDataDecls
+    (newLetDecls, newDecls) <- bindLets letBinds $
+                               singLetDecEnv letDecEnv $ do
+                                 newDataDecls <- concatMapM singDataD datas
+                                 newClassDecls <- mapM singClassD classes'
+                                 newInstDecls <- mapM singInstD insts'
+                                 return (newDataDecls ++ newClassDecls ++ newInstDecls)
+    return $ promDecls ++ (map DLetDec newLetDecls) ++ newDecls
 
 -- see comment at top of file
 buildDataLets :: DataDecl -> [(Name, DExp)]
@@ -195,81 +234,192 @@
       [ (name, wrapSingFun 1 (promoteValRhs name) (DVarE $ singValName name))
       | name <- names ]
 
-buildMethLets :: ClassDecl -> [(Name, DExp)]
-buildMethLets = error "Cannot singletonize class definitions yet."
-  -- FIXME!
+-- see comment at top of file
+buildMethLets :: UClassDecl -> [(Name, DExp)]
+buildMethLets (ClassDecl { cd_lde = LetDecEnv { lde_types = meth_sigs } }) =
+  map mk_bind (Map.toList meth_sigs)
+  where
+    mk_bind (meth_name, meth_ty) =
+      ( meth_name
+      , wrapSingFun (countArgs meth_ty) (promoteValRhs meth_name)
+                                        (DVarE $ singValName meth_name) )
 
-singLetDecEnv :: TopLevelFlag -> ALetDecEnv -> SgM a -> SgM ([DLetDec], a)
-singLetDecEnv top_level
-              (LetDecEnv { lde_defns = defns
+singClassD :: AClassDecl -> SgM DDec
+singClassD (ClassDecl { cd_cxt  = cls_cxt
+                      , cd_name = cls_name
+                      , cd_tvbs = cls_tvbs
+                      , cd_fds  = cls_fundeps
+                      , cd_lde  = LetDecEnv { lde_defns = default_defns
+                                            , lde_types = meth_sigs
+                                            , lde_infix = fixities
+                                            , lde_proms = promoted_defaults } }) = do
+  (sing_sigs, _, tyvar_names, res_kis)
+    <- unzip4 <$> zipWithM (singTySig no_meth_defns meth_sigs)
+                           meth_names (map promoteValRhs meth_names)
+  let default_sigs = catMaybes $ zipWith mk_default_sig meth_names sing_sigs
+      res_ki_map   = Map.fromList (zip meth_names
+                                       (map (fromMaybe always_sig) res_kis))
+  sing_meths <- mapM (uncurry (singLetDecRHS (Map.fromList tyvar_names)
+                                             res_ki_map))
+                     (Map.toList default_defns)
+  let fixities' = map (uncurry singInfixDecl) fixities
+  cls_cxt' <- mapM singPred cls_cxt
+  (kproxies, kproxy_pred) <- mkKProxies (map extractTvbName cls_tvbs)
+
+  return $ DClassD (cls_cxt' ++ kproxy_pred)
+                   (singClassName cls_name) kproxies
+                   cls_fundeps   -- they are fine without modification
+                   (map DLetDec (sing_sigs ++ sing_meths ++ fixities') ++ default_sigs)
+  where
+    no_meth_defns = error "Internal error: can't find declared method type"
+    always_sig    = error "Internal error: no signature for default method"
+    meth_names    = Map.keys meth_sigs
+
+    mk_default_sig meth_name (DSigD s_name sty) =
+      DDefaultSigD s_name <$> add_constraints meth_name sty
+    mk_default_sig _ _ = error "Internal error: a singled signature isn't a signature."
+
+    add_constraints meth_name sty = do  -- Maybe monad
+      prom_dflt <- Map.lookup meth_name promoted_defaults
+      let default_pred = foldl DAppPr (DConPr equalityName)
+                               [ foldApply (promoteValRhs meth_name) tvs
+                               , foldApply prom_dflt tvs ]
+      return $ DForallT tvbs (default_pred : cxt) (ravel args res)
+      where
+        (tvbs, cxt, args, res) = unravel sty
+        tvs                    = map tvbToType tvbs
+
+
+singInstD :: AInstDecl -> SgM DDec
+singInstD (InstDecl { id_cxt = cxt, id_name = inst_name
+                    , id_arg_tys = inst_tys, id_meths = ann_meths }) = do
+  cxt' <- mapM singPred cxt
+  inst_kis <- mapM promoteType inst_tys
+  meths <- concatMapM (uncurry sing_meth) ann_meths
+  return (DInstanceD cxt'
+                     (foldl DAppT (DConT s_inst_name) (map kindParam inst_kis))
+                     meths)
+
+  where
+    s_inst_name = singClassName inst_name
+
+    sing_meth :: Name -> ALetDecRHS -> SgM [DDec]
+    sing_meth name rhs = do
+      mb_s_info <- dsReify (singValName name)
+      (s_ty, tyvar_names, m_res_ki) <- case mb_s_info of
+        Just (DVarI _ (DForallT cls_kproxy_tvbs _cls_pred s_ty) _ _) -> do
+          let class_kvs = map extract_kv cls_kproxy_tvbs
+              extract_kv (DKindedTV _kproxyVar (DConK _kproxyTy [DVarK kv])) = kv
+              extract_kv _ = error "sing_meth cannot extract a kind variable"
+
+              (sing_tvbs, _pred, _args, res_ty) = unravel s_ty
+
+          inst_kis <- mapM promoteType inst_tys
+          let subst    = Map.fromList (zip class_kvs inst_kis)
+              m_res_ki = case res_ty of
+                _sing `DAppT` (_prom_func `DSigT` res_ki) -> Just (substKind subst res_ki)
+                _                                         -> Nothing
+
+          return (substKindInType subst s_ty, map extractTvbName sing_tvbs, m_res_ki)
+        _ -> do
+          mb_info <- dsReify name
+          case mb_info of
+            Just (DVarI _ (DForallT cls_tvbs _cls_pred inner_ty) _ _) -> do
+              let subst = Map.fromList (zip (map extractTvbName cls_tvbs)
+                                            inst_tys)
+              (s_ty, _num_args, tyvar_names, res_ki) <- singType (promoteValRhs name)
+                                                                 (substType subst inner_ty)
+              return (s_ty, tyvar_names, Just res_ki)
+            _ -> fail $ "Cannot find type of method " ++ show name
+
+      let kind_map = maybe Map.empty (Map.singleton name) m_res_ki
+      meth' <- singLetDecRHS (Map.singleton name tyvar_names)
+                             kind_map name rhs
+      return $ map DLetDec [DSigD (singValName name) s_ty, meth']
+
+singLetDecEnv :: ALetDecEnv -> SgM a -> SgM ([DLetDec], a)
+singLetDecEnv (LetDecEnv { lde_defns = defns
                          , lde_types = types
                          , lde_infix = infix_decls
                          , lde_proms = proms })
               thing_inside = do
-  (typeSigs, letBinds, tyvarNames)
-    <- mapAndUnzip3M (uncurry sing_ty_sig) (Map.toList proms)
-  let infix_decls' = map (uncurry sing_infix_decl) infix_decls
+  let prom_list = Map.toList proms
+  (typeSigs, letBinds, tyvarNames, res_kis)
+    <- unzip4 <$> mapM (uncurry (singTySig defns types)) prom_list
+  let infix_decls' = map (uncurry singInfixDecl) infix_decls
+      res_ki_map   = Map.fromList [ (name, res_ki) | ((name, _), Just res_ki)
+                                                       <- zip prom_list res_kis ]
   bindLets letBinds $ do
-    let_decs <- mapM (uncurry (sing_let_dec (Map.fromList tyvarNames))) (Map.toList defns)
+    let_decs <- mapM (uncurry (singLetDecRHS (Map.fromList tyvarNames) res_ki_map))
+                     (Map.toList defns)
     thing <- thing_inside
     return (infix_decls' ++ typeSigs ++ let_decs, thing)
-  where
-    sing_infix_decl :: Fixity -> Name -> DLetDec
-    sing_infix_decl fixity name
-      | isUpcase name =
-        -- is it a tycon name or a datacon name??
-        -- it *must* be a datacon name, because symbolic tycons
-        -- can't be promoted. This is terrible.
-        DInfixD fixity (singDataConName name)
-      | otherwise = DInfixD fixity (singValName name)
 
-    sing_ty_sig :: Name -> DType   -- the type is the promoted type, not the type sig!
-                -> SgM ( DLetDec               -- the new type signature
-                       , (Name, DExp)          -- the let-bind entry
-                       , (Name, [Name])        -- the scoped tyvar names in the tysig
-                       )
-    sing_ty_sig name prom_ty =
-      let sName = singValName name in
-      case Map.lookup name types of
-        Nothing -> do
-          num_args <- guess_num_args name
-          (sty, tyvar_names) <- mk_sing_ty num_args prom_ty
-          return ( DSigD sName sty
-                 , (name, wrapSingFun num_args prom_ty (DVarE sName))
-                 , (name, tyvar_names) )
-        Just ty -> do
-          (sty, num_args, tyvar_names) <- singType top_level prom_ty ty
-          return ( DSigD sName sty
-                 , (name, wrapSingFun num_args prom_ty (DVarE sName))
-                 , (name, tyvar_names) )
+singInfixDecl :: Fixity -> Name -> DLetDec
+singInfixDecl fixity name
+  | isUpcase name =
+    -- is it a tycon name or a datacon name??
+    -- it *must* be a datacon name, because symbolic tycons
+    -- can't be promoted. This is terrible.
+    DInfixD fixity (singDataConName name)
+  | otherwise = DInfixD fixity (singValName name)
 
-    guess_num_args :: Name -> SgM Int
-    guess_num_args name =
+singTySig :: Map Name ALetDecRHS  -- definitions
+          -> Map Name DType       -- type signatures
+          -> Name -> DType   -- the type is the promoted type, not the type sig!
+          -> SgM ( DLetDec               -- the new type signature
+                 , (Name, DExp)          -- the let-bind entry
+                 , (Name, [Name])        -- the scoped tyvar names in the tysig
+                 , Maybe DKind           -- the result kind in the tysig
+                 )
+singTySig defns types name prom_ty =
+  let sName = singValName name in
+  case Map.lookup name types of
+    Nothing -> do
+      num_args <- guess_num_args
+      (sty, tyvar_names) <- mk_sing_ty num_args
+      return ( DSigD sName sty
+             , (name, wrapSingFun num_args prom_ty (DVarE sName))
+             , (name, tyvar_names)
+             , Nothing )
+    Just ty -> do
+      (sty, num_args, tyvar_names, res_ki) <- singType prom_ty ty
+      return ( DSigD sName sty
+             , (name, wrapSingFun num_args prom_ty (DVarE sName))
+             , (name, tyvar_names)
+             , Just res_ki )
+  where
+    guess_num_args :: SgM Int
+    guess_num_args =
       case Map.lookup name defns of
         Nothing -> fail "Internal error: promotion known for something not let-bound."
         Just (AValue _ n _) -> return n
         Just (AFunction _ n _) -> return n
 
       -- create a Sing t1 -> Sing t2 -> ... type of a given arity and result type
-    mk_sing_ty :: Int -> DType -> SgM (DType, [Name])
-    mk_sing_ty n prom_ty = do
+    mk_sing_ty :: Int -> SgM (DType, [Name])
+    mk_sing_ty n = do
       arg_names <- replicateM n (qNewName "arg")
       return ( DForallT (map DPlainTV arg_names) []
-                        (ravel (map (\name -> singFamily `DAppT` DVarT name) arg_names
-                                ++ [singFamily `DAppT`
-                                    (foldl apply prom_ty (map DVarT arg_names))]))
+                        (ravel (map (\nm -> singFamily `DAppT` DVarT nm) arg_names)
+                               (singFamily `DAppT`
+                                    (foldl apply prom_ty (map DVarT arg_names))))
              , arg_names )
 
-    sing_let_dec :: Map Name [Name] -> Name -> ALetDecRHS -> SgM DLetDec
-    sing_let_dec _bound_names name (AValue prom num_arrows exp) =
-      DValD (DVarPa (singValName name)) <$>
-      (wrapUnSingFun num_arrows prom <$> singExp exp)
-    sing_let_dec bound_names name (AFunction prom_fun num_arrows clauses) =
-      let tyvar_names = case Map.lookup name bound_names of
-                          Nothing -> []
-                          Just ns -> ns
-      in
-      DFunD (singValName name) <$> mapM (singClause prom_fun num_arrows tyvar_names) clauses
+singLetDecRHS :: Map Name [Name]
+              -> Map Name DKind   -- result kind (might not be known)
+              -> Name -> ALetDecRHS -> SgM DLetDec
+singLetDecRHS _bound_names _res_kis name (AValue prom num_arrows exp) =
+  DValD (DVarPa (singValName name)) <$>
+  (wrapUnSingFun num_arrows prom <$> singExp exp)
+singLetDecRHS bound_names res_kis name (AFunction prom_fun num_arrows clauses) =
+  let tyvar_names = case Map.lookup name bound_names of
+                      Nothing -> []
+                      Just ns -> ns
+      res_ki = Map.lookup name res_kis
+  in
+  DFunD (singValName name) <$>
+        mapM (singClause prom_fun num_arrows tyvar_names res_ki) clauses
 
 singClause :: DType   -- the promoted function
            -> Int     -- the number of arrows in the type. If this is more
@@ -278,13 +428,19 @@
            -> [Name]  -- the names of the forall'd vars in the type sig of this
                       -- function. This list should have at least the length as the
                       -- number of patterns in the clause
+           -> Maybe DKind   -- result kind, if known
            -> ADClause -> SgM DClause
-singClause prom_fun num_arrows bound_names (ADClause var_proms pats exp) = do
-  ((sPats, prom_pats), wilds)
-    <- evalForPair $ mapAndUnzipM (singPat (Map.fromList var_proms) Parameter) pats
+singClause prom_fun num_arrows bound_names res_ki
+           (ADClause var_proms pats exp) = do
+  (sPats, prom_pats)
+    <- mapAndUnzipM (singPat (Map.fromList var_proms) Parameter) pats
   let equalities = zip (map DVarT bound_names) prom_pats
-      applied_ty = foldl apply prom_fun prom_pats
-  sBody <- bindTyVarsClause var_proms wilds applied_ty equalities $ singExp exp
+      -- This res_ki stuff is necessary when we need to propagate result-
+      -- based type-inference. It was inspired by toEnum. (If you remove
+      -- this, that should fail to compile.)
+      applied_ty = maybe id (\ki -> (`DSigT` ki)) res_ki $
+                   foldl apply prom_fun prom_pats
+  sBody <- bindTyVarsEq var_proms applied_ty equalities $ singExp exp
     -- when calling unSingFun, the prom_pats aren't in scope, so we use the
     -- bound_names instead
   let pattern_bound_names = zipWith const bound_names pats
@@ -307,15 +463,25 @@
   fail $ "Can't use a singleton pattern outside of a case-statement or\n" ++
          "do expression: GHC's brain will explode if you try. (Do try it!)"
 
+-- Note [No wildcards in singletons]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--
+-- We forbid patterns with wildcards during singletonization. Why? Because
+-- singletonizing a pattern also must produce a type expression equivalent
+-- to the pattern, for use in bindTyVars. Wildcards get in the way of this.
+-- Thus, we de-wild patterns during promotion, and put the de-wilded patterns
+-- in the ADExp AST.
+
 singPat :: Map Name Name   -- from term-level names to type-level names
-        -> PatternContext -> DPat -> QWithAux [Name]  -- these names must be forall-bound
-                                     SgM ( DPat
-                                         , DType ) -- the type form of the pat
+        -> PatternContext
+        -> DPat
+        -> SgM (DPat, DType) -- the type form of the pat
 singPat _var_proms _patCxt (DLitPa _lit) =
   fail "Singling of literal patterns not yet supported"
 singPat var_proms _patCxt (DVarPa name) = do
   tyname <- case Map.lookup name var_proms of
-              Nothing     -> qNewName (nameBase name)
+              Nothing     ->
+                fail "Internal error: unknown variable when singling pattern"
               Just tyname -> return tyname
   return (DVarPa (singValName name), DVarT tyname)
 singPat var_proms patCxt (DConPa name pats) = do
@@ -330,37 +496,99 @@
 singPat var_proms patCxt (DBangPa pat) = do
   (pat', ty) <- singPat var_proms patCxt pat
   return (DBangPa pat', ty)
-singPat _var_proms _patCxt DWildPa = do
-  wild <- qNewName "wild"
-  addElement wild
-  return (DWildPa, DVarT wild)
+singPat _var_proms _patCxt DWildPa =
+  -- See Note [No wildcards in singletons]
+  fail "Internal error: wildcard seen during singleton generation"
 
+-- Note [Annotate case return type]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--
+-- We're straining GHC's type inference here. One particular trouble area
+-- is determining the return type of a GADT pattern match. In general, GHC
+-- cannot infer return types of GADT pattern matches because the return type
+-- becomes "untouchable" in the case matches. See the OutsideIn paper. But,
+-- during singletonization, we *know* the return type. So, just add a type
+-- annotation. See #54.
+
+-- Note [Why error is so special]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- Some of the transformations that happen before this point produce impossible
+-- case matches. We must be careful when processing these so as not to make
+-- an error GHC will complain about. When binding the case-match variables, we
+-- normally include an equality constraint saying that the scrutinee is equal
+-- to the matched pattern. But, we can't do this in inaccessible matches, because
+-- equality is bogus, and GHC (rightly) complains. However, we then have another
+-- problem, because GHC doesn't have enough information when type-checking the
+-- RHS of the inaccessible match to deem it type-safe. The solution: treat error
+-- as super-special, so that GHC doesn't look too hard at singletonized error
+-- calls. Specifically, DON'T do the applySing stuff. Just use sError, which
+-- has a custom type (Sing x -> a) anyway.
+
 singExp :: ADExp -> SgM DExp
+  -- See Note [Why error is so special]
+singExp (ADVarE err `ADAppE` arg)
+  | err == errorName = DAppE (DVarE (singValName err)) <$> singExp arg
 singExp (ADVarE name)  = lookupVarE name
 singExp (ADConE name)  = lookupConE name
 singExp (ADLitE lit)   = singLit lit
 singExp (ADAppE e1 e2) = do
   e1' <- singExp e1
   e2' <- singExp e2
-  return $ (DVarE applySingName) `DAppE` e1' `DAppE` e2'
+  -- `applySing undefined x` kills type inference, because GHC can't figure
+  -- out the type of `undefined`. So we don't emit that code.
+  if isException e1'
+  then return e1'
+  else return $ (DVarE applySingName) `DAppE` e1' `DAppE` e2'
 singExp (ADLamE var_proms prom_lam names exp) = do
   let sNames = map singValName names
-  exp' <- bindTyVars var_proms [] (foldl apply prom_lam (map (DVarT . snd) var_proms)) $
+  exp' <- bindTyVars var_proms (foldl apply prom_lam (map (DVarT . snd) var_proms)) $
           singExp exp
   return $ wrapSingFun (length names) prom_lam $ DLamE sNames exp'
-singExp (ADCaseE exp matches) = DCaseE <$> singExp exp <*> mapM singMatch matches
+singExp (ADCaseE exp prom_exp matches ret_ty) =
+    -- See Note [Annotate case return type]
+  DSigE <$> (DCaseE <$> singExp exp <*> mapM (singMatch prom_exp) matches)
+        <*> pure (singFamily `DAppT` ret_ty)
 singExp (ADLetE env exp) =
-  uncurry DLetE <$> singLetDecEnv NotTopLevel env (singExp exp)
+  uncurry DLetE <$> singLetDecEnv env (singExp exp)
 singExp (ADSigE {}) =
   fail "Singling of explicit type annotations not yet supported."
 
-singMatch :: ADMatch -> SgM DMatch
-singMatch (ADMatch var_proms prom_match pat exp) = do
-  ((sPat, prom_pat), wilds)
-    <- evalForPair $ singPat (Map.fromList var_proms) CaseStatement pat
+isException :: DExp -> Bool
+isException (DVarE n)             = n == undefinedName
+isException (DConE {})            = False
+isException (DLitE {})            = False
+isException (DAppE (DVarE fun) _) | nameBase fun == "sError" = True
+isException (DAppE fun _)         = isException fun
+isException (DLamE _ _)           = False
+isException (DCaseE e _)          = isException e
+isException (DLetE _ e)           = isException e
+isException (DSigE e _)           = isException e
+isException (DStaticE e)          = isException e
+
+singMatch :: DType  -- ^ the promoted scrutinee
+          -> ADMatch -> SgM DMatch
+singMatch prom_scrut (ADMatch var_proms prom_match pat exp) = do
+  (sPat, prom_pat)
+    <- singPat (Map.fromList var_proms) CaseStatement pat
         -- why DAppT below? See comment near decl of ADMatch in LetDecEnv.
-  sExp <- bindTyVars var_proms wilds (prom_match `DAppT` prom_pat) $ singExp exp
+  let equality
+        | DVarPa _ <- pat
+        , (ADVarE err) `ADAppE` _ <- exp
+        , err == errorName   -- See Note [Why error is so special]
+        = [] -- no equality from impossible case.
+        | otherwise      = [(prom_pat, prom_scrut)]
+  sExp <- bindTyVarsEq var_proms (prom_match `DAppT` prom_pat) equality $
+          singExp exp
   return $ DMatch sPat sExp
 
 singLit :: Lit -> SgM DExp
-singLit lit = DSigE (DVarE singMethName) <$> (DAppT singFamily <$> (promoteLit lit))
+singLit (IntegerL n)
+  | n >= 0    = return $
+                DVarE sFromIntegerName `DAppE`
+                (DVarE singMethName `DSigE`
+                 (singFamily `DAppT` DLitT (NumTyLit n)))
+  | otherwise = do sLit <- singLit (IntegerL (-n))
+                   return $ DVarE sNegateName `DAppE` sLit
+singLit lit = do
+  prom_lit <- promoteLitExp lit
+  return $ DVarE singMethName `DSigE` (singFamily `DAppT` prom_lit)
diff --git a/src/Data/Singletons/Single/Data.hs b/src/Data/Singletons/Single/Data.hs
--- a/src/Data/Singletons/Single/Data.hs
+++ b/src/Data/Singletons/Single/Data.hs
@@ -50,11 +50,11 @@
               then mapM (mkEqualityInstance k ctors') [sEqClassDesc, sDecideClassDesc]
               else return []
 
-  -- e.g. type SNat (a :: Nat) = Sing a
+  -- e.g. type SNat = Sing :: Nat -> *
   let kindedSynInst =
         DTySynD (singTyConName name)
-                [DKindedTV aName k]
-                (DAppT singFamily a)
+                []
+                (singFamily `DSigT` (k `DArrowK` DStarK))
 
   return $ (DDataInstD Data [] singFamilyName [DSigT a k] ctors' []) :
            kindedSynInst :
@@ -125,7 +125,7 @@
       kindedIndices = zipWith DSigT indices kinds
 
   -- SingI instance
-  emitDecs 
+  emitDecs
     [DInstanceD (map (DAppPr (DConPr singIName)) indices)
                 (DAppT (DConT singIName)
                        (foldType pCon kindedIndices))
@@ -139,10 +139,10 @@
                             | (field_name, _, _) <- rec_fields
                             | arg <- args ]
   return $ DCon tvbs
-                [foldl DAppPr (DConPr equalityName) [a, foldType pCon indices]]
+                [mkEqPred a (foldType pCon indices)]
                 sName
                 conFields
   where buildArgType :: DType -> DType -> SgM DType
         buildArgType ty index = do
-          (ty', _, _) <- singType NotTopLevel index ty
+          (ty', _, _, _) <- singType index ty
           return ty'
diff --git a/src/Data/Singletons/Single/Eq.hs b/src/Data/Singletons/Single/Eq.hs
--- a/src/Data/Singletons/Single/Eq.hs
+++ b/src/Data/Singletons/Single/Eq.hs
@@ -17,12 +17,12 @@
 -- making the SEq instance and the SDecide instance are rather similar,
 -- so we generalize
 type EqualityClassDesc q = ((DCon, DCon) -> q DClause, Name, Name)
-sEqClassDesc, sDecideClassDesc :: DsMonad q => EqualityClassDesc q
+sEqClassDesc, sDecideClassDesc :: Quasi q => EqualityClassDesc q
 sEqClassDesc = (mkEqMethClause, sEqClassName, sEqMethName)
 sDecideClassDesc = (mkDecideMethClause, sDecideClassName, sDecideMethName)
 
 -- pass the *singleton* constructors, not the originals
-mkEqualityInstance :: DsMonad q => DKind -> [DCon]
+mkEqualityInstance :: Quasi q => DKind -> [DCon]
                    -> EqualityClassDesc q -> q DDec
 mkEqualityInstance k ctors (mkMeth, className, methName) = do
   let ctorPairs = [ (c1, c2) | c1 <- ctors, c2 <- ctors ]
@@ -42,12 +42,12 @@
         getKindVars other             =
           error ("getKindVars sees an unusual kind: " ++ show other)
 
-        mkEmptyMethClauses :: DsMonad q => q [DClause]
+        mkEmptyMethClauses :: Quasi q => q [DClause]
         mkEmptyMethClauses = do
           a <- qNewName "a"
           return [DClause [DVarPa a, DWildPa] (DCaseE (DVarE a) emptyMatches)]
 
-mkEqMethClause :: DsMonad q => (DCon, DCon) -> q DClause
+mkEqMethClause :: Quasi q => (DCon, DCon) -> q DClause
 mkEqMethClause (c1, c2)
   | lname == rname = do
     lnames <- replicateM lNumArgs (qNewName "a")
@@ -73,7 +73,7 @@
         (lname, lNumArgs) = extractNameArgs c1
         (rname, rNumArgs) = extractNameArgs c2
 
-mkDecideMethClause :: DsMonad q => (DCon, DCon) -> q DClause
+mkDecideMethClause :: Quasi q => (DCon, DCon) -> q DClause
 mkDecideMethClause (c1, c2)
   | lname == rname =
     if lNumArgs == 0
diff --git a/src/Data/Singletons/Single/Monad.hs b/src/Data/Singletons/Single/Monad.hs
--- a/src/Data/Singletons/Single/Monad.hs
+++ b/src/Data/Singletons/Single/Monad.hs
@@ -12,7 +12,7 @@
              TemplateHaskell, CPP #-}
 
 module Data.Singletons.Single.Monad (
-  SgM, bindLets, bindTyVars, bindTyVarsClause, lookupVarE, lookupConE,
+  SgM, bindLets, bindTyVars, bindTyVarsEq, lookupVarE, lookupConE,
   wrapSingFun, wrapUnSingFun,
   singM, singDecsM,
   emitDecs, emitDecsM
@@ -29,10 +29,7 @@
 import Language.Haskell.TH.Desugar
 import Control.Monad.Reader
 import Control.Monad.Writer
-
-#if __GLASGOW_HASKELL__ < 709
 import Control.Applicative
-#endif
 
 -- environment during singling
 data SgEnv =
@@ -86,7 +83,7 @@
   local (\env@(SgEnv { sg_let_binds = lets2 }) ->
                env { sg_let_binds = (Map.fromList lets1) `Map.union` lets2 })
 
--- bindTyVarsClause
+-- bindTyVarsEq
 -- ~~~~~~~~~~~~~~~~
 --
 -- This function does some dirty business.
@@ -131,25 +128,26 @@
 -- available from within the "lambda".
 --
 -- This means, though, that using constraints with case statements and lambdas
--- will likely not work. Ugh.
+-- will likely not work. Ugh. UPDATE: This actually bit in practice! The
+-- Enum class wants to define `succ = toEnum . (+1) . fromEnum`. But that
+-- (+1) is a right-section, which desugars to a lambda. The Num constraint
+-- couldn't get through. Changing (+1) to (1+) fixed the problem, as
+-- left-sections don't need a lambda.
 
-bindTyVarsClause :: VarPromotions   -- the bindings we wish to effect
-                 -> [Name]          -- free variables in...
-                 -> DType           -- ...this type of the thing_inside
-                 -> [(DType, DType)]  -- and asserting these equalities
-                 -> SgM DExp -> SgM DExp
-bindTyVarsClause var_proms fv_names prom_fun equalities thing_inside = do
+bindTyVarsEq :: VarPromotions   -- the bindings we wish to effect
+             -> DType           -- the type of the thing_inside
+             -> [(DType, DType)]  -- and asserting these equalities
+             -> SgM DExp -> SgM DExp
+bindTyVarsEq var_proms prom_fun equalities thing_inside = do
   lambda <- qNewName "lambda"
   let (term_names, tyvar_names) = unzip var_proms
-      eq_ct  = [ DConPr equalityName `DAppPr` t1 `DAppPr` t2
+      eq_ct  = [ mkEqPred t1 t2
                | (t1, t2) <- equalities ]
       ty_sig = DSigD lambda $
-               DForallT (map DPlainTV tyvar_names)
-                        []
-                        (DForallT (map DPlainTV fv_names) eq_ct $
-                                   ravel (map (\tv_name -> singFamily `DAppT` DVarT tv_name)
-                                    tyvar_names
-                                ++ [singFamily `DAppT` prom_fun]))
+               DForallT (map DPlainTV tyvar_names) eq_ct $
+                        ravel (map (\tv_name -> singFamily `DAppT` DVarT tv_name)
+                                    tyvar_names)
+                              (singFamily `DAppT` prom_fun)
   arg_names <- mapM (qNewName . nameBase) term_names
   body <- bindLets [ (term_name, DVarE arg_name)
                    | term_name <- term_names
@@ -158,12 +156,8 @@
       let_body = foldExp (DVarE lambda) (map (DVarE . singValName) term_names)
   return $ DLetE [ty_sig, fundef] let_body
 
-bindTyVars :: VarPromotions
-           -> [Name]
-           -> DType
-           -> SgM DExp -> SgM DExp
-bindTyVars var_proms fv_names prom_fun =
-  bindTyVarsClause var_proms fv_names prom_fun []
+bindTyVars :: VarPromotions -> DType -> SgM DExp -> SgM DExp
+bindTyVars var_proms prom_fun = bindTyVarsEq var_proms prom_fun []
 
 lookupVarE :: Name -> SgM DExp
 lookupVarE = lookup_var_con singValName (DVarE . singValName)
@@ -178,7 +172,8 @@
   case Map.lookup name letExpansions of
     Nothing -> do
       -- try to get it from the global context
-      m_dinfo <- dsReify sName
+      m_dinfo <- liftM2 (<|>) (dsReify sName) (dsReify name)
+        -- try the unrefined name too -- it's needed to bootstrap Enum
       case m_dinfo of
         Just (DVarI _ ty _ _) ->
           let num_args = countArgs ty in
diff --git a/src/Data/Singletons/Single/Type.hs b/src/Data/Singletons/Single/Type.hs
--- a/src/Data/Singletons/Single/Type.hs
+++ b/src/Data/Singletons/Single/Type.hs
@@ -16,37 +16,25 @@
 import Data.Singletons.Util
 import Control.Monad
 
-data TopLevelFlag = TopLevel | NotTopLevel
-
-singType :: TopLevelFlag
-         -> DType          -- the promoted version of the thing classified by...
+singType :: DType          -- the promoted version of the thing classified by...
          -> DType          -- ... this type
          -> SgM ( DType    -- the singletonized type
                 , Int      -- the number of arguments
-                , [Name] ) -- the names of the tyvars used in the sing'd type
-singType top_level prom ty = do
-  let (cxt, tys) = unravel ty
-      args       = init tys
-      num_args   = length args
+                , [Name]   -- the names of the tyvars used in the sing'd type
+                , DKind )  -- the kind of the result type
+singType prom ty = do
+  let (_, cxt, args, res) = unravel ty
+      num_args            = length args
   cxt' <- mapM singPred cxt
   arg_names <- replicateM num_args (qNewName "t")
+  prom_args <- mapM promoteType args
+  prom_res  <- promoteType res
   let args' = map (\n -> singFamily `DAppT` (DVarT n)) arg_names
-      res'  = singFamily `DAppT` (foldl apply prom (map DVarT arg_names))
-      tau   = ravel (args' ++ [res'])
-  ty' <- case top_level of
-           TopLevel -> do
-             prom_args <- mapM promoteType args
-             return $ DForallT (zipWith DKindedTV arg_names prom_args)
-                               cxt' tau
-                -- don't annotate kinds. Why? Because the original source
-                -- may have used scoped type variables, and we're just
-                -- not clever enough to get the scoped kind variables right.
-                -- (the business in bindTyVars gets in the way)
-                -- If ScopedTypeVariables was actually sane in patterns,
-                -- this restriction might be able to be lifted.
-           NotTopLevel -> return $ DForallT (map DPlainTV arg_names)
-                                            cxt' tau
-  return (ty', num_args, arg_names)
+      res'  = singFamily `DAppT` (foldl apply prom (map DVarT arg_names) `DSigT` prom_res)
+      tau   = ravel args' res'
+  let ty' = DForallT (zipWith DKindedTV arg_names prom_args)
+                     cxt' tau
+  return (ty', num_args, arg_names, prom_res)
 
 singPred :: DPred -> SgM DPred
 singPred = singPredRec []
diff --git a/src/Data/Singletons/Syntax.hs b/src/Data/Singletons/Syntax.hs
--- a/src/Data/Singletons/Syntax.hs
+++ b/src/Data/Singletons/Syntax.hs
@@ -14,79 +14,32 @@
 
 import Prelude hiding ( exp )
 import Data.Monoid
-import Data.Singletons.Util
 import Language.Haskell.TH.Syntax
 import Language.Haskell.TH.Desugar
-import Language.Haskell.TH.Ppr
 import Data.Map.Strict ( Map )
 import qualified Data.Map.Strict as Map
-import Data.Maybe
-import Control.Monad
 
 type VarPromotions = [(Name, Name)]  -- from term-level name to type-level name
 
   -- the relevant part of declarations
-data DataDecl  = DataDecl NewOrData Name [DTyVarBndr] [DCon] [Name]
-data ClassDecl = ClassDecl DCxt Name [DTyVarBndr] ULetDecEnv
-data InstDecl  = InstDecl Name [DType] [(Name, ULetDecRHS)]
-
-data PartitionedDecs =
-  PDecs { pd_let_decs :: [DLetDec]
-        , pd_class_decs :: [ClassDecl]
-        , pd_instance_decs :: [InstDecl]
-        , pd_data_decs :: [DataDecl]
-        }
-
-instance Monoid PartitionedDecs where
-  mempty = PDecs [] [] [] []
-  mappend (PDecs a1 b1 c1 d1) (PDecs a2 b2 c2 d2) =
-    PDecs (a1 <> a2) (b1 <> b2) (c1 <> c2) (d1 <> d2)
+data DataDecl      = DataDecl NewOrData Name [DTyVarBndr] [DCon] [Name]
 
--- monadic only because of failure
-partitionDecs :: Monad m => [DDec] -> m PartitionedDecs
-partitionDecs = concatMapM partitionDec
+data ClassDecl ann = ClassDecl { cd_cxt  :: DCxt
+                               , cd_name :: Name
+                               , cd_tvbs :: [DTyVarBndr]
+                               , cd_fds  :: [FunDep]
+                               , cd_lde  :: LetDecEnv ann }
 
-partitionDec :: Monad m => DDec -> m PartitionedDecs
-partitionDec (DLetDec letdec) = return $ mempty { pd_let_decs = [letdec] }
-partitionDec (DDataD nd _cxt name tvbs cons derivings) =
-  return $ mempty { pd_data_decs = [DataDecl nd name tvbs cons derivings] }
-partitionDec (DClassD cxt name tvbs _fds decs) = do
-  env <- concatMapM partitionClassDec decs
-  return $ mempty { pd_class_decs = [ClassDecl cxt name tvbs env] }
-partitionDec (DInstanceD _cxt ty decs) = do
-  defns <- liftM catMaybes $ mapM partitionInstanceDec decs
-  (name, tys) <- split_app_tys [] ty
-  return $ mempty { pd_instance_decs = [InstDecl name tys defns] }
-  where
-    split_app_tys acc (DAppT t1 t2) = split_app_tys (t2:acc) t1
-    split_app_tys acc (DConT name)  = return (name, acc)
-    split_app_tys acc (DSigT t _)   = split_app_tys acc t
-    split_app_tys _ _ = fail $ "Illegal instance head: " ++ show ty
-partitionDec (DRoleAnnotD {}) = return mempty  -- ignore these
-partitionDec (DPragmaD {}) = return mempty
-partitionDec dec =
-  fail $ "Declaration cannot be promoted: " ++ pprint (decToTH dec)
+data InstDecl  ann = InstDecl { id_cxt     :: DCxt
+                              , id_name    :: Name
+                              , id_arg_tys :: [DType]
+                              , id_meths   :: [(Name, LetDecRHS ann)] }
 
-partitionClassDec :: Monad m => DDec -> m ULetDecEnv
-partitionClassDec (DLetDec (DSigD name ty)) = return $ typeBinding name ty
-partitionClassDec (DLetDec (DValD (DVarPa name) exp)) =
-  return $ valueBinding name (UValue exp)
-partitionClassDec (DLetDec (DFunD name clauses)) =
-  return $ valueBinding name (UFunction clauses)
-partitionClassDec (DLetDec (DInfixD fixity name)) =
-  return $ infixDecl fixity name
-partitionClassDec (DPragmaD {}) = return mempty
-partitionClassDec _ =
-  fail "Only method declarations can be promoted within a class."
+type UClassDecl = ClassDecl Unannotated
+type UInstDecl  = InstDecl Unannotated
 
-partitionInstanceDec :: Monad m => DDec -> m (Maybe (Name, ULetDecRHS))
-partitionInstanceDec (DLetDec (DValD (DVarPa name) exp)) =
-  return $ Just (name, UValue exp)
-partitionInstanceDec (DLetDec (DFunD name clauses)) =
-  return $ Just (name, UFunction clauses)
-partitionInstanceDec (DPragmaD {}) = return Nothing
-partitionInstanceDec _ =
-  fail "Only method bodies can be promoted within an instance."
+type AClassDecl = ClassDecl Annotated
+type AInstDecl  = InstDecl Annotated
 
 {-
 We see below several datatypes beginning with "A". These are annotated structures,
@@ -104,7 +57,9 @@
            | ADLamE VarPromotions  -- bind these type variables to these term vars
                     DType          -- the promoted lambda
                     [Name] ADExp
-           | ADCaseE ADExp [ADMatch]
+           | ADCaseE ADExp DType [ADMatch] DType
+               -- the first type is the promoted scrutinee;
+               -- the second type is the return type
            | ADLetE ALetDecEnv ADExp
            | ADSigE ADExp DType
 
@@ -116,24 +71,30 @@
 
 data AnnotationFlag = Annotated | Unannotated
 
--- these will be promoted a lot!
-type Annotated = 'Annotated
+-- These are used at the type-level exclusively
+type Annotated   = 'Annotated
 type Unannotated = 'Unannotated
 
 type family IfAnn (ann :: AnnotationFlag) (yes :: k) (no :: k) :: k
 type instance IfAnn Annotated   yes no = yes
 type instance IfAnn Unannotated yes no = no
 
-data ALetDecRHS = AFunction DType  -- promote function (unapplied)
-                            Int    -- number of arrows in type
-                            [ADClause]
-                | AValue DType -- promoted exp
-                         Int   -- number of arrows in type
-                         ADExp
-data ULetDecRHS = UFunction [DClause]
-                | UValue DExp
+data family LetDecRHS (ann :: AnnotationFlag)
+data instance LetDecRHS Annotated
+  = AFunction DType  -- promote function (unapplied)
+    Int    -- number of arrows in type
+    [ADClause]
+  | AValue DType -- promoted exp
+    Int   -- number of arrows in type
+    ADExp
+data instance LetDecRHS Unannotated = UFunction [DClause]
+                                    | UValue DExp
+
+type ALetDecRHS = LetDecRHS Annotated
+type ULetDecRHS = LetDecRHS Unannotated
+
 data LetDecEnv ann = LetDecEnv
-                   { lde_defns :: Map Name (IfAnn ann ALetDecRHS ULetDecRHS)
+                   { lde_defns :: Map Name (LetDecRHS ann)
                    , lde_types :: Map Name DType   -- type signatures
                    , lde_infix :: [(Fixity, Name)] -- infix declarations
                    , lde_proms :: IfAnn ann (Map Name DType) () -- possibly, promotions
@@ -158,7 +119,7 @@
 emptyLetDecEnv :: ULetDecEnv
 emptyLetDecEnv = mempty
 
-buildLetDecEnv :: DsMonad q => [DLetDec] -> q ULetDecEnv
+buildLetDecEnv :: Quasi q => [DLetDec] -> q ULetDecEnv
 buildLetDecEnv = go emptyLetDecEnv
   where
     go acc [] = return acc
diff --git a/src/Data/Singletons/TH.hs b/src/Data/Singletons/TH.hs
--- a/src/Data/Singletons/TH.hs
+++ b/src/Data/Singletons/TH.hs
@@ -27,15 +27,21 @@
   singEqInstancesOnly, singEqInstanceOnly,
   singDecideInstances, singDecideInstance,
 
-  -- ** Functions to generate Ord instances
+  -- ** Functions to generate 'Ord' instances
   promoteOrdInstances, promoteOrdInstance,
+  singOrdInstances, singOrdInstance,
 
-  -- ** Functions to generate Ord instances
+  -- ** Functions to generate 'Bounded' instances
   promoteBoundedInstances, promoteBoundedInstance,
+  singBoundedInstances, singBoundedInstance,
 
-  -- ** Utility function
-  cases,
+  -- ** Functions to generate 'Enum' instances
+  promoteEnumInstances, promoteEnumInstance,
+  singEnumInstances, singEnumInstance,
 
+  -- ** Utility functions
+  cases, sCases,
+
   -- * Basic singleton definitions
   Sing(SFalse, STrue, STuple0, STuple2, STuple3, STuple4, STuple5, STuple6, STuple7),
   module Data.Singletons,
@@ -45,7 +51,7 @@
   -- so they must be in scope.
 
   PEq(..), If, sIf, (:&&), SEq(..),
-  POrd(..),
+  POrd(..), SOrd(..), ThenCmp, sThenCmp, Foldl, sFoldl,
   Any,
   SDecide(..), (:~:)(..), Void, Refuted, Decision(..),
   Proxy(..), KProxy(..), SomeSing(..),
@@ -60,6 +66,7 @@
   Tuple5Sym0, Tuple5Sym1, Tuple5Sym2, Tuple5Sym3, Tuple5Sym4, Tuple5Sym5,
   Tuple6Sym0, Tuple6Sym1, Tuple6Sym2, Tuple6Sym3, Tuple6Sym4, Tuple6Sym5, Tuple6Sym6,
   Tuple7Sym0, Tuple7Sym1, Tuple7Sym2, Tuple7Sym3, Tuple7Sym4, Tuple7Sym5, Tuple7Sym6, Tuple7Sym7,
+  CompareSym0, ThenCmpSym0, FoldlSym0,
 
   SuppressUnusedWarnings(..)
 
@@ -72,20 +79,17 @@
 import Data.Singletons.Prelude.Bool
 import Data.Singletons.Prelude.Eq
 import Data.Singletons.Prelude.Ord
-import Data.Singletons.Types
-import Data.Singletons.Void
 import Data.Singletons.Decide
 import Data.Singletons.TypeLits
 import Data.Singletons.SuppressUnusedWarnings
+import Data.Singletons.Names
 import Language.Haskell.TH.Desugar
 
 import GHC.Exts
 import Language.Haskell.TH
 import Data.Singletons.Util
-
-#if __GLASGOW_HASKELL__ < 709
-import Control.Applicative
-#endif
+import Data.Proxy ( Proxy(..) )
+import Control.Arrow ( first )
 
 -- | The function 'cases' generates a case expression where each right-hand side
 -- is identical. This may be useful if the type-checker requires knowledge of which
@@ -97,16 +101,47 @@
       -> q Exp       -- ^ The body, in a Template Haskell quote
       -> q Exp
 cases tyName expq bodyq = do
-  info <- reifyWithLocals tyName
-  dinfo <- dsInfo info
+  dinfo <- dsReify tyName
   case dinfo of
-    DTyConI (DDataD _ _ _ _ ctors _) _ -> fmap expToTH $ buildCases ctors
-    _ -> fail $ "Using <<cases>> with something other than a type constructor: "
-                ++ (show tyName)
-  where buildCases ctors =
-          DCaseE <$> (dsExp =<< expq) <*>
-                     mapM (\con -> DMatch (conToPat con) <$> (dsExp =<< bodyq)) ctors
+    Just (DTyConI (DDataD _ _ _ _ ctors _) _) ->
+      expToTH <$> buildCases (map extractNameArgs ctors) expq bodyq
+    Just _ ->
+      fail $ "Using <<cases>> with something other than a type constructor: "
+              ++ (show tyName)
+    _ -> fail $ "Cannot find " ++ show tyName
 
-        conToPat :: DCon -> DPat
-        conToPat (DCon _ _ name fields) =
-          DConPa name (map (const DWildPa) $ tysOfConFields fields)
+-- | The function 'sCases' generates a case expression where each right-hand side
+-- is identical. This may be useful if the type-checker requires knowledge of which
+-- constructor is used to satisfy equality or type-class constraints, but where
+-- each constructor is treated the same. For 'sCases', unlike 'cases', the
+-- scrutinee is a singleton. But make sure to pass in the name of the /original/
+-- datatype, preferring @''Maybe@ over @''SMaybe@.
+sCases :: DsMonad q
+       => Name        -- ^ The head of the type the scrutinee's type is based on.
+                      -- (Like @''Maybe@ or @''Bool@.)
+       -> q Exp       -- ^ The scrutinee, in a Template Haskell quote
+       -> q Exp       -- ^ The body, in a Template Haskell quote
+       -> q Exp
+sCases tyName expq bodyq = do
+  dinfo <- dsReify tyName
+  case dinfo of
+    Just (DTyConI (DDataD _ _ _ _ ctors _) _) ->
+      let ctor_stuff = map (first singDataConName . extractNameArgs) ctors in
+      expToTH <$> buildCases ctor_stuff expq bodyq
+    Just _ ->
+      fail $ "Using <<cases>> with something other than a type constructor: "
+              ++ (show tyName)
+    _ -> fail $ "Cannot find " ++ show tyName
+
+buildCases :: DsMonad m
+           => [(Name, Int)]
+           -> m Exp  -- scrutinee
+           -> m Exp  -- body
+           -> m DExp
+buildCases ctor_infos expq bodyq =
+  DCaseE <$> (dsExp =<< expq) <*>
+             mapM (\con -> DMatch (conToPat con) <$> (dsExp =<< bodyq)) ctor_infos
+  where
+    conToPat :: (Name, Int) -> DPat
+    conToPat (name, num_fields) =
+      DConPa name (replicate num_fields DWildPa)
diff --git a/src/Data/Singletons/TypeLits.hs b/src/Data/Singletons/TypeLits.hs
--- a/src/Data/Singletons/TypeLits.hs
+++ b/src/Data/Singletons/TypeLits.hs
@@ -8,206 +8,36 @@
 -- Portability :  non-portable
 --
 -- Defines and exports singletons useful for the Nat and Symbol kinds.
+-- This exports the internal, unsafe constructors. Use Data.Singletons.TypeLits
+-- for a safe interface.
 --
 ----------------------------------------------------------------------------
 
-{-# LANGUAGE CPP, PolyKinds, DataKinds, TypeFamilies, FlexibleInstances,
-             UndecidableInstances, ScopedTypeVariables, RankNTypes,
-             GADTs, FlexibleContexts, TypeOperators, ConstraintKinds,
-             TemplateHaskell #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-#if __GLASGOW_HASKELL__ < 707
-{-# OPTIONS_GHC -O0 #-}   -- don't optimize SDecide instances in 7.6!
-#endif
-
 module Data.Singletons.TypeLits (
   Nat, Symbol,
   SNat, SSymbol, withKnownNat, withKnownSymbol,
-  Error, ErrorSym0, sError,
+  Error, ErrorSym0, ErrorSym1, sError,
   KnownNat, natVal, KnownSymbol, symbolVal,
 
-  (:+), (:-), (:*), (:^),
-  (:+$), (:+$$), (:-$), (:-$$),
-  (:*$), (:*$$), (:^$), (:^$$)
+  (:^), (:^$), (:^$$), (:^$$$)
   ) where
 
-import Data.Singletons
-import Data.Singletons.Types
-import Data.Singletons.Prelude.Eq
-import Data.Singletons.Prelude.Ord
-import Data.Singletons.Decide
-import Data.Singletons.Prelude.Bool
-import Data.Singletons.Promote
-#if __GLASGOW_HASKELL__ >= 707
-import GHC.TypeLits as TL
-import Data.Type.Equality
-#else
-import GHC.TypeLits (Nat, Symbol)
-import qualified GHC.TypeLits as TL
-#endif
-import Unsafe.Coerce
-
-----------------------------------------------------------------------
----- TypeLits singletons ---------------------------------------------
-----------------------------------------------------------------------
-
-#if __GLASGOW_HASKELL__ >= 707
-data instance Sing (n :: Nat) = KnownNat n => SNat
-
-instance KnownNat n => SingI n where
-  sing = SNat
-
-instance SingKind ('KProxy :: KProxy Nat) where
-  type DemoteRep ('KProxy :: KProxy Nat) = Integer
-  fromSing (SNat :: Sing n) = natVal (Proxy :: Proxy n)
-  toSing n = case someNatVal n of
-               Just (SomeNat (_ :: Proxy n)) -> SomeSing (SNat :: Sing n)
-               Nothing -> error "Negative singleton nat"
-
-data instance Sing (n :: Symbol) = KnownSymbol n => SSym
-
-instance KnownSymbol n => SingI n where
-  sing = SSym
-
-instance SingKind ('KProxy :: KProxy Symbol) where
-  type DemoteRep ('KProxy :: KProxy Symbol) = String
-  fromSing (SSym :: Sing n) = symbolVal (Proxy :: Proxy n)
-  toSing s = case someSymbolVal s of
-               SomeSymbol (_ :: Proxy n) -> SomeSing (SSym :: Sing n)
-
-#else
-
-data TLSingInstance (a :: k) where
-  TLSingInstance :: TL.SingI a => TLSingInstance a
-
-newtype DI a = Don'tInstantiate (TL.SingI a => TLSingInstance a)
-
-tlSingInstance :: forall (a :: k). TL.Sing a -> TLSingInstance a
-tlSingInstance s = with_sing_i TLSingInstance
-  where
-    with_sing_i :: (TL.SingI a => TLSingInstance a) -> TLSingInstance a
-    with_sing_i si = unsafeCoerce (Don'tInstantiate si) s
-
-withTLSingI :: TL.Sing n -> (TL.SingI n => r) -> r
-withTLSingI sn r =
-  case tlSingInstance sn of
-    TLSingInstance -> r
-
-data instance Sing (n :: Nat) = TL.SingRep n Integer => SNat
-
-instance TL.SingRep n Integer => SingI (n :: Nat) where
-  sing = SNat
-
-instance SingKind ('KProxy :: KProxy Nat) where
-  type DemoteRep ('KProxy :: KProxy Nat) = Integer
-  fromSing (SNat :: Sing n) = TL.fromSing (TL.sing :: TL.Sing n)
-  toSing n
-    | n >= 0 = case TL.unsafeSingNat n of
-                 (tlsing :: TL.Sing n) ->
-                   withTLSingI tlsing (SomeSing (SNat :: Sing n))
-    | otherwise = error "Negative singleton nat"
-
-data instance Sing (n :: Symbol) = TL.SingRep n String => SSym
-
-instance TL.SingRep n String => SingI (n :: Symbol) where
-  sing = SSym
-
-instance SingKind ('KProxy :: KProxy Symbol) where
-  type DemoteRep ('KProxy :: KProxy Symbol) = String
-  fromSing (SSym :: Sing n) = TL.fromSing (TL.sing :: TL.Sing n)
-  toSing n = case TL.unsafeSingSymbol n of
-               (tlsing :: TL.Sing n) ->
-                 withTLSingI tlsing (SomeSing (SSym :: Sing n))
-
--- create 7.8-style TypeLits definitions:
-class KnownNat (n :: Nat) where
-  natVal :: proxy n -> Integer
-
-class KnownSymbol (n :: Symbol) where
-  symbolVal :: proxy n -> String
-
-instance TL.SingI n => KnownNat n where
-  natVal _ = TL.fromSing (TL.sing :: TL.Sing n)
-
-instance TL.SingI n => KnownSymbol n where
-  symbolVal _ = TL.fromSing (TL.sing :: TL.Sing n)
-
-#endif
-
--- Synonyms for GHC.TypeLits operations on Nat. These match our naming
--- conventions.
-type x :+ y = x + y
-type x :- y = x - y
-type x :* y = x * y
-type x :^ y = x ^ y
-
-$(genDefunSymbols [ ''(:+), ''(:-), ''(:*), ''(:^)] )
-
--- SDecide instances:
-instance SDecide ('KProxy :: KProxy Nat) where
-  (SNat :: Sing n) %~ (SNat :: Sing m)
-    | natVal (Proxy :: Proxy n) == natVal (Proxy :: Proxy m)
-    = Proved $ unsafeCoerce Refl
-    | otherwise
-    = Disproved (\_ -> error errStr)
-    where errStr = "Broken Nat singletons"
-
-instance SDecide ('KProxy :: KProxy Symbol) where
-  (SSym :: Sing n) %~ (SSym :: Sing m)
-    | symbolVal (Proxy :: Proxy n) == symbolVal (Proxy :: Proxy m)
-    = Proved $ unsafeCoerce Refl
-    | otherwise
-    = Disproved (\_ -> error errStr)
-    where errStr = "Broken Symbol singletons"
-
--- PEq instances
-instance PEq ('KProxy :: KProxy Nat) where
-  type (a :: Nat) :== (b :: Nat) = a == b
-instance PEq ('KProxy :: KProxy Symbol) where
-  type (a :: Symbol) :== (b :: Symbol) = a == b
-
--- need SEq instances for TypeLits kinds
-instance SEq ('KProxy :: KProxy Nat) where
-  a %:== b
-    | fromSing a == fromSing b    = unsafeCoerce STrue
-    | otherwise                   = unsafeCoerce SFalse
-
-instance SEq ('KProxy :: KProxy Symbol) where
-  a %:== b
-    | fromSing a == fromSing b    = unsafeCoerce STrue
-    | otherwise                   = unsafeCoerce SFalse
-
--- POrd instances
-instance POrd ('KProxy :: KProxy Nat) where
-  type (a :: Nat) `Compare` (b :: Nat) = a `TL.CmpNat` b
-
-instance POrd ('KProxy :: KProxy Symbol) where
-  type (a :: Symbol) `Compare` (b :: Symbol) = a `TL.CmpSymbol` b
-
--- | Kind-restricted synonym for 'Sing' for @Nat@s
-type SNat (x :: Nat) = Sing x
-
--- | Kind-restricted synonym for 'Sing' for @Symbol@s
-type SSymbol (x :: Symbol) = Sing x
-
--- Convenience functions
-
--- | Given a singleton for @Nat@, call something requiring a
--- @KnownNat@ instance.
-withKnownNat :: Sing n -> (KnownNat n => r) -> r
-withKnownNat SNat f = f
-
--- | Given a singleton for @Symbol@, call something requiring
--- a @KnownSymbol@ instance.
-withKnownSymbol :: Sing n -> (KnownSymbol n => r) -> r
-withKnownSymbol SSym f = f
+import Data.Singletons.TypeLits.Internal
+import Data.Singletons.Prelude.Num ()   -- for typelits instances
 
--- | The promotion of 'error'
-type family Error (str :: Symbol) :: k
-data ErrorSym0 (t1 :: TyFun k1 k2)
-type instance Apply ErrorSym0 a = Error a
+-- This bogus Num instance is helpful for people who want to define
+-- functions over Nats that will only be used at the type level or
+-- as singletons. A correct SNum instance for Nat singletons exists.
+instance Num Nat where
+  (+)         = no_term_level_nats
+  (-)         = no_term_level_nats
+  (*)         = no_term_level_nats
+  negate      = no_term_level_nats
+  abs         = no_term_level_nats
+  signum      = no_term_level_nats
+  fromInteger = no_term_level_nats
 
--- | The singleton for 'error'
-sError :: Sing (str :: Symbol) -> a
-sError sstr = error (fromSing sstr)
+no_term_level_nats :: a
+no_term_level_nats = error "The kind `Nat` may not be used at the term level."
diff --git a/src/Data/Singletons/TypeLits/Internal.hs b/src/Data/Singletons/TypeLits/Internal.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Singletons/TypeLits/Internal.hs
@@ -0,0 +1,155 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Singletons.TypeLits.Internal
+-- Copyright   :  (C) 2014 Richard Eisenberg
+-- License     :  BSD-style (see LICENSE)
+-- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu)
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- Defines and exports singletons useful for the Nat and Symbol kinds.
+-- This exports the internal, unsafe constructors. Use Data.Singletons.TypeLits
+-- for a safe interface.
+--
+----------------------------------------------------------------------------
+
+{-# LANGUAGE PolyKinds, DataKinds, TypeFamilies, FlexibleInstances,
+             UndecidableInstances, ScopedTypeVariables, RankNTypes,
+             GADTs, FlexibleContexts, TypeOperators, ConstraintKinds,
+             TemplateHaskell #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Data.Singletons.TypeLits.Internal (
+  Sing(..),
+
+  Nat, Symbol,
+  SNat, SSymbol, withKnownNat, withKnownSymbol,
+  Error, ErrorSym0, ErrorSym1, sError,
+  KnownNat, natVal, KnownSymbol, symbolVal,
+
+  (:^), (:^$), (:^$$), (:^$$$)
+  ) where
+
+import Data.Singletons.Promote
+import Data.Singletons
+import Data.Singletons.Prelude.Eq
+import Data.Singletons.Prelude.Ord
+import Data.Singletons.Decide
+import Data.Singletons.Prelude.Bool
+import GHC.TypeLits as TL
+import Data.Type.Equality
+import Data.Proxy ( Proxy(..) )
+import Unsafe.Coerce
+
+----------------------------------------------------------------------
+---- TypeLits singletons ---------------------------------------------
+----------------------------------------------------------------------
+
+data instance Sing (n :: Nat) = KnownNat n => SNat
+
+instance KnownNat n => SingI n where
+  sing = SNat
+
+instance SingKind ('KProxy :: KProxy Nat) where
+  type DemoteRep ('KProxy :: KProxy Nat) = Integer
+  fromSing (SNat :: Sing n) = natVal (Proxy :: Proxy n)
+  toSing n = case someNatVal n of
+               Just (SomeNat (_ :: Proxy n)) -> SomeSing (SNat :: Sing n)
+               Nothing -> error "Negative singleton nat"
+
+data instance Sing (n :: Symbol) = KnownSymbol n => SSym
+
+instance KnownSymbol n => SingI n where
+  sing = SSym
+
+instance SingKind ('KProxy :: KProxy Symbol) where
+  type DemoteRep ('KProxy :: KProxy Symbol) = String
+  fromSing (SSym :: Sing n) = symbolVal (Proxy :: Proxy n)
+  toSing s = case someSymbolVal s of
+               SomeSymbol (_ :: Proxy n) -> SomeSing (SSym :: Sing n)
+
+-- SDecide instances:
+instance SDecide ('KProxy :: KProxy Nat) where
+  (SNat :: Sing n) %~ (SNat :: Sing m)
+    | natVal (Proxy :: Proxy n) == natVal (Proxy :: Proxy m)
+    = Proved $ unsafeCoerce Refl
+    | otherwise
+    = Disproved (\_ -> error errStr)
+    where errStr = "Broken Nat singletons"
+
+instance SDecide ('KProxy :: KProxy Symbol) where
+  (SSym :: Sing n) %~ (SSym :: Sing m)
+    | symbolVal (Proxy :: Proxy n) == symbolVal (Proxy :: Proxy m)
+    = Proved $ unsafeCoerce Refl
+    | otherwise
+    = Disproved (\_ -> error errStr)
+    where errStr = "Broken Symbol singletons"
+
+-- PEq instances
+instance PEq ('KProxy :: KProxy Nat) where
+  type (a :: Nat) :== (b :: Nat) = a == b
+instance PEq ('KProxy :: KProxy Symbol) where
+  type (a :: Symbol) :== (b :: Symbol) = a == b
+
+-- need SEq instances for TypeLits kinds
+instance SEq ('KProxy :: KProxy Nat) where
+  a %:== b
+    | fromSing a == fromSing b    = unsafeCoerce STrue
+    | otherwise                   = unsafeCoerce SFalse
+
+instance SEq ('KProxy :: KProxy Symbol) where
+  a %:== b
+    | fromSing a == fromSing b    = unsafeCoerce STrue
+    | otherwise                   = unsafeCoerce SFalse
+
+-- POrd instances
+instance POrd ('KProxy :: KProxy Nat) where
+  type (a :: Nat) `Compare` (b :: Nat) = a `TL.CmpNat` b
+
+instance POrd ('KProxy :: KProxy Symbol) where
+  type (a :: Symbol) `Compare` (b :: Symbol) = a `TL.CmpSymbol` b
+
+-- | Kind-restricted synonym for 'Sing' for @Nat@s
+type SNat (x :: Nat) = Sing x
+
+-- | Kind-restricted synonym for 'Sing' for @Symbol@s
+type SSymbol (x :: Symbol) = Sing x
+
+-- SOrd instances
+instance SOrd ('KProxy :: KProxy Nat) where
+  a `sCompare` b = case fromSing a `compare` fromSing b of
+                     LT -> unsafeCoerce SLT
+                     EQ -> unsafeCoerce SEQ
+                     GT -> unsafeCoerce SGT
+
+instance SOrd ('KProxy :: KProxy Symbol) where
+  a `sCompare` b = case fromSing a `compare` fromSing b of
+                     LT -> unsafeCoerce SLT
+                     EQ -> unsafeCoerce SEQ
+                     GT -> unsafeCoerce SGT
+
+-- Convenience functions
+
+-- | Given a singleton for @Nat@, call something requiring a
+-- @KnownNat@ instance.
+withKnownNat :: Sing n -> (KnownNat n => r) -> r
+withKnownNat SNat f = f
+
+-- | Given a singleton for @Symbol@, call something requiring
+-- a @KnownSymbol@ instance.
+withKnownSymbol :: Sing n -> (KnownSymbol n => r) -> r
+withKnownSymbol SSym f = f
+
+-- | The promotion of 'error'. This version is more poly-kinded for
+-- easier use.
+type family Error (str :: k0) :: k
+$(genDefunSymbols [''Error])
+
+-- | The singleton for 'error'
+sError :: Sing (str :: Symbol) -> a
+sError sstr = error (fromSing sstr)
+
+-- TODO: move this to a better home:
+type a :^ b = a ^ b
+infixr 8 :^
+$(genDefunSymbols [''(:^)])
diff --git a/src/Data/Singletons/TypeRepStar.hs b/src/Data/Singletons/TypeRepStar.hs
--- a/src/Data/Singletons/TypeRepStar.hs
+++ b/src/Data/Singletons/TypeRepStar.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE RankNTypes, TypeFamilies, KindSignatures, FlexibleInstances,
              GADTs, UndecidableInstances, ScopedTypeVariables, DataKinds,
-             MagicHash, CPP, TypeOperators #-}
+             MagicHash, TypeOperators #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
 -----------------------------------------------------------------------------
@@ -31,20 +31,14 @@
 
 import Data.Singletons.Prelude.Instances
 import Data.Singletons
-import Data.Singletons.Types
 import Data.Singletons.Prelude.Eq
 import Data.Typeable
 import Unsafe.Coerce
 import Data.Singletons.Decide
 
-#if __GLASGOW_HASKELL__ >= 707
 import GHC.Exts ( Proxy# )
 import Data.Type.Coercion
 import Data.Type.Equality
-#else
-eqT :: (Typeable a, Typeable b) => Maybe (a :~: b)
-eqT = gcast Refl
-#endif
 
 data instance Sing (a :: *) where
   STypeRep :: Typeable a => Sing a
@@ -57,11 +51,7 @@
   toSing = dirty_mk_STypeRep
 
 instance PEq ('KProxy :: KProxy *) where
-#if __GLASGOW_HASKELL__ < 707
-  type (a :: *) :== (a :: *) = True
-#else
   type (a :: *) :== (b :: *) = a == b
-#endif
 
 instance SEq ('KProxy :: KProxy *) where
   (STypeRep :: Sing a) %:== (STypeRep :: Sing b) =
@@ -77,27 +67,19 @@
       Just Refl -> Proved Refl
       Nothing   -> Disproved (\Refl -> error "Data.Typeable.eqT failed")
 
-#if __GLASGOW_HASKELL__ >= 707
 -- TestEquality instance already defined, but we need this one:
 instance TestCoercion Sing where
   testCoercion (STypeRep :: Sing a) (STypeRep :: Sing b) =
     case (eqT :: Maybe (a :~: b)) of
       Just Refl -> Just Coercion
       Nothing   -> Nothing
-#endif
 
 -- everything below here is private and dirty. Don't look!
 
 newtype DI = Don'tInstantiate (forall a. Typeable a => Sing a)
 dirty_mk_STypeRep :: TypeRep -> SomeSing ('KProxy :: KProxy *)
 dirty_mk_STypeRep rep =
-#if __GLASGOW_HASKELL__ >= 707
   let justLikeTypeable :: Proxy# a -> TypeRep
       justLikeTypeable _ = rep
   in
-#else
-  let justLikeTypeable :: a -> TypeRep
-      justLikeTypeable _ = rep
-  in
-#endif
   unsafeCoerce (Don'tInstantiate STypeRep) justLikeTypeable
diff --git a/src/Data/Singletons/Types.hs b/src/Data/Singletons/Types.hs
deleted file mode 100644
--- a/src/Data/Singletons/Types.hs
+++ /dev/null
@@ -1,53 +0,0 @@
-{-# LANGUAGE PolyKinds, TypeOperators, GADTs, RankNTypes, TypeFamilies,
-             CPP, DataKinds #-}
-
------------------------------------------------------------------------------
--- |
--- Module      :  Data.Singletons.Types
--- Copyright   :  (C) 2013 Richard Eisenberg
--- License     :  BSD-style (see LICENSE)
--- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu)
--- Stability   :  experimental
--- Portability :  non-portable
---
--- Defines and exports types that are useful when working with singletons.
--- Some of these are re-exports from @Data.Type.Equality@.
---
-----------------------------------------------------------------------------
-
-
-module Data.Singletons.Types (
-  KProxy(..), Proxy(..),
-  (:~:)(..), gcastWith, TestEquality(..),
-  If
-  ) where
-
-#if __GLASGOW_HASKELL__ < 707
-
--- now in Data.Proxy
-data KProxy (a :: *) = KProxy
-data Proxy a = Proxy
-
--- now in Data.Type.Equality
-data a :~: b where
-  Refl :: a :~: a
-
-gcastWith :: (a :~: b) -> ((a ~ b) => r) -> r
-gcastWith Refl x = x
-
-class TestEquality (f :: k -> *) where
-  testEquality :: f a -> f b -> Maybe (a :~: b)
-
--- now in Data.Type.Bool
--- | Type-level "If". @If True a b@ ==> @a@; @If False a b@ ==> @b@
-type family If (a :: Bool) (b :: k) (c :: k) :: k
-type instance If 'True b c = b
-type instance If 'False b c = c
-
-#else
-
-import Data.Proxy
-import Data.Type.Equality
-import Data.Type.Bool
-
-#endif
diff --git a/src/Data/Singletons/Util.hs b/src/Data/Singletons/Util.hs
--- a/src/Data/Singletons/Util.hs
+++ b/src/Data/Singletons/Util.hs
@@ -7,15 +7,15 @@
 Users of the package should not need to consult this file.
 -}
 
-{-# LANGUAGE CPP, TypeSynonymInstances, FlexibleInstances, RankNTypes,
+{-# LANGUAGE TypeSynonymInstances, FlexibleInstances, RankNTypes,
              TemplateHaskell, GeneralizedNewtypeDeriving,
              MultiParamTypeClasses, StandaloneDeriving,
              UndecidableInstances, MagicHash, UnboxedTuples,
-             LambdaCase #-}
+             LambdaCase, CPP #-}
 
 module Data.Singletons.Util where
 
-import Prelude hiding ( exp, foldl, concat, mapM, any )
+import Prelude hiding ( exp, foldl, concat, mapM, any, pred )
 import Language.Haskell.TH.Syntax hiding ( lift )
 import Language.Haskell.TH.Desugar
 import Data.Char
@@ -23,14 +23,10 @@
 import Control.Monad.Writer hiding ( mapM )
 import Control.Monad.Reader hiding ( mapM )
 import qualified Data.Map as Map
+import Data.Map ( Map )
 import Data.Foldable
 import Data.Traversable
 
-#if __GLASGOW_HASKELL__ < 709
-import Control.Applicative
-import GHC.Exts ( Int(I#) )
-#endif
-
 -- The list of types that singletons processes by default
 basicTypes :: [Name]
 basicTypes = [ ''Maybe
@@ -39,23 +35,24 @@
              ] ++ boundedBasicTypes
 
 boundedBasicTypes :: [Name]
-boundedBasicTypes = [ ''Bool
-             , ''Ordering
-             , ''()
-             , ''(,)
-             , ''(,,)
-             , ''(,,,)
-             , ''(,,,,)
-             , ''(,,,,,)
-             , ''(,,,,,,)
-            ]
+boundedBasicTypes =
+            [  ''(,)
+            , ''(,,)
+            , ''(,,,)
+            , ''(,,,,)
+            , ''(,,,,,)
+            , ''(,,,,,,)
+            ] ++ enumBasicTypes
 
--- like reportWarning, but generalized to any DsMonad
-qReportWarning :: DsMonad q => String -> q ()
+enumBasicTypes :: [Name]
+enumBasicTypes = [ ''Bool, ''Ordering, ''() ]
+
+-- like reportWarning, but generalized to any Quasi
+qReportWarning :: Quasi q => String -> q ()
 qReportWarning = qReport False
 
--- like reportError, but generalized to any DsMonad
-qReportError :: DsMonad q => String -> q ()
+-- like reportError, but generalized to any Quasi
+qReportError :: Quasi q => String -> q ()
 qReportError = qReport True
 
 -- | Generate a new Unique
@@ -63,21 +60,17 @@
 qNewUnique = do
   Name _ flav <- qNewName "x"
   case flav of
-#if __GLASGOW_HASKELL__ >= 709
     NameU n -> return n
-#else
-    NameU n -> return (I# n)
-#endif
     _       -> error "Internal error: `qNewName` didn't return a NameU"
 
-checkForRep :: DsMonad q => [Name] -> q ()
+checkForRep :: Quasi q => [Name] -> q ()
 checkForRep names =
   when (any ((== "Rep") . nameBase) names)
     (fail $ "A data type named <<Rep>> is a special case.\n" ++
             "Promoting it will not work as expected.\n" ++
             "Please choose another name for your data type.")
 
-checkForRepInDecls :: DsMonad q => [DDec] -> q ()
+checkForRepInDecls :: Quasi q => [DDec] -> q ()
 checkForRepInDecls decls =
   checkForRep (allNamesIn decls)
 
@@ -93,6 +86,9 @@
 extractNameTypes :: DCon -> (Name, [DType])
 extractNameTypes (DCon _ _ n fields) = (n, tysOfConFields fields)
 
+extractName :: DCon -> Name
+extractName (DCon _ _ n _) = n
+
 -- is an identifier uppercase?
 isUpcase :: Name -> Bool
 isUpcase n = let first = head (nameBase n) in isUpper first || first == ':'
@@ -186,7 +182,7 @@
                  _   -> error "non-digit in show #"
       in d' : convert ds
 
--- extract the kind from a TyVarBndr. Returns '*' by default.
+-- extract the kind from a TyVarBndr
 extractTvbKind :: DTyVarBndr -> Maybe DKind
 extractTvbKind (DPlainTV _) = Nothing
 extractTvbKind (DKindedTV _ k) = Just k
@@ -196,38 +192,100 @@
 extractTvbName (DPlainTV n) = n
 extractTvbName (DKindedTV n _) = n
 
--- use the kind provided, or make a fresh kind variable
-inferKind :: DsMonad q => Maybe DKind -> q (Maybe DKind)
-inferKind (Just k) = return $ Just k
-#if __GLASGOW_HASKELL__ < 707
-inferKind Nothing = do
-  newK <- qNewName "k"
-  return $ Just $ DVarK newK
-#else
-inferKind Nothing = return Nothing
-#endif
+tvbToType :: DTyVarBndr -> DType
+tvbToType = DVarT . extractTvbName
 
+inferMaybeKindTV :: Name -> Maybe DKind -> DTyVarBndr
+inferMaybeKindTV n Nothing =  DPlainTV n
+inferMaybeKindTV n (Just k) = DKindedTV n k
+
 -- Get argument types from an arrow type. Removing ForallT is an
 -- important preprocessing step required by promoteType.
-unravel :: DType -> ([DPred], [DType])
-unravel (DForallT _ cxt ty) =
-  let (cxt', tys) = unravel ty in
-  (cxt ++ cxt', tys)
+unravel :: DType -> ([DTyVarBndr], [DPred], [DType], DType)
+unravel (DForallT tvbs cxt ty) =
+  let (tvbs', cxt', tys, res) = unravel ty in
+  (tvbs ++ tvbs', cxt ++ cxt', tys, res)
 unravel (DAppT (DAppT DArrowT t1) t2) =
-  let (cxt, tys) = unravel t2 in
-  (cxt, t1 : tys)
-unravel t = ([], [t])
+  let (tvbs, cxt, tys, res) = unravel t2 in
+  (tvbs, cxt, t1 : tys, res)
+unravel t = ([], [], [], t)
 
 -- Reconstruct arrow kind from the list of kinds
-ravel :: [DType] -> DType
-ravel []    = error "Internal error: raveling nil"
-ravel [k]   = k
-ravel (h:t) = DAppT (DAppT DArrowT h) (ravel t)
+ravel :: [DType] -> DType -> DType
+ravel []    res  = res
+ravel (h:t) res = DAppT (DAppT DArrowT h) (ravel t res)
 
 -- count the number of arguments in a type
 countArgs :: DType -> Int
-countArgs ty = length (snd $ unravel ty) - 1
+countArgs ty = length args
+  where (_, _, args, _) = unravel ty
 
+substKind :: Map Name DKind -> DKind -> DKind
+substKind _ (DForallK {}) =
+  error "Higher-rank kind encountered in instance method promotion."
+substKind subst (DVarK n) =
+  case Map.lookup n subst of
+    Just ki -> ki
+    Nothing -> DVarK n
+substKind subst (DConK con kis) = DConK con (map (substKind subst) kis)
+substKind subst (DArrowK k1 k2) = DArrowK (substKind subst k1) (substKind subst k2)
+substKind _ DStarK = DStarK
+
+substType :: Map Name DType -> DType -> DType
+substType subst ty | Map.null subst = ty
+substType subst (DForallT tvbs cxt inner_ty) =
+  let subst'    = foldr Map.delete subst (map extractTvbName tvbs)
+      cxt'      = map (substPred subst') cxt
+      inner_ty' = substType subst' inner_ty
+  in
+  DForallT tvbs cxt' inner_ty'
+substType subst (DAppT ty1 ty2) = substType subst ty1 `DAppT` substType subst ty2
+substType subst (DSigT ty ki) = substType subst ty `DSigT` ki
+substType subst (DVarT n) =
+  case Map.lookup n subst of
+    Just ki -> ki
+    Nothing -> DVarT n
+substType _ ty@(DConT {}) = ty
+substType _ ty@(DArrowT)  = ty
+substType _ ty@(DLitT {}) = ty
+
+substPred :: Map Name DType -> DPred -> DPred
+substPred subst pred | Map.null subst = pred
+substPred subst (DAppPr pred ty) =
+  DAppPr (substPred subst pred) (substType subst ty)
+substPred subst (DSigPr pred ki) = DSigPr (substPred subst pred) ki
+substPred _ pred@(DVarPr {}) = pred
+substPred _ pred@(DConPr {}) = pred
+
+substKindInType :: Map Name DKind -> DType -> DType
+substKindInType subst ty | Map.null subst = ty
+substKindInType subst (DForallT tvbs cxt inner_ty) =
+  let tvbs'     = map (substKindInTvb subst) tvbs
+      cxt'      = map (substKindInPred subst) cxt
+      inner_ty' = substKindInType subst inner_ty
+  in
+  DForallT tvbs' cxt' inner_ty'
+substKindInType subst (DAppT ty1 ty2)
+  = substKindInType subst ty1 `DAppT` substKindInType subst ty2
+substKindInType subst (DSigT ty ki) = substKindInType subst ty `DSigT` substKind subst ki
+substKindInType _ ty@(DVarT {}) = ty
+substKindInType _ ty@(DConT {}) = ty
+substKindInType _ ty@(DArrowT)  = ty
+substKindInType _ ty@(DLitT {}) = ty
+
+substKindInPred :: Map Name DKind -> DPred -> DPred
+substKindInPred subst pred | Map.null subst = pred
+substKindInPred subst (DAppPr pred ty) =
+  DAppPr (substKindInPred subst pred) (substKindInType subst ty)
+substKindInPred subst (DSigPr pred ki) = DSigPr (substKindInPred subst pred)
+                                                (substKind subst ki)
+substKindInPred _ pred@(DVarPr {}) = pred
+substKindInPred _ pred@(DConPr {}) = pred
+
+substKindInTvb :: Map Name DKind -> DTyVarBndr -> DTyVarBndr
+substKindInTvb _ tvb@(DPlainTV _) = tvb
+substKindInTvb subst (DKindedTV n ki) = DKindedTV n (substKind subst ki)
+
 addStar :: DKind -> DKind
 addStar t = DArrowK t DStarK
 
@@ -258,7 +316,6 @@
 orIfEmpty [] x = x
 orIfEmpty x  _ = x
 
--- an empty list of matches, compatible with GHC 7.6.3
 emptyMatches :: [DMatch]
 emptyMatches = [DMatch DWildPa (DAppE (DVarE 'error) (DLitE (StringL errStr)))]
   where errStr = "Empty case reached -- this should be impossible"
@@ -280,7 +337,7 @@
   deriving ( Functor, Applicative, Monad, MonadTrans
            , MonadWriter m, MonadReader r )
 
--- make a DsMonad instance for easy lifting
+-- make a Quasi instance for easy lifting
 instance (Quasi q, Monoid m) => Quasi (QWithAux m q) where
   qNewName          = lift `comp1` qNewName
   qReport           = lift `comp2` qReport
@@ -290,7 +347,6 @@
   qLocation         = lift qLocation
   qRunIO            = lift `comp1` qRunIO
   qAddDependentFile = lift `comp1` qAddDependentFile
-#if __GLASGOW_HASKELL__ >= 707
   qReifyRoles       = lift `comp1` qReifyRoles
   qReifyAnnotations = lift `comp1` qReifyAnnotations
   qReifyModule      = lift `comp1` qReifyModule
@@ -298,7 +354,6 @@
   qAddModFinalizer  = lift `comp1` qAddModFinalizer
   qGetQ             = lift qGetQ
   qPutQ             = lift `comp1` qPutQ
-#endif
 
   qRecover exp handler = do
     (result, aux) <- lift $ qRecover (evalForPair exp) (evalForPair handler)
diff --git a/src/Data/Singletons/Void.hs b/src/Data/Singletons/Void.hs
deleted file mode 100644
--- a/src/Data/Singletons/Void.hs
+++ /dev/null
@@ -1,78 +0,0 @@
-{- Data/Singletons/Void.hs
-
-   A reimplementation of a Void type, copied shamelessly from Edward Kmett's void
-   package, but without inducing a dependency.
-
--}
-
-{-# LANGUAGE CPP, Trustworthy, DeriveDataTypeable, DeriveGeneric, StandaloneDeriving #-}
-
------------------------------------------------------------------------------
--- |
--- Copyright   :  (C) 2008-2013 Edward Kmett
--- License     :  BSD-style (see LICENSE)
--- Maintainer  :  Richard Eisenberg (eir@cis.upenn.edu)
--- Stability   :  experimental
--- Portability :  non-portable
---
--- This module is a reimplementation of Edward Kmett's @void@ package.
--- It is included within singletons to avoid depending on @void@ and all the
--- packages that depends on (including @text@). If this causes problems for
--- you (that singletons has its own 'Void' type), please let me (Richard Eisenberg)
--- know at @eir@ at @cis.upenn.edu@.
---
-----------------------------------------------------------------------------
-module Data.Singletons.Void
-  ( Void
-  , absurd
-  , vacuous
-  , vacuousM
-  ) where
-
-import Control.Monad (liftM)
-import Data.Ix
-import Data.Data
-import GHC.Generics
-import Control.Exception
-
--- | A logically uninhabited data type.
-newtype Void = Void Void
-  deriving (Data, Typeable, Generic)
-
-instance Eq Void where
-  _ == _ = True
-
-instance Ord Void where
-  compare _ _ = EQ
-
-instance Show Void where
-  showsPrec _ = absurd
-
--- | Reading a 'Void' value is always a parse error, considering 'Void' as
--- a data type with no constructors.
-instance Read Void where
-  readsPrec _ _ = []
-
--- | Since 'Void' values logically don't exist, this witnesses the logical
--- reasoning tool of \"ex falso quodlibet\".
-absurd :: Void -> a
-absurd a = a `seq` spin a where
-   spin (Void b) = spin b
-
--- | If 'Void' is uninhabited then any 'Functor' that holds only values of type 'Void'
--- is holding no values.
-vacuous :: Functor f => f Void -> f a
-vacuous = fmap absurd
-
--- | If 'Void' is uninhabited then any 'Monad' that holds values of type 'Void'
--- is holding no values.
-vacuousM :: Monad m => m Void -> m a
-vacuousM = liftM absurd
-
-instance Ix Void where
-  range _ = []
-  index _ = absurd
-  inRange _ = absurd
-  rangeSize _ = 0
-
-instance Exception Void
diff --git a/tests/SingletonsTestSuite.hs b/tests/SingletonsTestSuite.hs
--- a/tests/SingletonsTestSuite.hs
+++ b/tests/SingletonsTestSuite.hs
@@ -4,10 +4,14 @@
 
 import Test.Tasty               ( TestTree, defaultMain, testGroup          )
 import SingletonsTestSuiteUtils ( compileAndDumpStdTest, compileAndDumpTest
-                                , testCompileAndDumpGroup, ghcOpts          )
+                                , testCompileAndDumpGroup, ghcOpts
+                             --   , cleanFiles
+                                )
 
 main :: IO ()
-main = defaultMain tests
+main = do
+--  cleanFiles    We really need to parallelize the testsuite.
+  defaultMain tests
 
 tests :: TestTree
 tests =
@@ -25,7 +29,6 @@
     , compileAndDumpStdTest "EqInstances"
     , compileAndDumpStdTest "CaseExpressions"
     , compileAndDumpStdTest "Star"
-    , compileAndDumpStdTest "Tuples"
     , compileAndDumpStdTest "ReturnFunc"
     , compileAndDumpStdTest "Lambdas"
     , compileAndDumpStdTest "LambdasComprehensive"
@@ -38,17 +41,25 @@
     , compileAndDumpStdTest "Records"
     , compileAndDumpStdTest "T29"
     , compileAndDumpStdTest "T33"
+    , compileAndDumpStdTest "T54"
+    , compileAndDumpStdTest "Classes"
+    , compileAndDumpStdTest "Classes2"
+    , compileAndDumpStdTest "FunDeps"
+    , compileAndDumpStdTest "T78"
+    , compileAndDumpStdTest "OrdDeriving"
+    , compileAndDumpStdTest "BoundedDeriving"
+    , compileAndDumpStdTest "BadBoundedDeriving"
+    , compileAndDumpStdTest "EnumDeriving"
+    , compileAndDumpStdTest "BadEnumDeriving"
+    , compileAndDumpStdTest "Fixity"
+    , compileAndDumpStdTest "Undef"
+    , compileAndDumpStdTest "T124"
     ],
     testCompileAndDumpGroup "Promote"
     [ compileAndDumpStdTest "Constructors"
     , compileAndDumpStdTest "GenDefunSymbols"
     , compileAndDumpStdTest "Newtypes"
-    , compileAndDumpStdTest "Classes"
-    , compileAndDumpStdTest "TopLevelPatterns"
     , compileAndDumpStdTest "Pragmas"
-    , compileAndDumpStdTest "OrdDeriving"
-    , compileAndDumpStdTest "BoundedDeriving"
-    , compileAndDumpStdTest "BadBoundedDeriving"
     , compileAndDumpStdTest "Prelude"
     ],
     testGroup "Database client"
diff --git a/tests/SingletonsTestSuiteUtils.hs b/tests/SingletonsTestSuiteUtils.hs
--- a/tests/SingletonsTestSuiteUtils.hs
+++ b/tests/SingletonsTestSuiteUtils.hs
@@ -4,26 +4,26 @@
  , compileAndDumpStdTest
  , testCompileAndDumpGroup
  , ghcOpts
- , singletonsVersion
+ , cleanFiles
  ) where
 
 import Control.Exception  ( Exception, throw                    )
-import Data.List          ( intercalate                         )
+import Control.Monad      ( liftM                               )
+import Data.List          ( intercalate, find, isPrefixOf       )
 import Data.Typeable      ( Typeable                            )
 import System.Exit        ( ExitCode(..)                        )
 import System.FilePath    ( takeBaseName, pathSeparator         )
 import System.IO          ( IOMode(..), hGetContents, openFile  )
 import System.Process     ( CreateProcess(..), StdStream(..)
-                          , createProcess, proc, waitForProcess )
+                          , createProcess, proc, waitForProcess
+                          , readProcess, callCommand            )
+import System.Directory   ( doesFileExist                       )
 import Test.Tasty         ( TestTree, testGroup                 )
 import Test.Tasty.Golden  ( goldenVsFileDiff                    )
 
-import Distribution.PackageDescription.Parse         ( readPackageDescription    )
-import Distribution.PackageDescription.Configuration ( flattenPackageDescription )
-import Distribution.PackageDescription               ( PackageDescription(..)    )
-import Distribution.Verbosity                        ( silent                    )
 import Distribution.Package                          ( PackageIdentifier(..)     )
-import Data.Version                                  ( showVersion               )
+import Distribution.Text                             ( simpleParse               )
+import Data.Version                                  ( Version(..)               )
 import System.IO.Unsafe                              ( unsafePerformIO           )
 
 #include "../dist/build/autogen/cabal_macros.h"
@@ -35,7 +35,6 @@
 
 instance Show ProcessException where
     show (ProcessException msg) = msg
-
 -- GHC executable name (if on path) or full path
 ghcPath :: FilePath
 ghcPath = "ghc"
@@ -50,49 +49,58 @@
 includePath = "../../dist/build"
 
 ghcVersion :: String
-#if __GLASGOW_HASKELL__ <  706
-ghcVersion = error "testsuite requires GHC 7.6 or newer"
-#else
-#if __GLASGOW_HASKELL__ >= 706 && __GLASGOW_HASKELL__ < 707
-ghcVersion = ".ghc76"
-#else
-ghcVersion = ".ghc78"
-#endif
-#endif
+ghcVersion = ".ghc710"
 
--- the version number of "singletons"
-singletonsVersion :: String
-singletonsVersion = unsafePerformIO $ do
-  gpd <- readPackageDescription silent "singletons.cabal"
-  let pd = flattenPackageDescription gpd
-  return $ showVersion $ pkgVersion $ package pd
+-- The mtl package made an incompatible change between 2.1.3.1 and 2.2.1. Because
+-- test files are compiled outside of the cabal infrastructure, we need to check
+-- the mtl version and behave accordingly. Argh. The more general solution to this
+-- is to use cabal_macros.h and then use the package specifications in dist/setup-config.
+-- This also uses a cabal sandbox, if it is around.
+extraOpts :: [String]
+extraOpts = unsafePerformIO $ do
+  (ghcPackageDbOpts, ghcPkgOpts) <- do
+     sandboxed <- doesFileExist "cabal.sandbox.config"
+     if sandboxed
+     then do
+       let prefix = "package-db: "
+           opts_from_config config =
+             case find (prefix `isPrefixOf`) $ lines config of
+               Nothing -> ([], [])
+               Just db_line -> let package_db = drop (length prefix) db_line in
+                               ( [ "-no-user-package-db"
+                                 , "-package-db " ++ package_db ]
+                               , [ "--no-user-package-db"  -- ghc-pkg is slightly different!
+                                 , "--package-db=" ++ package_db ] )
+       opts_from_config `liftM` readFile "cabal.sandbox.config"
+     else return ([], [])
+  mtl_string <- readProcess "ghc-pkg" (ghcPkgOpts ++ ["latest", "mtl"]) ""
+  let Just (PackageIdentifier { pkgVersion = ver }) = simpleParse mtl_string
+      firstModernVersion = Version [2,2,1] []
+      mtlOpt | ver >= firstModernVersion = ["-DMODERN_MTL"]
+             | otherwise                 = []
+  return $ ghcPackageDbOpts ++ mtlOpt
 
+
 -- GHC options used when running the tests
 ghcOpts :: [String]
-ghcOpts = [
+ghcOpts = extraOpts ++ [
     "-v0"
   , "-c"
-#if __GLASGOW_HASKELL__ < 709
-  , "-package-name singletons-" ++ singletonsVersion -- See Note [-package-name hack]
-#else
-  , "-this-package-key " ++ CURRENT_PACKAGE_KEY
-#endif
+  , "-this-package-key " ++ CURRENT_PACKAGE_KEY -- See Note [-this-package-key hack]
   , "-ddump-splices"
   , "-dsuppress-uniques"
   , "-fforce-recomp"
   , "-fprint-explicit-kinds"
-  , "-i" ++ includePath
+  , "-O0"
+  , "-i" ++ includePath   -- necessary because some tests use these modules
+  , "-itests/compile-and-dump"
   , "-XTemplateHaskell"
   , "-XDataKinds"
   , "-XKindSignatures"
   , "-XTypeFamilies"
-  , "-XTemplateHaskell"
   , "-XTypeOperators"
-  , "-XKindSignatures"
-  , "-XDataKinds"
   , "-XMultiParamTypeClasses"
   , "-XGADTs"
-  , "-XTypeFamilies"
   , "-XFlexibleInstances"
   , "-XUndecidableInstances"
   , "-XRankNTypes"
@@ -100,17 +108,18 @@
   , "-XPolyKinds"
   , "-XFlexibleContexts"
   , "-XIncoherentInstances"
-  , "-XCPP"
   , "-XLambdaCase"
   , "-XUnboxedTuples"
+  , "-XInstanceSigs"
+  , "-XDefaultSignatures"
   ]
 
--- Note [-package-name hack]
--- ~~~~~~~~~~~~~~~~~~~~~~~~~
+-- Note [-this-package-key hack]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 --
 -- We want to avoid installing singletons package before running the
 -- testsuite, because in this way we prevent double compilation of the
--- library. To do this we pass -package-name option to GHC to convince
+-- library. To do this we pass -this-package-key option to GHC to convince
 -- it that the test files are actually part of the current
 -- package. This means that library doesn't have to be installed
 -- globally and interface files generated during library compilation
@@ -240,3 +249,6 @@
        err <- hGetContents serr -- Text would be faster than String, but this is
                                 -- a corner case so probably not worth it.
        throw $ ProcessException ("Error when running " ++ program ++ ":\n" ++ err)
+
+cleanFiles :: IO ()
+cleanFiles = callCommand "rm -f tests/compile-and-dump/*/*.{hi,o}"
diff --git a/tests/compile-and-dump/GradingClient/Database.ghc710.template b/tests/compile-and-dump/GradingClient/Database.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/GradingClient/Database.ghc710.template
@@ -0,0 +1,4916 @@
+GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data Nat
+            = Zero | Succ Nat
+            deriving (Eq, Ord) |]
+  ======>
+    data Nat
+      = Zero | Succ Nat
+      deriving (Eq, Ord)
+    type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where
+      Equals_0123456789 Zero Zero = TrueSym0
+      Equals_0123456789 (Succ a) (Succ b) = (:==) a b
+      Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0
+    instance PEq (KProxy :: KProxy Nat) where
+      type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b
+    type ZeroSym0 = Zero
+    type SuccSym1 (t :: Nat) = Succ t
+    instance SuppressUnusedWarnings SuccSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
+    data SuccSym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
+        SuccSym0KindInference
+    type instance Apply SuccSym0 l = SuccSym1 l
+    type family Compare_0123456789 (a :: Nat)
+                                   (a :: Nat) :: Ordering where
+      Compare_0123456789 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]
+      Compare_0123456789 (Succ a_0123456789) (Succ b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])
+      Compare_0123456789 Zero (Succ _z_0123456789) = LTSym0
+      Compare_0123456789 (Succ _z_0123456789) Zero = GTSym0
+    type Compare_0123456789Sym2 (t :: Nat) (t :: Nat) =
+        Compare_0123456789 t t
+    instance SuppressUnusedWarnings Compare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.())
+    data Compare_0123456789Sym1 (l :: Nat) (l :: TyFun Nat Ordering)
+      = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) =>
+        Compare_0123456789Sym1KindInference
+    type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Compare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.())
+    data Compare_0123456789Sym0 (l :: TyFun Nat (TyFun Nat Ordering
+                                                 -> *))
+      = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) =>
+        Compare_0123456789Sym0KindInference
+    type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l
+    instance POrd (KProxy :: KProxy Nat) where
+      type Compare (a :: Nat) (a :: Nat) = Apply (Apply Compare_0123456789Sym0 a) a
+    data instance Sing (z :: Nat)
+      = z ~ Zero => SZero |
+        forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat))
+    type SNat = (Sing :: Nat -> *)
+    instance SingKind (KProxy :: KProxy Nat) where
+      type DemoteRep (KProxy :: KProxy Nat) = Nat
+      fromSing SZero = Zero
+      fromSing (SSucc b) = Succ (fromSing b)
+      toSing Zero = SomeSing SZero
+      toSing (Succ b)
+        = case toSing b :: SomeSing (KProxy :: KProxy Nat) of {
+            SomeSing c -> SomeSing (SSucc c) }
+    instance SEq (KProxy :: KProxy Nat) where
+      (%:==) SZero SZero = STrue
+      (%:==) SZero (SSucc _) = SFalse
+      (%:==) (SSucc _) SZero = SFalse
+      (%:==) (SSucc a) (SSucc b) = (%:==) a b
+    instance SDecide (KProxy :: KProxy Nat) where
+      (%~) SZero SZero = Proved Refl
+      (%~) SZero (SSucc _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SSucc _) SZero
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SSucc a) (SSucc b)
+        = case (%~) a b of {
+            Proved Refl -> Proved Refl
+            Disproved contra
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+    instance SOrd (KProxy :: KProxy Nat) =>
+             SOrd (KProxy :: KProxy Nat) where
+      sCompare ::
+        forall (t0 :: Nat) (t1 :: Nat).
+        Sing t0
+        -> Sing t1
+           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat (TyFun Nat Ordering
+                                                            -> *)
+                                                 -> *) t0 :: TyFun Nat Ordering
+                                                             -> *) t1 :: Ordering)
+      sCompare SZero SZero
+        = let
+            lambda ::
+              (t0 ~ ZeroSym0, t1 ~ ZeroSym0) =>
+              Sing (Apply (Apply CompareSym0 ZeroSym0) ZeroSym0 :: Ordering)
+            lambda
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  SNil
+          in lambda
+      sCompare (SSucc sA_0123456789) (SSucc sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     b_0123456789. (t0 ~ Apply SuccSym0 a_0123456789,
+                                    t1 ~ Apply SuccSym0 b_0123456789) =>
+              Sing a_0123456789
+              -> Sing b_0123456789
+                 -> Sing (Apply (Apply CompareSym0 (Apply SuccSym0 a_0123456789)) (Apply SuccSym0 b_0123456789) :: Ordering)
+            lambda a_0123456789 b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Proxy :: Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                           b_0123456789))
+                     SNil)
+          in lambda sA_0123456789 sB_0123456789
+      sCompare SZero (SSucc _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ ZeroSym0,
+                                     t1 ~ Apply SuccSym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 ZeroSym0) (Apply SuccSym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 = SLT
+          in lambda _s_z_0123456789
+      sCompare (SSucc _s_z_0123456789) SZero
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ Apply SuccSym0 _z_0123456789,
+                                     t1 ~ ZeroSym0) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 (Apply SuccSym0 _z_0123456789)) ZeroSym0 :: Ordering)
+            lambda _z_0123456789 = SGT
+          in lambda _s_z_0123456789
+    instance SingI Zero where
+      sing = SZero
+    instance SingI n => SingI (Succ (n :: Nat)) where
+      sing = SSucc sing
+GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| append :: Schema -> Schema -> Schema
+          append (Sch s1) (Sch s2) = Sch (s1 ++ s2)
+          attrNotIn :: Attribute -> Schema -> Bool
+          attrNotIn _ (Sch []) = True
+          attrNotIn (Attr name u) (Sch ((Attr name' _) : t))
+            = (name /= name') && (attrNotIn (Attr name u) (Sch t))
+          disjoint :: Schema -> Schema -> Bool
+          disjoint (Sch []) _ = True
+          disjoint (Sch (h : t)) s = (attrNotIn h s) && (disjoint (Sch t) s)
+          occurs :: [AChar] -> Schema -> Bool
+          occurs _ (Sch []) = False
+          occurs name (Sch ((Attr name' _) : attrs))
+            = name == name' || occurs name (Sch attrs)
+          lookup :: [AChar] -> Schema -> U
+          lookup _ (Sch []) = undefined
+          lookup name (Sch ((Attr name' u) : attrs))
+            = if name == name' then u else lookup name (Sch attrs)
+          
+          data U
+            = BOOL | STRING | NAT | VEC U Nat
+            deriving (Read, Eq, Show)
+          data AChar
+            = CA |
+              CB |
+              CC |
+              CD |
+              CE |
+              CF |
+              CG |
+              CH |
+              CI |
+              CJ |
+              CK |
+              CL |
+              CM |
+              CN |
+              CO |
+              CP |
+              CQ |
+              CR |
+              CS |
+              CT |
+              CU |
+              CV |
+              CW |
+              CX |
+              CY |
+              CZ
+            deriving (Read, Show, Eq)
+          data Attribute = Attr [AChar] U
+          data Schema = Sch [Attribute] |]
+  ======>
+    data U
+      = BOOL | STRING | NAT | VEC U Nat
+      deriving (Read, Eq, Show)
+    data AChar
+      = CA |
+        CB |
+        CC |
+        CD |
+        CE |
+        CF |
+        CG |
+        CH |
+        CI |
+        CJ |
+        CK |
+        CL |
+        CM |
+        CN |
+        CO |
+        CP |
+        CQ |
+        CR |
+        CS |
+        CT |
+        CU |
+        CV |
+        CW |
+        CX |
+        CY |
+        CZ
+      deriving (Read, Show, Eq)
+    data Attribute = Attr [AChar] U
+    data Schema = Sch [Attribute]
+    append :: Schema -> Schema -> Schema
+    append (Sch s1) (Sch s2) = Sch (s1 ++ s2)
+    attrNotIn :: Attribute -> Schema -> Bool
+    attrNotIn _ (Sch GHC.Types.[]) = True
+    attrNotIn (Attr name u) (Sch ((Attr name' _) GHC.Types.: t))
+      = ((name /= name') && (attrNotIn (Attr name u) (Sch t)))
+    disjoint :: Schema -> Schema -> Bool
+    disjoint (Sch GHC.Types.[]) _ = True
+    disjoint (Sch (h GHC.Types.: t)) s
+      = ((attrNotIn h s) && (disjoint (Sch t) s))
+    occurs :: [AChar] -> Schema -> Bool
+    occurs _ (Sch GHC.Types.[]) = False
+    occurs name (Sch ((Attr name' _) GHC.Types.: attrs))
+      = ((name == name') || (occurs name (Sch attrs)))
+    lookup :: [AChar] -> Schema -> U
+    lookup _ (Sch GHC.Types.[]) = undefined
+    lookup name (Sch ((Attr name' u) GHC.Types.: attrs))
+      = if (name == name') then u else lookup name (Sch attrs)
+    type family Equals_0123456789 (a :: U) (b :: U) :: Bool where
+      Equals_0123456789 BOOL BOOL = TrueSym0
+      Equals_0123456789 STRING STRING = TrueSym0
+      Equals_0123456789 NAT NAT = TrueSym0
+      Equals_0123456789 (VEC a a) (VEC b b) = (:&&) ((:==) a b) ((:==) a b)
+      Equals_0123456789 (a :: U) (b :: U) = FalseSym0
+    instance PEq (KProxy :: KProxy U) where
+      type (:==) (a :: U) (b :: U) = Equals_0123456789 a b
+    type BOOLSym0 = BOOL
+    type STRINGSym0 = STRING
+    type NATSym0 = NAT
+    type VECSym2 (t :: U) (t :: Nat) = VEC t t
+    instance SuppressUnusedWarnings VECSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) VECSym1KindInference GHC.Tuple.())
+    data VECSym1 (l :: U) (l :: TyFun Nat U)
+      = forall arg. KindOf (Apply (VECSym1 l) arg) ~ KindOf (VECSym2 l arg) =>
+        VECSym1KindInference
+    type instance Apply (VECSym1 l) l = VECSym2 l l
+    instance SuppressUnusedWarnings VECSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) VECSym0KindInference GHC.Tuple.())
+    data VECSym0 (l :: TyFun U (TyFun Nat U -> *))
+      = forall arg. KindOf (Apply VECSym0 arg) ~ KindOf (VECSym1 arg) =>
+        VECSym0KindInference
+    type instance Apply VECSym0 l = VECSym1 l
+    type family Equals_0123456789 (a :: AChar)
+                                  (b :: AChar) :: Bool where
+      Equals_0123456789 CA CA = TrueSym0
+      Equals_0123456789 CB CB = TrueSym0
+      Equals_0123456789 CC CC = TrueSym0
+      Equals_0123456789 CD CD = TrueSym0
+      Equals_0123456789 CE CE = TrueSym0
+      Equals_0123456789 CF CF = TrueSym0
+      Equals_0123456789 CG CG = TrueSym0
+      Equals_0123456789 CH CH = TrueSym0
+      Equals_0123456789 CI CI = TrueSym0
+      Equals_0123456789 CJ CJ = TrueSym0
+      Equals_0123456789 CK CK = TrueSym0
+      Equals_0123456789 CL CL = TrueSym0
+      Equals_0123456789 CM CM = TrueSym0
+      Equals_0123456789 CN CN = TrueSym0
+      Equals_0123456789 CO CO = TrueSym0
+      Equals_0123456789 CP CP = TrueSym0
+      Equals_0123456789 CQ CQ = TrueSym0
+      Equals_0123456789 CR CR = TrueSym0
+      Equals_0123456789 CS CS = TrueSym0
+      Equals_0123456789 CT CT = TrueSym0
+      Equals_0123456789 CU CU = TrueSym0
+      Equals_0123456789 CV CV = TrueSym0
+      Equals_0123456789 CW CW = TrueSym0
+      Equals_0123456789 CX CX = TrueSym0
+      Equals_0123456789 CY CY = TrueSym0
+      Equals_0123456789 CZ CZ = TrueSym0
+      Equals_0123456789 (a :: AChar) (b :: AChar) = FalseSym0
+    instance PEq (KProxy :: KProxy AChar) where
+      type (:==) (a :: AChar) (b :: AChar) = Equals_0123456789 a b
+    type CASym0 = CA
+    type CBSym0 = CB
+    type CCSym0 = CC
+    type CDSym0 = CD
+    type CESym0 = CE
+    type CFSym0 = CF
+    type CGSym0 = CG
+    type CHSym0 = CH
+    type CISym0 = CI
+    type CJSym0 = CJ
+    type CKSym0 = CK
+    type CLSym0 = CL
+    type CMSym0 = CM
+    type CNSym0 = CN
+    type COSym0 = CO
+    type CPSym0 = CP
+    type CQSym0 = CQ
+    type CRSym0 = CR
+    type CSSym0 = CS
+    type CTSym0 = CT
+    type CUSym0 = CU
+    type CVSym0 = CV
+    type CWSym0 = CW
+    type CXSym0 = CX
+    type CYSym0 = CY
+    type CZSym0 = CZ
+    type AttrSym2 (t :: [AChar]) (t :: U) = Attr t t
+    instance SuppressUnusedWarnings AttrSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) AttrSym1KindInference GHC.Tuple.())
+    data AttrSym1 (l :: [AChar]) (l :: TyFun U Attribute)
+      = forall arg. KindOf (Apply (AttrSym1 l) arg) ~ KindOf (AttrSym2 l arg) =>
+        AttrSym1KindInference
+    type instance Apply (AttrSym1 l) l = AttrSym2 l l
+    instance SuppressUnusedWarnings AttrSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) AttrSym0KindInference GHC.Tuple.())
+    data AttrSym0 (l :: TyFun [AChar] (TyFun U Attribute -> *))
+      = forall arg. KindOf (Apply AttrSym0 arg) ~ KindOf (AttrSym1 arg) =>
+        AttrSym0KindInference
+    type instance Apply AttrSym0 l = AttrSym1 l
+    type SchSym1 (t :: [Attribute]) = Sch t
+    instance SuppressUnusedWarnings SchSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SchSym0KindInference GHC.Tuple.())
+    data SchSym0 (l :: TyFun [Attribute] Schema)
+      = forall arg. KindOf (Apply SchSym0 arg) ~ KindOf (SchSym1 arg) =>
+        SchSym0KindInference
+    type instance Apply SchSym0 l = SchSym1 l
+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
+        Let0123456789Scrutinee_0123456789 t t t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>
+        Let0123456789Scrutinee_0123456789Sym3KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>
+        Let0123456789Scrutinee_0123456789Sym2KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
+        Let0123456789Scrutinee_0123456789Sym1KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 name
+                                                  name'
+                                                  u
+                                                  attrs where
+      Let0123456789Scrutinee_0123456789 name name' u attrs = Apply (Apply (:==$) name) name'
+    type family Case_0123456789 name name' u attrs t where
+      Case_0123456789 name name' u attrs True = u
+      Case_0123456789 name name' u attrs False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs)
+    type LookupSym2 (t :: [AChar]) (t :: Schema) = Lookup t t
+    instance SuppressUnusedWarnings LookupSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LookupSym1KindInference GHC.Tuple.())
+    data LookupSym1 (l :: [AChar]) (l :: TyFun Schema U)
+      = forall arg. KindOf (Apply (LookupSym1 l) arg) ~ KindOf (LookupSym2 l arg) =>
+        LookupSym1KindInference
+    type instance Apply (LookupSym1 l) l = LookupSym2 l l
+    instance SuppressUnusedWarnings LookupSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LookupSym0KindInference GHC.Tuple.())
+    data LookupSym0 (l :: TyFun [AChar] (TyFun Schema U -> *))
+      = forall arg. KindOf (Apply LookupSym0 arg) ~ KindOf (LookupSym1 arg) =>
+        LookupSym0KindInference
+    type instance Apply LookupSym0 l = LookupSym1 l
+    type OccursSym2 (t :: [AChar]) (t :: Schema) = Occurs t t
+    instance SuppressUnusedWarnings OccursSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) OccursSym1KindInference GHC.Tuple.())
+    data OccursSym1 (l :: [AChar]) (l :: TyFun Schema Bool)
+      = forall arg. KindOf (Apply (OccursSym1 l) arg) ~ KindOf (OccursSym2 l arg) =>
+        OccursSym1KindInference
+    type instance Apply (OccursSym1 l) l = OccursSym2 l l
+    instance SuppressUnusedWarnings OccursSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) OccursSym0KindInference GHC.Tuple.())
+    data OccursSym0 (l :: TyFun [AChar] (TyFun Schema Bool -> *))
+      = forall arg. KindOf (Apply OccursSym0 arg) ~ KindOf (OccursSym1 arg) =>
+        OccursSym0KindInference
+    type instance Apply OccursSym0 l = OccursSym1 l
+    type AttrNotInSym2 (t :: Attribute) (t :: Schema) = AttrNotIn t t
+    instance SuppressUnusedWarnings AttrNotInSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) AttrNotInSym1KindInference GHC.Tuple.())
+    data AttrNotInSym1 (l :: Attribute) (l :: TyFun Schema Bool)
+      = forall arg. KindOf (Apply (AttrNotInSym1 l) arg) ~ KindOf (AttrNotInSym2 l arg) =>
+        AttrNotInSym1KindInference
+    type instance Apply (AttrNotInSym1 l) l = AttrNotInSym2 l l
+    instance SuppressUnusedWarnings AttrNotInSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) AttrNotInSym0KindInference GHC.Tuple.())
+    data AttrNotInSym0 (l :: TyFun Attribute (TyFun Schema Bool -> *))
+      = forall arg. KindOf (Apply AttrNotInSym0 arg) ~ KindOf (AttrNotInSym1 arg) =>
+        AttrNotInSym0KindInference
+    type instance Apply AttrNotInSym0 l = AttrNotInSym1 l
+    type DisjointSym2 (t :: Schema) (t :: Schema) = Disjoint t t
+    instance SuppressUnusedWarnings DisjointSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) DisjointSym1KindInference GHC.Tuple.())
+    data DisjointSym1 (l :: Schema) (l :: TyFun Schema Bool)
+      = forall arg. KindOf (Apply (DisjointSym1 l) arg) ~ KindOf (DisjointSym2 l arg) =>
+        DisjointSym1KindInference
+    type instance Apply (DisjointSym1 l) l = DisjointSym2 l l
+    instance SuppressUnusedWarnings DisjointSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) DisjointSym0KindInference GHC.Tuple.())
+    data DisjointSym0 (l :: TyFun Schema (TyFun Schema Bool -> *))
+      = forall arg. KindOf (Apply DisjointSym0 arg) ~ KindOf (DisjointSym1 arg) =>
+        DisjointSym0KindInference
+    type instance Apply DisjointSym0 l = DisjointSym1 l
+    type AppendSym2 (t :: Schema) (t :: Schema) = Append t t
+    instance SuppressUnusedWarnings AppendSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) AppendSym1KindInference GHC.Tuple.())
+    data AppendSym1 (l :: Schema) (l :: TyFun Schema Schema)
+      = forall arg. KindOf (Apply (AppendSym1 l) arg) ~ KindOf (AppendSym2 l arg) =>
+        AppendSym1KindInference
+    type instance Apply (AppendSym1 l) l = AppendSym2 l l
+    instance SuppressUnusedWarnings AppendSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) AppendSym0KindInference GHC.Tuple.())
+    data AppendSym0 (l :: TyFun Schema (TyFun Schema Schema -> *))
+      = forall arg. KindOf (Apply AppendSym0 arg) ~ KindOf (AppendSym1 arg) =>
+        AppendSym0KindInference
+    type instance Apply AppendSym0 l = AppendSym1 l
+    type family Lookup (a :: [AChar]) (a :: Schema) :: U where
+      Lookup _z_0123456789 (Sch '[]) = Any
+      Lookup name (Sch ((:) (Attr name' u) attrs)) = Case_0123456789 name name' u attrs (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs)
+    type family Occurs (a :: [AChar]) (a :: Schema) :: Bool where
+      Occurs _z_0123456789 (Sch '[]) = FalseSym0
+      Occurs name (Sch ((:) (Attr name' _z_0123456789) attrs)) = Apply (Apply (:||$) (Apply (Apply (:==$) name) name')) (Apply (Apply OccursSym0 name) (Apply SchSym0 attrs))
+    type family AttrNotIn (a :: Attribute) (a :: Schema) :: Bool where
+      AttrNotIn _z_0123456789 (Sch '[]) = TrueSym0
+      AttrNotIn (Attr name u) (Sch ((:) (Attr name' _z_0123456789) t)) = Apply (Apply (:&&$) (Apply (Apply (:/=$) name) name')) (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 t))
+    type family Disjoint (a :: Schema) (a :: Schema) :: Bool where
+      Disjoint (Sch '[]) _z_0123456789 = TrueSym0
+      Disjoint (Sch ((:) h t)) s = Apply (Apply (:&&$) (Apply (Apply AttrNotInSym0 h) s)) (Apply (Apply DisjointSym0 (Apply SchSym0 t)) s)
+    type family Append (a :: Schema) (a :: Schema) :: Schema where
+      Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (:++$) s1) s2)
+    sLookup ::
+      forall (t :: [AChar]) (t :: Schema).
+      Sing t -> Sing t -> Sing (Apply (Apply LookupSym0 t) t :: U)
+    sOccurs ::
+      forall (t :: [AChar]) (t :: Schema).
+      Sing t -> Sing t -> Sing (Apply (Apply OccursSym0 t) t :: Bool)
+    sAttrNotIn ::
+      forall (t :: Attribute) (t :: Schema).
+      Sing t -> Sing t -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool)
+    sDisjoint ::
+      forall (t :: Schema) (t :: Schema).
+      Sing t -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t :: Bool)
+    sAppend ::
+      forall (t :: Schema) (t :: Schema).
+      Sing t -> Sing t -> Sing (Apply (Apply AppendSym0 t) t :: Schema)
+    sLookup _s_z_0123456789 (SSch SNil)
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ _z_0123456789, t ~ Apply SchSym0 '[]) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply LookupSym0 _z_0123456789) (Apply SchSym0 '[]) :: U)
+          lambda _z_0123456789 = undefined
+        in lambda _s_z_0123456789
+    sLookup sName (SSch (SCons (SAttr sName' sU) sAttrs))
+      = let
+          lambda ::
+            forall name name' u attrs. (t ~ name,
+                                        t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') u)) attrs)) =>
+            Sing name
+            -> Sing name'
+               -> Sing u
+                  -> Sing attrs
+                     -> Sing (Apply (Apply LookupSym0 name) (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') u)) attrs)) :: U)
+          lambda name name' u attrs
+            = let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs)
+                sScrutinee_0123456789
+                  = applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) name) name'
+              in  case sScrutinee_0123456789 of {
+                    STrue
+                      -> let
+                           lambda ::
+                             TrueSym0 ~ Let0123456789Scrutinee_0123456789Sym4 name name' u attrs =>
+                             Sing (Case_0123456789 name name' u attrs TrueSym0)
+                           lambda = u
+                         in lambda
+                    SFalse
+                      -> let
+                           lambda ::
+                             FalseSym0 ~ Let0123456789Scrutinee_0123456789Sym4 name name' u attrs =>
+                             Sing (Case_0123456789 name name' u attrs FalseSym0)
+                           lambda
+                             = applySing
+                                 (applySing (singFun2 (Proxy :: Proxy LookupSym0) sLookup) name)
+                                 (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) attrs)
+                         in lambda } ::
+                    Sing (Case_0123456789 name name' u attrs (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs))
+        in lambda sName sName' sU sAttrs
+    sOccurs _s_z_0123456789 (SSch SNil)
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ _z_0123456789, t ~ Apply SchSym0 '[]) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply OccursSym0 _z_0123456789) (Apply SchSym0 '[]) :: Bool)
+          lambda _z_0123456789 = SFalse
+        in lambda _s_z_0123456789
+    sOccurs sName (SSch (SCons (SAttr sName' _s_z_0123456789) sAttrs))
+      = let
+          lambda ::
+            forall name name' _z_0123456789 attrs. (t ~ name,
+                                                    t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') _z_0123456789)) attrs)) =>
+            Sing name
+            -> Sing name'
+               -> Sing _z_0123456789
+                  -> Sing attrs
+                     -> Sing (Apply (Apply OccursSym0 name) (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') _z_0123456789)) attrs)) :: Bool)
+          lambda name name' _z_0123456789 attrs
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:||$)) (%:||))
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) name) name'))
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy OccursSym0) sOccurs) name)
+                   (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) attrs))
+        in lambda sName sName' _s_z_0123456789 sAttrs
+    sAttrNotIn _s_z_0123456789 (SSch SNil)
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ _z_0123456789, t ~ Apply SchSym0 '[]) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply AttrNotInSym0 _z_0123456789) (Apply SchSym0 '[]) :: Bool)
+          lambda _z_0123456789 = STrue
+        in lambda _s_z_0123456789
+    sAttrNotIn
+      (SAttr sName sU)
+      (SSch (SCons (SAttr sName' _s_z_0123456789) sT))
+      = let
+          lambda ::
+            forall name
+                   u
+                   name'
+                   _z_0123456789
+                   t. (t ~ Apply (Apply AttrSym0 name) u,
+                       t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') _z_0123456789)) t)) =>
+            Sing name
+            -> Sing u
+               -> Sing name'
+                  -> Sing _z_0123456789
+                     -> Sing t
+                        -> Sing (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') _z_0123456789)) t)) :: Bool)
+          lambda name u name' _z_0123456789 t
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:&&$)) (%:&&))
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:/=$)) (%:/=)) name) name'))
+                (applySing
+                   (applySing
+                      (singFun2 (Proxy :: Proxy AttrNotInSym0) sAttrNotIn)
+                      (applySing
+                         (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) name) u))
+                   (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) t))
+        in lambda sName sU sName' _s_z_0123456789 sT
+    sDisjoint (SSch SNil) _s_z_0123456789
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ Apply SchSym0 '[], t ~ _z_0123456789) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply DisjointSym0 (Apply SchSym0 '[])) _z_0123456789 :: Bool)
+          lambda _z_0123456789 = STrue
+        in lambda _s_z_0123456789
+    sDisjoint (SSch (SCons sH sT)) sS
+      = let
+          lambda ::
+            forall h t s. (t ~ Apply SchSym0 (Apply (Apply (:$) h) t),
+                           t ~ s) =>
+            Sing h
+            -> Sing t
+               -> Sing s
+                  -> Sing (Apply (Apply DisjointSym0 (Apply SchSym0 (Apply (Apply (:$) h) t))) s :: Bool)
+          lambda h t s
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:&&$)) (%:&&))
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy AttrNotInSym0) sAttrNotIn) h)
+                      s))
+                (applySing
+                   (applySing
+                      (singFun2 (Proxy :: Proxy DisjointSym0) sDisjoint)
+                      (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) t))
+                   s)
+        in lambda sH sT sS
+    sAppend (SSch sS1) (SSch sS2)
+      = let
+          lambda ::
+            forall s1 s2. (t ~ Apply SchSym0 s1, t ~ Apply SchSym0 s2) =>
+            Sing s1
+            -> Sing s2
+               -> Sing (Apply (Apply AppendSym0 (Apply SchSym0 s1)) (Apply SchSym0 s2) :: Schema)
+          lambda s1 s2
+            = applySing
+                (singFun1 (Proxy :: Proxy SchSym0) SSch)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy (:++$)) (%:++)) s1) s2)
+        in lambda sS1 sS2
+    data instance Sing (z :: U)
+      = z ~ BOOL => SBOOL |
+        z ~ STRING => SSTRING |
+        z ~ NAT => SNAT |
+        forall (n :: U) (n :: Nat). z ~ VEC n n =>
+        SVEC (Sing (n :: U)) (Sing (n :: Nat))
+    type SU = (Sing :: U -> *)
+    instance SingKind (KProxy :: KProxy U) where
+      type DemoteRep (KProxy :: KProxy U) = U
+      fromSing SBOOL = BOOL
+      fromSing SSTRING = STRING
+      fromSing SNAT = NAT
+      fromSing (SVEC b b) = VEC (fromSing b) (fromSing b)
+      toSing BOOL = SomeSing SBOOL
+      toSing STRING = SomeSing SSTRING
+      toSing NAT = SomeSing SNAT
+      toSing (VEC b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy U))
+                (toSing b :: SomeSing (KProxy :: KProxy Nat))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SVEC c c) }
+    instance SEq (KProxy :: KProxy U) where
+      (%:==) SBOOL SBOOL = STrue
+      (%:==) SBOOL SSTRING = SFalse
+      (%:==) SBOOL SNAT = SFalse
+      (%:==) SBOOL (SVEC _ _) = SFalse
+      (%:==) SSTRING SBOOL = SFalse
+      (%:==) SSTRING SSTRING = STrue
+      (%:==) SSTRING SNAT = SFalse
+      (%:==) SSTRING (SVEC _ _) = SFalse
+      (%:==) SNAT SBOOL = SFalse
+      (%:==) SNAT SSTRING = SFalse
+      (%:==) SNAT SNAT = STrue
+      (%:==) SNAT (SVEC _ _) = SFalse
+      (%:==) (SVEC _ _) SBOOL = SFalse
+      (%:==) (SVEC _ _) SSTRING = SFalse
+      (%:==) (SVEC _ _) SNAT = SFalse
+      (%:==) (SVEC a a) (SVEC b b) = (%:&&) ((%:==) a b) ((%:==) a b)
+    instance SDecide (KProxy :: KProxy U) where
+      (%~) SBOOL SBOOL = Proved Refl
+      (%~) SBOOL SSTRING
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SBOOL SNAT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SBOOL (SVEC _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SSTRING SBOOL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SSTRING SSTRING = Proved Refl
+      (%~) SSTRING SNAT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SSTRING (SVEC _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SNAT SBOOL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SNAT SSTRING
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SNAT SNAT = Proved Refl
+      (%~) SNAT (SVEC _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVEC _ _) SBOOL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVEC _ _) SSTRING
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVEC _ _) SNAT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVEC a a) (SVEC b b)
+        = case GHC.Tuple.(,) ((%~) a b) ((%~) a b) of {
+            GHC.Tuple.(,) (Proved Refl) (Proved Refl) -> Proved Refl
+            GHC.Tuple.(,) (Disproved contra) _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,) _ (Disproved contra)
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+    data instance Sing (z :: AChar)
+      = z ~ CA => SCA |
+        z ~ CB => SCB |
+        z ~ CC => SCC |
+        z ~ CD => SCD |
+        z ~ CE => SCE |
+        z ~ CF => SCF |
+        z ~ CG => SCG |
+        z ~ CH => SCH |
+        z ~ CI => SCI |
+        z ~ CJ => SCJ |
+        z ~ CK => SCK |
+        z ~ CL => SCL |
+        z ~ CM => SCM |
+        z ~ CN => SCN |
+        z ~ CO => SCO |
+        z ~ CP => SCP |
+        z ~ CQ => SCQ |
+        z ~ CR => SCR |
+        z ~ CS => SCS |
+        z ~ CT => SCT |
+        z ~ CU => SCU |
+        z ~ CV => SCV |
+        z ~ CW => SCW |
+        z ~ CX => SCX |
+        z ~ CY => SCY |
+        z ~ CZ => SCZ
+    type SAChar = (Sing :: AChar -> *)
+    instance SingKind (KProxy :: KProxy AChar) where
+      type DemoteRep (KProxy :: KProxy AChar) = AChar
+      fromSing SCA = CA
+      fromSing SCB = CB
+      fromSing SCC = CC
+      fromSing SCD = CD
+      fromSing SCE = CE
+      fromSing SCF = CF
+      fromSing SCG = CG
+      fromSing SCH = CH
+      fromSing SCI = CI
+      fromSing SCJ = CJ
+      fromSing SCK = CK
+      fromSing SCL = CL
+      fromSing SCM = CM
+      fromSing SCN = CN
+      fromSing SCO = CO
+      fromSing SCP = CP
+      fromSing SCQ = CQ
+      fromSing SCR = CR
+      fromSing SCS = CS
+      fromSing SCT = CT
+      fromSing SCU = CU
+      fromSing SCV = CV
+      fromSing SCW = CW
+      fromSing SCX = CX
+      fromSing SCY = CY
+      fromSing SCZ = CZ
+      toSing CA = SomeSing SCA
+      toSing CB = SomeSing SCB
+      toSing CC = SomeSing SCC
+      toSing CD = SomeSing SCD
+      toSing CE = SomeSing SCE
+      toSing CF = SomeSing SCF
+      toSing CG = SomeSing SCG
+      toSing CH = SomeSing SCH
+      toSing CI = SomeSing SCI
+      toSing CJ = SomeSing SCJ
+      toSing CK = SomeSing SCK
+      toSing CL = SomeSing SCL
+      toSing CM = SomeSing SCM
+      toSing CN = SomeSing SCN
+      toSing CO = SomeSing SCO
+      toSing CP = SomeSing SCP
+      toSing CQ = SomeSing SCQ
+      toSing CR = SomeSing SCR
+      toSing CS = SomeSing SCS
+      toSing CT = SomeSing SCT
+      toSing CU = SomeSing SCU
+      toSing CV = SomeSing SCV
+      toSing CW = SomeSing SCW
+      toSing CX = SomeSing SCX
+      toSing CY = SomeSing SCY
+      toSing CZ = SomeSing SCZ
+    instance SEq (KProxy :: KProxy AChar) where
+      (%:==) SCA SCA = STrue
+      (%:==) SCA SCB = SFalse
+      (%:==) SCA SCC = SFalse
+      (%:==) SCA SCD = SFalse
+      (%:==) SCA SCE = SFalse
+      (%:==) SCA SCF = SFalse
+      (%:==) SCA SCG = SFalse
+      (%:==) SCA SCH = SFalse
+      (%:==) SCA SCI = SFalse
+      (%:==) SCA SCJ = SFalse
+      (%:==) SCA SCK = SFalse
+      (%:==) SCA SCL = SFalse
+      (%:==) SCA SCM = SFalse
+      (%:==) SCA SCN = SFalse
+      (%:==) SCA SCO = SFalse
+      (%:==) SCA SCP = SFalse
+      (%:==) SCA SCQ = SFalse
+      (%:==) SCA SCR = SFalse
+      (%:==) SCA SCS = SFalse
+      (%:==) SCA SCT = SFalse
+      (%:==) SCA SCU = SFalse
+      (%:==) SCA SCV = SFalse
+      (%:==) SCA SCW = SFalse
+      (%:==) SCA SCX = SFalse
+      (%:==) SCA SCY = SFalse
+      (%:==) SCA SCZ = SFalse
+      (%:==) SCB SCA = SFalse
+      (%:==) SCB SCB = STrue
+      (%:==) SCB SCC = SFalse
+      (%:==) SCB SCD = SFalse
+      (%:==) SCB SCE = SFalse
+      (%:==) SCB SCF = SFalse
+      (%:==) SCB SCG = SFalse
+      (%:==) SCB SCH = SFalse
+      (%:==) SCB SCI = SFalse
+      (%:==) SCB SCJ = SFalse
+      (%:==) SCB SCK = SFalse
+      (%:==) SCB SCL = SFalse
+      (%:==) SCB SCM = SFalse
+      (%:==) SCB SCN = SFalse
+      (%:==) SCB SCO = SFalse
+      (%:==) SCB SCP = SFalse
+      (%:==) SCB SCQ = SFalse
+      (%:==) SCB SCR = SFalse
+      (%:==) SCB SCS = SFalse
+      (%:==) SCB SCT = SFalse
+      (%:==) SCB SCU = SFalse
+      (%:==) SCB SCV = SFalse
+      (%:==) SCB SCW = SFalse
+      (%:==) SCB SCX = SFalse
+      (%:==) SCB SCY = SFalse
+      (%:==) SCB SCZ = SFalse
+      (%:==) SCC SCA = SFalse
+      (%:==) SCC SCB = SFalse
+      (%:==) SCC SCC = STrue
+      (%:==) SCC SCD = SFalse
+      (%:==) SCC SCE = SFalse
+      (%:==) SCC SCF = SFalse
+      (%:==) SCC SCG = SFalse
+      (%:==) SCC SCH = SFalse
+      (%:==) SCC SCI = SFalse
+      (%:==) SCC SCJ = SFalse
+      (%:==) SCC SCK = SFalse
+      (%:==) SCC SCL = SFalse
+      (%:==) SCC SCM = SFalse
+      (%:==) SCC SCN = SFalse
+      (%:==) SCC SCO = SFalse
+      (%:==) SCC SCP = SFalse
+      (%:==) SCC SCQ = SFalse
+      (%:==) SCC SCR = SFalse
+      (%:==) SCC SCS = SFalse
+      (%:==) SCC SCT = SFalse
+      (%:==) SCC SCU = SFalse
+      (%:==) SCC SCV = SFalse
+      (%:==) SCC SCW = SFalse
+      (%:==) SCC SCX = SFalse
+      (%:==) SCC SCY = SFalse
+      (%:==) SCC SCZ = SFalse
+      (%:==) SCD SCA = SFalse
+      (%:==) SCD SCB = SFalse
+      (%:==) SCD SCC = SFalse
+      (%:==) SCD SCD = STrue
+      (%:==) SCD SCE = SFalse
+      (%:==) SCD SCF = SFalse
+      (%:==) SCD SCG = SFalse
+      (%:==) SCD SCH = SFalse
+      (%:==) SCD SCI = SFalse
+      (%:==) SCD SCJ = SFalse
+      (%:==) SCD SCK = SFalse
+      (%:==) SCD SCL = SFalse
+      (%:==) SCD SCM = SFalse
+      (%:==) SCD SCN = SFalse
+      (%:==) SCD SCO = SFalse
+      (%:==) SCD SCP = SFalse
+      (%:==) SCD SCQ = SFalse
+      (%:==) SCD SCR = SFalse
+      (%:==) SCD SCS = SFalse
+      (%:==) SCD SCT = SFalse
+      (%:==) SCD SCU = SFalse
+      (%:==) SCD SCV = SFalse
+      (%:==) SCD SCW = SFalse
+      (%:==) SCD SCX = SFalse
+      (%:==) SCD SCY = SFalse
+      (%:==) SCD SCZ = SFalse
+      (%:==) SCE SCA = SFalse
+      (%:==) SCE SCB = SFalse
+      (%:==) SCE SCC = SFalse
+      (%:==) SCE SCD = SFalse
+      (%:==) SCE SCE = STrue
+      (%:==) SCE SCF = SFalse
+      (%:==) SCE SCG = SFalse
+      (%:==) SCE SCH = SFalse
+      (%:==) SCE SCI = SFalse
+      (%:==) SCE SCJ = SFalse
+      (%:==) SCE SCK = SFalse
+      (%:==) SCE SCL = SFalse
+      (%:==) SCE SCM = SFalse
+      (%:==) SCE SCN = SFalse
+      (%:==) SCE SCO = SFalse
+      (%:==) SCE SCP = SFalse
+      (%:==) SCE SCQ = SFalse
+      (%:==) SCE SCR = SFalse
+      (%:==) SCE SCS = SFalse
+      (%:==) SCE SCT = SFalse
+      (%:==) SCE SCU = SFalse
+      (%:==) SCE SCV = SFalse
+      (%:==) SCE SCW = SFalse
+      (%:==) SCE SCX = SFalse
+      (%:==) SCE SCY = SFalse
+      (%:==) SCE SCZ = SFalse
+      (%:==) SCF SCA = SFalse
+      (%:==) SCF SCB = SFalse
+      (%:==) SCF SCC = SFalse
+      (%:==) SCF SCD = SFalse
+      (%:==) SCF SCE = SFalse
+      (%:==) SCF SCF = STrue
+      (%:==) SCF SCG = SFalse
+      (%:==) SCF SCH = SFalse
+      (%:==) SCF SCI = SFalse
+      (%:==) SCF SCJ = SFalse
+      (%:==) SCF SCK = SFalse
+      (%:==) SCF SCL = SFalse
+      (%:==) SCF SCM = SFalse
+      (%:==) SCF SCN = SFalse
+      (%:==) SCF SCO = SFalse
+      (%:==) SCF SCP = SFalse
+      (%:==) SCF SCQ = SFalse
+      (%:==) SCF SCR = SFalse
+      (%:==) SCF SCS = SFalse
+      (%:==) SCF SCT = SFalse
+      (%:==) SCF SCU = SFalse
+      (%:==) SCF SCV = SFalse
+      (%:==) SCF SCW = SFalse
+      (%:==) SCF SCX = SFalse
+      (%:==) SCF SCY = SFalse
+      (%:==) SCF SCZ = SFalse
+      (%:==) SCG SCA = SFalse
+      (%:==) SCG SCB = SFalse
+      (%:==) SCG SCC = SFalse
+      (%:==) SCG SCD = SFalse
+      (%:==) SCG SCE = SFalse
+      (%:==) SCG SCF = SFalse
+      (%:==) SCG SCG = STrue
+      (%:==) SCG SCH = SFalse
+      (%:==) SCG SCI = SFalse
+      (%:==) SCG SCJ = SFalse
+      (%:==) SCG SCK = SFalse
+      (%:==) SCG SCL = SFalse
+      (%:==) SCG SCM = SFalse
+      (%:==) SCG SCN = SFalse
+      (%:==) SCG SCO = SFalse
+      (%:==) SCG SCP = SFalse
+      (%:==) SCG SCQ = SFalse
+      (%:==) SCG SCR = SFalse
+      (%:==) SCG SCS = SFalse
+      (%:==) SCG SCT = SFalse
+      (%:==) SCG SCU = SFalse
+      (%:==) SCG SCV = SFalse
+      (%:==) SCG SCW = SFalse
+      (%:==) SCG SCX = SFalse
+      (%:==) SCG SCY = SFalse
+      (%:==) SCG SCZ = SFalse
+      (%:==) SCH SCA = SFalse
+      (%:==) SCH SCB = SFalse
+      (%:==) SCH SCC = SFalse
+      (%:==) SCH SCD = SFalse
+      (%:==) SCH SCE = SFalse
+      (%:==) SCH SCF = SFalse
+      (%:==) SCH SCG = SFalse
+      (%:==) SCH SCH = STrue
+      (%:==) SCH SCI = SFalse
+      (%:==) SCH SCJ = SFalse
+      (%:==) SCH SCK = SFalse
+      (%:==) SCH SCL = SFalse
+      (%:==) SCH SCM = SFalse
+      (%:==) SCH SCN = SFalse
+      (%:==) SCH SCO = SFalse
+      (%:==) SCH SCP = SFalse
+      (%:==) SCH SCQ = SFalse
+      (%:==) SCH SCR = SFalse
+      (%:==) SCH SCS = SFalse
+      (%:==) SCH SCT = SFalse
+      (%:==) SCH SCU = SFalse
+      (%:==) SCH SCV = SFalse
+      (%:==) SCH SCW = SFalse
+      (%:==) SCH SCX = SFalse
+      (%:==) SCH SCY = SFalse
+      (%:==) SCH SCZ = SFalse
+      (%:==) SCI SCA = SFalse
+      (%:==) SCI SCB = SFalse
+      (%:==) SCI SCC = SFalse
+      (%:==) SCI SCD = SFalse
+      (%:==) SCI SCE = SFalse
+      (%:==) SCI SCF = SFalse
+      (%:==) SCI SCG = SFalse
+      (%:==) SCI SCH = SFalse
+      (%:==) SCI SCI = STrue
+      (%:==) SCI SCJ = SFalse
+      (%:==) SCI SCK = SFalse
+      (%:==) SCI SCL = SFalse
+      (%:==) SCI SCM = SFalse
+      (%:==) SCI SCN = SFalse
+      (%:==) SCI SCO = SFalse
+      (%:==) SCI SCP = SFalse
+      (%:==) SCI SCQ = SFalse
+      (%:==) SCI SCR = SFalse
+      (%:==) SCI SCS = SFalse
+      (%:==) SCI SCT = SFalse
+      (%:==) SCI SCU = SFalse
+      (%:==) SCI SCV = SFalse
+      (%:==) SCI SCW = SFalse
+      (%:==) SCI SCX = SFalse
+      (%:==) SCI SCY = SFalse
+      (%:==) SCI SCZ = SFalse
+      (%:==) SCJ SCA = SFalse
+      (%:==) SCJ SCB = SFalse
+      (%:==) SCJ SCC = SFalse
+      (%:==) SCJ SCD = SFalse
+      (%:==) SCJ SCE = SFalse
+      (%:==) SCJ SCF = SFalse
+      (%:==) SCJ SCG = SFalse
+      (%:==) SCJ SCH = SFalse
+      (%:==) SCJ SCI = SFalse
+      (%:==) SCJ SCJ = STrue
+      (%:==) SCJ SCK = SFalse
+      (%:==) SCJ SCL = SFalse
+      (%:==) SCJ SCM = SFalse
+      (%:==) SCJ SCN = SFalse
+      (%:==) SCJ SCO = SFalse
+      (%:==) SCJ SCP = SFalse
+      (%:==) SCJ SCQ = SFalse
+      (%:==) SCJ SCR = SFalse
+      (%:==) SCJ SCS = SFalse
+      (%:==) SCJ SCT = SFalse
+      (%:==) SCJ SCU = SFalse
+      (%:==) SCJ SCV = SFalse
+      (%:==) SCJ SCW = SFalse
+      (%:==) SCJ SCX = SFalse
+      (%:==) SCJ SCY = SFalse
+      (%:==) SCJ SCZ = SFalse
+      (%:==) SCK SCA = SFalse
+      (%:==) SCK SCB = SFalse
+      (%:==) SCK SCC = SFalse
+      (%:==) SCK SCD = SFalse
+      (%:==) SCK SCE = SFalse
+      (%:==) SCK SCF = SFalse
+      (%:==) SCK SCG = SFalse
+      (%:==) SCK SCH = SFalse
+      (%:==) SCK SCI = SFalse
+      (%:==) SCK SCJ = SFalse
+      (%:==) SCK SCK = STrue
+      (%:==) SCK SCL = SFalse
+      (%:==) SCK SCM = SFalse
+      (%:==) SCK SCN = SFalse
+      (%:==) SCK SCO = SFalse
+      (%:==) SCK SCP = SFalse
+      (%:==) SCK SCQ = SFalse
+      (%:==) SCK SCR = SFalse
+      (%:==) SCK SCS = SFalse
+      (%:==) SCK SCT = SFalse
+      (%:==) SCK SCU = SFalse
+      (%:==) SCK SCV = SFalse
+      (%:==) SCK SCW = SFalse
+      (%:==) SCK SCX = SFalse
+      (%:==) SCK SCY = SFalse
+      (%:==) SCK SCZ = SFalse
+      (%:==) SCL SCA = SFalse
+      (%:==) SCL SCB = SFalse
+      (%:==) SCL SCC = SFalse
+      (%:==) SCL SCD = SFalse
+      (%:==) SCL SCE = SFalse
+      (%:==) SCL SCF = SFalse
+      (%:==) SCL SCG = SFalse
+      (%:==) SCL SCH = SFalse
+      (%:==) SCL SCI = SFalse
+      (%:==) SCL SCJ = SFalse
+      (%:==) SCL SCK = SFalse
+      (%:==) SCL SCL = STrue
+      (%:==) SCL SCM = SFalse
+      (%:==) SCL SCN = SFalse
+      (%:==) SCL SCO = SFalse
+      (%:==) SCL SCP = SFalse
+      (%:==) SCL SCQ = SFalse
+      (%:==) SCL SCR = SFalse
+      (%:==) SCL SCS = SFalse
+      (%:==) SCL SCT = SFalse
+      (%:==) SCL SCU = SFalse
+      (%:==) SCL SCV = SFalse
+      (%:==) SCL SCW = SFalse
+      (%:==) SCL SCX = SFalse
+      (%:==) SCL SCY = SFalse
+      (%:==) SCL SCZ = SFalse
+      (%:==) SCM SCA = SFalse
+      (%:==) SCM SCB = SFalse
+      (%:==) SCM SCC = SFalse
+      (%:==) SCM SCD = SFalse
+      (%:==) SCM SCE = SFalse
+      (%:==) SCM SCF = SFalse
+      (%:==) SCM SCG = SFalse
+      (%:==) SCM SCH = SFalse
+      (%:==) SCM SCI = SFalse
+      (%:==) SCM SCJ = SFalse
+      (%:==) SCM SCK = SFalse
+      (%:==) SCM SCL = SFalse
+      (%:==) SCM SCM = STrue
+      (%:==) SCM SCN = SFalse
+      (%:==) SCM SCO = SFalse
+      (%:==) SCM SCP = SFalse
+      (%:==) SCM SCQ = SFalse
+      (%:==) SCM SCR = SFalse
+      (%:==) SCM SCS = SFalse
+      (%:==) SCM SCT = SFalse
+      (%:==) SCM SCU = SFalse
+      (%:==) SCM SCV = SFalse
+      (%:==) SCM SCW = SFalse
+      (%:==) SCM SCX = SFalse
+      (%:==) SCM SCY = SFalse
+      (%:==) SCM SCZ = SFalse
+      (%:==) SCN SCA = SFalse
+      (%:==) SCN SCB = SFalse
+      (%:==) SCN SCC = SFalse
+      (%:==) SCN SCD = SFalse
+      (%:==) SCN SCE = SFalse
+      (%:==) SCN SCF = SFalse
+      (%:==) SCN SCG = SFalse
+      (%:==) SCN SCH = SFalse
+      (%:==) SCN SCI = SFalse
+      (%:==) SCN SCJ = SFalse
+      (%:==) SCN SCK = SFalse
+      (%:==) SCN SCL = SFalse
+      (%:==) SCN SCM = SFalse
+      (%:==) SCN SCN = STrue
+      (%:==) SCN SCO = SFalse
+      (%:==) SCN SCP = SFalse
+      (%:==) SCN SCQ = SFalse
+      (%:==) SCN SCR = SFalse
+      (%:==) SCN SCS = SFalse
+      (%:==) SCN SCT = SFalse
+      (%:==) SCN SCU = SFalse
+      (%:==) SCN SCV = SFalse
+      (%:==) SCN SCW = SFalse
+      (%:==) SCN SCX = SFalse
+      (%:==) SCN SCY = SFalse
+      (%:==) SCN SCZ = SFalse
+      (%:==) SCO SCA = SFalse
+      (%:==) SCO SCB = SFalse
+      (%:==) SCO SCC = SFalse
+      (%:==) SCO SCD = SFalse
+      (%:==) SCO SCE = SFalse
+      (%:==) SCO SCF = SFalse
+      (%:==) SCO SCG = SFalse
+      (%:==) SCO SCH = SFalse
+      (%:==) SCO SCI = SFalse
+      (%:==) SCO SCJ = SFalse
+      (%:==) SCO SCK = SFalse
+      (%:==) SCO SCL = SFalse
+      (%:==) SCO SCM = SFalse
+      (%:==) SCO SCN = SFalse
+      (%:==) SCO SCO = STrue
+      (%:==) SCO SCP = SFalse
+      (%:==) SCO SCQ = SFalse
+      (%:==) SCO SCR = SFalse
+      (%:==) SCO SCS = SFalse
+      (%:==) SCO SCT = SFalse
+      (%:==) SCO SCU = SFalse
+      (%:==) SCO SCV = SFalse
+      (%:==) SCO SCW = SFalse
+      (%:==) SCO SCX = SFalse
+      (%:==) SCO SCY = SFalse
+      (%:==) SCO SCZ = SFalse
+      (%:==) SCP SCA = SFalse
+      (%:==) SCP SCB = SFalse
+      (%:==) SCP SCC = SFalse
+      (%:==) SCP SCD = SFalse
+      (%:==) SCP SCE = SFalse
+      (%:==) SCP SCF = SFalse
+      (%:==) SCP SCG = SFalse
+      (%:==) SCP SCH = SFalse
+      (%:==) SCP SCI = SFalse
+      (%:==) SCP SCJ = SFalse
+      (%:==) SCP SCK = SFalse
+      (%:==) SCP SCL = SFalse
+      (%:==) SCP SCM = SFalse
+      (%:==) SCP SCN = SFalse
+      (%:==) SCP SCO = SFalse
+      (%:==) SCP SCP = STrue
+      (%:==) SCP SCQ = SFalse
+      (%:==) SCP SCR = SFalse
+      (%:==) SCP SCS = SFalse
+      (%:==) SCP SCT = SFalse
+      (%:==) SCP SCU = SFalse
+      (%:==) SCP SCV = SFalse
+      (%:==) SCP SCW = SFalse
+      (%:==) SCP SCX = SFalse
+      (%:==) SCP SCY = SFalse
+      (%:==) SCP SCZ = SFalse
+      (%:==) SCQ SCA = SFalse
+      (%:==) SCQ SCB = SFalse
+      (%:==) SCQ SCC = SFalse
+      (%:==) SCQ SCD = SFalse
+      (%:==) SCQ SCE = SFalse
+      (%:==) SCQ SCF = SFalse
+      (%:==) SCQ SCG = SFalse
+      (%:==) SCQ SCH = SFalse
+      (%:==) SCQ SCI = SFalse
+      (%:==) SCQ SCJ = SFalse
+      (%:==) SCQ SCK = SFalse
+      (%:==) SCQ SCL = SFalse
+      (%:==) SCQ SCM = SFalse
+      (%:==) SCQ SCN = SFalse
+      (%:==) SCQ SCO = SFalse
+      (%:==) SCQ SCP = SFalse
+      (%:==) SCQ SCQ = STrue
+      (%:==) SCQ SCR = SFalse
+      (%:==) SCQ SCS = SFalse
+      (%:==) SCQ SCT = SFalse
+      (%:==) SCQ SCU = SFalse
+      (%:==) SCQ SCV = SFalse
+      (%:==) SCQ SCW = SFalse
+      (%:==) SCQ SCX = SFalse
+      (%:==) SCQ SCY = SFalse
+      (%:==) SCQ SCZ = SFalse
+      (%:==) SCR SCA = SFalse
+      (%:==) SCR SCB = SFalse
+      (%:==) SCR SCC = SFalse
+      (%:==) SCR SCD = SFalse
+      (%:==) SCR SCE = SFalse
+      (%:==) SCR SCF = SFalse
+      (%:==) SCR SCG = SFalse
+      (%:==) SCR SCH = SFalse
+      (%:==) SCR SCI = SFalse
+      (%:==) SCR SCJ = SFalse
+      (%:==) SCR SCK = SFalse
+      (%:==) SCR SCL = SFalse
+      (%:==) SCR SCM = SFalse
+      (%:==) SCR SCN = SFalse
+      (%:==) SCR SCO = SFalse
+      (%:==) SCR SCP = SFalse
+      (%:==) SCR SCQ = SFalse
+      (%:==) SCR SCR = STrue
+      (%:==) SCR SCS = SFalse
+      (%:==) SCR SCT = SFalse
+      (%:==) SCR SCU = SFalse
+      (%:==) SCR SCV = SFalse
+      (%:==) SCR SCW = SFalse
+      (%:==) SCR SCX = SFalse
+      (%:==) SCR SCY = SFalse
+      (%:==) SCR SCZ = SFalse
+      (%:==) SCS SCA = SFalse
+      (%:==) SCS SCB = SFalse
+      (%:==) SCS SCC = SFalse
+      (%:==) SCS SCD = SFalse
+      (%:==) SCS SCE = SFalse
+      (%:==) SCS SCF = SFalse
+      (%:==) SCS SCG = SFalse
+      (%:==) SCS SCH = SFalse
+      (%:==) SCS SCI = SFalse
+      (%:==) SCS SCJ = SFalse
+      (%:==) SCS SCK = SFalse
+      (%:==) SCS SCL = SFalse
+      (%:==) SCS SCM = SFalse
+      (%:==) SCS SCN = SFalse
+      (%:==) SCS SCO = SFalse
+      (%:==) SCS SCP = SFalse
+      (%:==) SCS SCQ = SFalse
+      (%:==) SCS SCR = SFalse
+      (%:==) SCS SCS = STrue
+      (%:==) SCS SCT = SFalse
+      (%:==) SCS SCU = SFalse
+      (%:==) SCS SCV = SFalse
+      (%:==) SCS SCW = SFalse
+      (%:==) SCS SCX = SFalse
+      (%:==) SCS SCY = SFalse
+      (%:==) SCS SCZ = SFalse
+      (%:==) SCT SCA = SFalse
+      (%:==) SCT SCB = SFalse
+      (%:==) SCT SCC = SFalse
+      (%:==) SCT SCD = SFalse
+      (%:==) SCT SCE = SFalse
+      (%:==) SCT SCF = SFalse
+      (%:==) SCT SCG = SFalse
+      (%:==) SCT SCH = SFalse
+      (%:==) SCT SCI = SFalse
+      (%:==) SCT SCJ = SFalse
+      (%:==) SCT SCK = SFalse
+      (%:==) SCT SCL = SFalse
+      (%:==) SCT SCM = SFalse
+      (%:==) SCT SCN = SFalse
+      (%:==) SCT SCO = SFalse
+      (%:==) SCT SCP = SFalse
+      (%:==) SCT SCQ = SFalse
+      (%:==) SCT SCR = SFalse
+      (%:==) SCT SCS = SFalse
+      (%:==) SCT SCT = STrue
+      (%:==) SCT SCU = SFalse
+      (%:==) SCT SCV = SFalse
+      (%:==) SCT SCW = SFalse
+      (%:==) SCT SCX = SFalse
+      (%:==) SCT SCY = SFalse
+      (%:==) SCT SCZ = SFalse
+      (%:==) SCU SCA = SFalse
+      (%:==) SCU SCB = SFalse
+      (%:==) SCU SCC = SFalse
+      (%:==) SCU SCD = SFalse
+      (%:==) SCU SCE = SFalse
+      (%:==) SCU SCF = SFalse
+      (%:==) SCU SCG = SFalse
+      (%:==) SCU SCH = SFalse
+      (%:==) SCU SCI = SFalse
+      (%:==) SCU SCJ = SFalse
+      (%:==) SCU SCK = SFalse
+      (%:==) SCU SCL = SFalse
+      (%:==) SCU SCM = SFalse
+      (%:==) SCU SCN = SFalse
+      (%:==) SCU SCO = SFalse
+      (%:==) SCU SCP = SFalse
+      (%:==) SCU SCQ = SFalse
+      (%:==) SCU SCR = SFalse
+      (%:==) SCU SCS = SFalse
+      (%:==) SCU SCT = SFalse
+      (%:==) SCU SCU = STrue
+      (%:==) SCU SCV = SFalse
+      (%:==) SCU SCW = SFalse
+      (%:==) SCU SCX = SFalse
+      (%:==) SCU SCY = SFalse
+      (%:==) SCU SCZ = SFalse
+      (%:==) SCV SCA = SFalse
+      (%:==) SCV SCB = SFalse
+      (%:==) SCV SCC = SFalse
+      (%:==) SCV SCD = SFalse
+      (%:==) SCV SCE = SFalse
+      (%:==) SCV SCF = SFalse
+      (%:==) SCV SCG = SFalse
+      (%:==) SCV SCH = SFalse
+      (%:==) SCV SCI = SFalse
+      (%:==) SCV SCJ = SFalse
+      (%:==) SCV SCK = SFalse
+      (%:==) SCV SCL = SFalse
+      (%:==) SCV SCM = SFalse
+      (%:==) SCV SCN = SFalse
+      (%:==) SCV SCO = SFalse
+      (%:==) SCV SCP = SFalse
+      (%:==) SCV SCQ = SFalse
+      (%:==) SCV SCR = SFalse
+      (%:==) SCV SCS = SFalse
+      (%:==) SCV SCT = SFalse
+      (%:==) SCV SCU = SFalse
+      (%:==) SCV SCV = STrue
+      (%:==) SCV SCW = SFalse
+      (%:==) SCV SCX = SFalse
+      (%:==) SCV SCY = SFalse
+      (%:==) SCV SCZ = SFalse
+      (%:==) SCW SCA = SFalse
+      (%:==) SCW SCB = SFalse
+      (%:==) SCW SCC = SFalse
+      (%:==) SCW SCD = SFalse
+      (%:==) SCW SCE = SFalse
+      (%:==) SCW SCF = SFalse
+      (%:==) SCW SCG = SFalse
+      (%:==) SCW SCH = SFalse
+      (%:==) SCW SCI = SFalse
+      (%:==) SCW SCJ = SFalse
+      (%:==) SCW SCK = SFalse
+      (%:==) SCW SCL = SFalse
+      (%:==) SCW SCM = SFalse
+      (%:==) SCW SCN = SFalse
+      (%:==) SCW SCO = SFalse
+      (%:==) SCW SCP = SFalse
+      (%:==) SCW SCQ = SFalse
+      (%:==) SCW SCR = SFalse
+      (%:==) SCW SCS = SFalse
+      (%:==) SCW SCT = SFalse
+      (%:==) SCW SCU = SFalse
+      (%:==) SCW SCV = SFalse
+      (%:==) SCW SCW = STrue
+      (%:==) SCW SCX = SFalse
+      (%:==) SCW SCY = SFalse
+      (%:==) SCW SCZ = SFalse
+      (%:==) SCX SCA = SFalse
+      (%:==) SCX SCB = SFalse
+      (%:==) SCX SCC = SFalse
+      (%:==) SCX SCD = SFalse
+      (%:==) SCX SCE = SFalse
+      (%:==) SCX SCF = SFalse
+      (%:==) SCX SCG = SFalse
+      (%:==) SCX SCH = SFalse
+      (%:==) SCX SCI = SFalse
+      (%:==) SCX SCJ = SFalse
+      (%:==) SCX SCK = SFalse
+      (%:==) SCX SCL = SFalse
+      (%:==) SCX SCM = SFalse
+      (%:==) SCX SCN = SFalse
+      (%:==) SCX SCO = SFalse
+      (%:==) SCX SCP = SFalse
+      (%:==) SCX SCQ = SFalse
+      (%:==) SCX SCR = SFalse
+      (%:==) SCX SCS = SFalse
+      (%:==) SCX SCT = SFalse
+      (%:==) SCX SCU = SFalse
+      (%:==) SCX SCV = SFalse
+      (%:==) SCX SCW = SFalse
+      (%:==) SCX SCX = STrue
+      (%:==) SCX SCY = SFalse
+      (%:==) SCX SCZ = SFalse
+      (%:==) SCY SCA = SFalse
+      (%:==) SCY SCB = SFalse
+      (%:==) SCY SCC = SFalse
+      (%:==) SCY SCD = SFalse
+      (%:==) SCY SCE = SFalse
+      (%:==) SCY SCF = SFalse
+      (%:==) SCY SCG = SFalse
+      (%:==) SCY SCH = SFalse
+      (%:==) SCY SCI = SFalse
+      (%:==) SCY SCJ = SFalse
+      (%:==) SCY SCK = SFalse
+      (%:==) SCY SCL = SFalse
+      (%:==) SCY SCM = SFalse
+      (%:==) SCY SCN = SFalse
+      (%:==) SCY SCO = SFalse
+      (%:==) SCY SCP = SFalse
+      (%:==) SCY SCQ = SFalse
+      (%:==) SCY SCR = SFalse
+      (%:==) SCY SCS = SFalse
+      (%:==) SCY SCT = SFalse
+      (%:==) SCY SCU = SFalse
+      (%:==) SCY SCV = SFalse
+      (%:==) SCY SCW = SFalse
+      (%:==) SCY SCX = SFalse
+      (%:==) SCY SCY = STrue
+      (%:==) SCY SCZ = SFalse
+      (%:==) SCZ SCA = SFalse
+      (%:==) SCZ SCB = SFalse
+      (%:==) SCZ SCC = SFalse
+      (%:==) SCZ SCD = SFalse
+      (%:==) SCZ SCE = SFalse
+      (%:==) SCZ SCF = SFalse
+      (%:==) SCZ SCG = SFalse
+      (%:==) SCZ SCH = SFalse
+      (%:==) SCZ SCI = SFalse
+      (%:==) SCZ SCJ = SFalse
+      (%:==) SCZ SCK = SFalse
+      (%:==) SCZ SCL = SFalse
+      (%:==) SCZ SCM = SFalse
+      (%:==) SCZ SCN = SFalse
+      (%:==) SCZ SCO = SFalse
+      (%:==) SCZ SCP = SFalse
+      (%:==) SCZ SCQ = SFalse
+      (%:==) SCZ SCR = SFalse
+      (%:==) SCZ SCS = SFalse
+      (%:==) SCZ SCT = SFalse
+      (%:==) SCZ SCU = SFalse
+      (%:==) SCZ SCV = SFalse
+      (%:==) SCZ SCW = SFalse
+      (%:==) SCZ SCX = SFalse
+      (%:==) SCZ SCY = SFalse
+      (%:==) SCZ SCZ = STrue
+    instance SDecide (KProxy :: KProxy AChar) where
+      (%~) SCA SCA = Proved Refl
+      (%~) SCA SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCA SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCB = Proved Refl
+      (%~) SCB SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCB SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCC = Proved Refl
+      (%~) SCC SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCC SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCD = Proved Refl
+      (%~) SCD SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCD SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCE = Proved Refl
+      (%~) SCE SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCE SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCF = Proved Refl
+      (%~) SCF SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCF SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCG = Proved Refl
+      (%~) SCG SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCG SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCH = Proved Refl
+      (%~) SCH SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCH SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCI = Proved Refl
+      (%~) SCI SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCI SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCJ = Proved Refl
+      (%~) SCJ SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCJ SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCK = Proved Refl
+      (%~) SCK SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCK SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCL = Proved Refl
+      (%~) SCL SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCL SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCM = Proved Refl
+      (%~) SCM SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCM SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCN = Proved Refl
+      (%~) SCN SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCN SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCO = Proved Refl
+      (%~) SCO SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCO SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCP = Proved Refl
+      (%~) SCP SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCP SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCQ = Proved Refl
+      (%~) SCQ SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCQ SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCR = Proved Refl
+      (%~) SCR SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCR SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCS = Proved Refl
+      (%~) SCS SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCS SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCT = Proved Refl
+      (%~) SCT SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCT SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCU = Proved Refl
+      (%~) SCU SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCU SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCV = Proved Refl
+      (%~) SCV SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCV SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCW = Proved Refl
+      (%~) SCW SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCW SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCX = Proved Refl
+      (%~) SCX SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCX SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCY SCY = Proved Refl
+      (%~) SCY SCZ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCA
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCB
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCC
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCD
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCE
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCF
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCG
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCH
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCI
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCJ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCK
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCL
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCM
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCN
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCO
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCP
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCQ
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCR
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCS
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCT
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCU
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCV
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCW
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCX
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCY
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SCZ SCZ = Proved Refl
+    data instance Sing (z :: Attribute)
+      = forall (n :: [AChar]) (n :: U). z ~ Attr n n =>
+        SAttr (Sing (n :: [AChar])) (Sing (n :: U))
+    type SAttribute = (Sing :: Attribute -> *)
+    instance SingKind (KProxy :: KProxy Attribute) where
+      type DemoteRep (KProxy :: KProxy Attribute) = Attribute
+      fromSing (SAttr b b) = Attr (fromSing b) (fromSing b)
+      toSing (Attr b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy [AChar]))
+                (toSing b :: SomeSing (KProxy :: KProxy U))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SAttr c c) }
+    data instance Sing (z :: Schema)
+      = forall (n :: [Attribute]). z ~ Sch n =>
+        SSch (Sing (n :: [Attribute]))
+    type SSchema = (Sing :: Schema -> *)
+    instance SingKind (KProxy :: KProxy Schema) where
+      type DemoteRep (KProxy :: KProxy Schema) = Schema
+      fromSing (SSch b) = Sch (fromSing b)
+      toSing (Sch b)
+        = case toSing b :: SomeSing (KProxy :: KProxy [Attribute]) of {
+            SomeSing c -> SomeSing (SSch c) }
+    instance SingI BOOL where
+      sing = SBOOL
+    instance SingI STRING where
+      sing = SSTRING
+    instance SingI NAT where
+      sing = SNAT
+    instance (SingI n, SingI n) =>
+             SingI (VEC (n :: U) (n :: Nat)) where
+      sing = SVEC sing sing
+    instance SingI CA where
+      sing = SCA
+    instance SingI CB where
+      sing = SCB
+    instance SingI CC where
+      sing = SCC
+    instance SingI CD where
+      sing = SCD
+    instance SingI CE where
+      sing = SCE
+    instance SingI CF where
+      sing = SCF
+    instance SingI CG where
+      sing = SCG
+    instance SingI CH where
+      sing = SCH
+    instance SingI CI where
+      sing = SCI
+    instance SingI CJ where
+      sing = SCJ
+    instance SingI CK where
+      sing = SCK
+    instance SingI CL where
+      sing = SCL
+    instance SingI CM where
+      sing = SCM
+    instance SingI CN where
+      sing = SCN
+    instance SingI CO where
+      sing = SCO
+    instance SingI CP where
+      sing = SCP
+    instance SingI CQ where
+      sing = SCQ
+    instance SingI CR where
+      sing = SCR
+    instance SingI CS where
+      sing = SCS
+    instance SingI CT where
+      sing = SCT
+    instance SingI CU where
+      sing = SCU
+    instance SingI CV where
+      sing = SCV
+    instance SingI CW where
+      sing = SCW
+    instance SingI CX where
+      sing = SCX
+    instance SingI CY where
+      sing = SCY
+    instance SingI CZ where
+      sing = SCZ
+    instance (SingI n, SingI n) =>
+             SingI (Attr (n :: [AChar]) (n :: U)) where
+      sing = SAttr sing sing
+    instance SingI n => SingI (Sch (n :: [Attribute])) where
+      sing = SSch sing
+GradingClient/Database.hs:0:0:: Splicing declarations
+    return [] ======>
+GradingClient/Database.hs:(0,0)-(0,0): Splicing expression
+    cases ''Row [| r |] [| changeId (n ++ (getId r)) r |]
+  ======>
+    case r of {
+      EmptyRow _ -> changeId ((++) n (getId r)) r
+      ConsRow _ _ -> changeId ((++) n (getId r)) r }
diff --git a/tests/compile-and-dump/GradingClient/Database.ghc78.template b/tests/compile-and-dump/GradingClient/Database.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/GradingClient/Database.ghc78.template
+++ /dev/null
@@ -1,4808 +0,0 @@
-GradingClient/Database.hs:0:0: Splicing declarations
-    singletons
-      [d| data Nat
-            = Zero | Succ Nat
-            deriving (Eq, Ord) |]
-  ======>
-    GradingClient/Database.hs:(0,0)-(0,0)
-    data Nat
-      = Zero | Succ Nat
-      deriving (Eq, Ord)
-    type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where
-      Equals_0123456789 Zero Zero = TrueSym0
-      Equals_0123456789 (Succ a) (Succ b) = (:==) a b
-      Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0
-    instance PEq (KProxy :: KProxy Nat) where
-      type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b
-    instance POrd (KProxy :: KProxy Nat) where
-      type Compare Zero Zero = EQ
-      type Compare Zero (Succ rhs) = LT
-      type Compare (Succ lhs) Zero = GT
-      type Compare (Succ lhs) (Succ rhs) = ThenCmp EQ (Compare lhs rhs)
-    type ZeroSym0 = Zero
-    type SuccSym1 (t :: Nat) = Succ t
-    instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
-    data SuccSym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
-        SuccSym0KindInference
-    type instance Apply SuccSym0 l = SuccSym1 l
-    data instance Sing (z :: Nat)
-      = z ~ Zero => SZero |
-        forall (n :: Nat). z ~ Succ n => SSucc (Sing n)
-    type SNat (z :: Nat) = Sing z
-    instance SingKind (KProxy :: KProxy Nat) where
-      type DemoteRep (KProxy :: KProxy Nat) = Nat
-      fromSing SZero = Zero
-      fromSing (SSucc b) = Succ (fromSing b)
-      toSing Zero = SomeSing SZero
-      toSing (Succ b)
-        = case toSing b :: SomeSing (KProxy :: KProxy Nat) of {
-            SomeSing c -> SomeSing (SSucc c) }
-    instance SEq (KProxy :: KProxy Nat) where
-      (%:==) SZero SZero = STrue
-      (%:==) SZero (SSucc _) = SFalse
-      (%:==) (SSucc _) SZero = SFalse
-      (%:==) (SSucc a) (SSucc b) = (%:==) a b
-    instance SDecide (KProxy :: KProxy Nat) where
-      (%~) SZero SZero = Proved Refl
-      (%~) SZero (SSucc _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SSucc _) SZero
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SSucc a) (SSucc b)
-        = case (%~) a b of {
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
-    instance SingI Zero where
-      sing = SZero
-    instance SingI n => SingI (Succ (n :: Nat)) where
-      sing = SSucc sing
-GradingClient/Database.hs:0:0: Splicing declarations
-    singletons
-      [d| append :: Schema -> Schema -> Schema
-          append (Sch s1) (Sch s2) = Sch (s1 ++ s2)
-          attrNotIn :: Attribute -> Schema -> Bool
-          attrNotIn _ (Sch []) = True
-          attrNotIn (Attr name u) (Sch ((Attr name' _) : t))
-            = (name /= name') && (attrNotIn (Attr name u) (Sch t))
-          disjoint :: Schema -> Schema -> Bool
-          disjoint (Sch []) _ = True
-          disjoint (Sch (h : t)) s = (attrNotIn h s) && (disjoint (Sch t) s)
-          occurs :: [AChar] -> Schema -> Bool
-          occurs _ (Sch []) = False
-          occurs name (Sch ((Attr name' _) : attrs))
-            = name == name' || occurs name (Sch attrs)
-          lookup :: [AChar] -> Schema -> U
-          lookup _ (Sch []) = undefined
-          lookup name (Sch ((Attr name' u) : attrs))
-            = if name == name' then u else lookup name (Sch attrs)
-          
-          data U
-            = BOOL | STRING | NAT | VEC U Nat
-            deriving (Read, Eq, Show)
-          data AChar
-            = CA |
-              CB |
-              CC |
-              CD |
-              CE |
-              CF |
-              CG |
-              CH |
-              CI |
-              CJ |
-              CK |
-              CL |
-              CM |
-              CN |
-              CO |
-              CP |
-              CQ |
-              CR |
-              CS |
-              CT |
-              CU |
-              CV |
-              CW |
-              CX |
-              CY |
-              CZ
-            deriving (Read, Show, Eq)
-          data Attribute = Attr [AChar] U
-          data Schema = Sch [Attribute] |]
-  ======>
-    GradingClient/Database.hs:(0,0)-(0,0)
-    data U
-      = BOOL | STRING | NAT | VEC U Nat
-      deriving (Read, Eq, Show)
-    data AChar
-      = CA |
-        CB |
-        CC |
-        CD |
-        CE |
-        CF |
-        CG |
-        CH |
-        CI |
-        CJ |
-        CK |
-        CL |
-        CM |
-        CN |
-        CO |
-        CP |
-        CQ |
-        CR |
-        CS |
-        CT |
-        CU |
-        CV |
-        CW |
-        CX |
-        CY |
-        CZ
-      deriving (Read, Show, Eq)
-    data Attribute = Attr [AChar] U
-    data Schema = Sch [Attribute]
-    append :: Schema -> Schema -> Schema
-    append (Sch s1) (Sch s2) = Sch (s1 ++ s2)
-    attrNotIn :: Attribute -> Schema -> Bool
-    attrNotIn _ (Sch GHC.Types.[]) = True
-    attrNotIn (Attr name u) (Sch ((Attr name' _) GHC.Types.: t))
-      = ((name /= name') && (attrNotIn (Attr name u) (Sch t)))
-    disjoint :: Schema -> Schema -> Bool
-    disjoint (Sch GHC.Types.[]) _ = True
-    disjoint (Sch (h GHC.Types.: t)) s
-      = ((attrNotIn h s) && (disjoint (Sch t) s))
-    occurs :: [AChar] -> Schema -> Bool
-    occurs _ (Sch GHC.Types.[]) = False
-    occurs name (Sch ((Attr name' _) GHC.Types.: attrs))
-      = ((name == name') || (occurs name (Sch attrs)))
-    lookup :: [AChar] -> Schema -> U
-    lookup _ (Sch GHC.Types.[]) = undefined
-    lookup name (Sch ((Attr name' u) GHC.Types.: attrs))
-      = if (name == name') then u else lookup name (Sch attrs)
-    type family Equals_0123456789 (a :: U) (b :: U) :: Bool where
-      Equals_0123456789 BOOL BOOL = TrueSym0
-      Equals_0123456789 STRING STRING = TrueSym0
-      Equals_0123456789 NAT NAT = TrueSym0
-      Equals_0123456789 (VEC a a) (VEC b b) = (:&&) ((:==) a b) ((:==) a b)
-      Equals_0123456789 (a :: U) (b :: U) = FalseSym0
-    instance PEq (KProxy :: KProxy U) where
-      type (:==) (a :: U) (b :: U) = Equals_0123456789 a b
-    type BOOLSym0 = BOOL
-    type STRINGSym0 = STRING
-    type NATSym0 = NAT
-    type VECSym2 (t :: U) (t :: Nat) = VEC t t
-    instance SuppressUnusedWarnings VECSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) VECSym1KindInference GHC.Tuple.())
-    data VECSym1 (l :: U) (l :: TyFun Nat U)
-      = forall arg. KindOf (Apply (VECSym1 l) arg) ~ KindOf (VECSym2 l arg) =>
-        VECSym1KindInference
-    type instance Apply (VECSym1 l) l = VECSym2 l l
-    instance SuppressUnusedWarnings VECSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) VECSym0KindInference GHC.Tuple.())
-    data VECSym0 (l :: TyFun U (TyFun Nat U -> *))
-      = forall arg. KindOf (Apply VECSym0 arg) ~ KindOf (VECSym1 arg) =>
-        VECSym0KindInference
-    type instance Apply VECSym0 l = VECSym1 l
-    type family Equals_0123456789 (a :: AChar)
-                                  (b :: AChar) :: Bool where
-      Equals_0123456789 CA CA = TrueSym0
-      Equals_0123456789 CB CB = TrueSym0
-      Equals_0123456789 CC CC = TrueSym0
-      Equals_0123456789 CD CD = TrueSym0
-      Equals_0123456789 CE CE = TrueSym0
-      Equals_0123456789 CF CF = TrueSym0
-      Equals_0123456789 CG CG = TrueSym0
-      Equals_0123456789 CH CH = TrueSym0
-      Equals_0123456789 CI CI = TrueSym0
-      Equals_0123456789 CJ CJ = TrueSym0
-      Equals_0123456789 CK CK = TrueSym0
-      Equals_0123456789 CL CL = TrueSym0
-      Equals_0123456789 CM CM = TrueSym0
-      Equals_0123456789 CN CN = TrueSym0
-      Equals_0123456789 CO CO = TrueSym0
-      Equals_0123456789 CP CP = TrueSym0
-      Equals_0123456789 CQ CQ = TrueSym0
-      Equals_0123456789 CR CR = TrueSym0
-      Equals_0123456789 CS CS = TrueSym0
-      Equals_0123456789 CT CT = TrueSym0
-      Equals_0123456789 CU CU = TrueSym0
-      Equals_0123456789 CV CV = TrueSym0
-      Equals_0123456789 CW CW = TrueSym0
-      Equals_0123456789 CX CX = TrueSym0
-      Equals_0123456789 CY CY = TrueSym0
-      Equals_0123456789 CZ CZ = TrueSym0
-      Equals_0123456789 (a :: AChar) (b :: AChar) = FalseSym0
-    instance PEq (KProxy :: KProxy AChar) where
-      type (:==) (a :: AChar) (b :: AChar) = Equals_0123456789 a b
-    type CASym0 = CA
-    type CBSym0 = CB
-    type CCSym0 = CC
-    type CDSym0 = CD
-    type CESym0 = CE
-    type CFSym0 = CF
-    type CGSym0 = CG
-    type CHSym0 = CH
-    type CISym0 = CI
-    type CJSym0 = CJ
-    type CKSym0 = CK
-    type CLSym0 = CL
-    type CMSym0 = CM
-    type CNSym0 = CN
-    type COSym0 = CO
-    type CPSym0 = CP
-    type CQSym0 = CQ
-    type CRSym0 = CR
-    type CSSym0 = CS
-    type CTSym0 = CT
-    type CUSym0 = CU
-    type CVSym0 = CV
-    type CWSym0 = CW
-    type CXSym0 = CX
-    type CYSym0 = CY
-    type CZSym0 = CZ
-    type AttrSym2 (t :: [AChar]) (t :: U) = Attr t t
-    instance SuppressUnusedWarnings AttrSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) AttrSym1KindInference GHC.Tuple.())
-    data AttrSym1 (l :: [AChar]) (l :: TyFun U Attribute)
-      = forall arg. KindOf (Apply (AttrSym1 l) arg) ~ KindOf (AttrSym2 l arg) =>
-        AttrSym1KindInference
-    type instance Apply (AttrSym1 l) l = AttrSym2 l l
-    instance SuppressUnusedWarnings AttrSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) AttrSym0KindInference GHC.Tuple.())
-    data AttrSym0 (l :: TyFun [AChar] (TyFun U Attribute -> *))
-      = forall arg. KindOf (Apply AttrSym0 arg) ~ KindOf (AttrSym1 arg) =>
-        AttrSym0KindInference
-    type instance Apply AttrSym0 l = AttrSym1 l
-    type SchSym1 (t :: [Attribute]) = Sch t
-    instance SuppressUnusedWarnings SchSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) SchSym0KindInference GHC.Tuple.())
-    data SchSym0 (l :: TyFun [Attribute] Schema)
-      = forall arg. KindOf (Apply SchSym0 arg) ~ KindOf (SchSym1 arg) =>
-        SchSym0KindInference
-    type instance Apply SchSym0 l = SchSym1 l
-    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
-        Let0123456789Scrutinee_0123456789 t t t t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>
-        Let0123456789Scrutinee_0123456789Sym3KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>
-        Let0123456789Scrutinee_0123456789Sym2KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 name name' u attrs =
-        Apply (Apply (:==$) name) name'
-    type family Case_0123456789 name name' u attrs t where
-      Case_0123456789 name name' u attrs True = u
-      Case_0123456789 name name' u attrs False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs)
-    type LookupSym2 (t :: [AChar]) (t :: Schema) = Lookup t t
-    instance SuppressUnusedWarnings LookupSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LookupSym1KindInference GHC.Tuple.())
-    data LookupSym1 (l :: [AChar]) (l :: TyFun Schema U)
-      = forall arg. KindOf (Apply (LookupSym1 l) arg) ~ KindOf (LookupSym2 l arg) =>
-        LookupSym1KindInference
-    type instance Apply (LookupSym1 l) l = LookupSym2 l l
-    instance SuppressUnusedWarnings LookupSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LookupSym0KindInference GHC.Tuple.())
-    data LookupSym0 (l :: TyFun [AChar] (TyFun Schema U -> *))
-      = forall arg. KindOf (Apply LookupSym0 arg) ~ KindOf (LookupSym1 arg) =>
-        LookupSym0KindInference
-    type instance Apply LookupSym0 l = LookupSym1 l
-    type OccursSym2 (t :: [AChar]) (t :: Schema) = Occurs t t
-    instance SuppressUnusedWarnings OccursSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) OccursSym1KindInference GHC.Tuple.())
-    data OccursSym1 (l :: [AChar]) (l :: TyFun Schema Bool)
-      = forall arg. KindOf (Apply (OccursSym1 l) arg) ~ KindOf (OccursSym2 l arg) =>
-        OccursSym1KindInference
-    type instance Apply (OccursSym1 l) l = OccursSym2 l l
-    instance SuppressUnusedWarnings OccursSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) OccursSym0KindInference GHC.Tuple.())
-    data OccursSym0 (l :: TyFun [AChar] (TyFun Schema Bool -> *))
-      = forall arg. KindOf (Apply OccursSym0 arg) ~ KindOf (OccursSym1 arg) =>
-        OccursSym0KindInference
-    type instance Apply OccursSym0 l = OccursSym1 l
-    type AttrNotInSym2 (t :: Attribute) (t :: Schema) = AttrNotIn t t
-    instance SuppressUnusedWarnings AttrNotInSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) AttrNotInSym1KindInference GHC.Tuple.())
-    data AttrNotInSym1 (l :: Attribute) (l :: TyFun Schema Bool)
-      = forall arg. KindOf (Apply (AttrNotInSym1 l) arg) ~ KindOf (AttrNotInSym2 l arg) =>
-        AttrNotInSym1KindInference
-    type instance Apply (AttrNotInSym1 l) l = AttrNotInSym2 l l
-    instance SuppressUnusedWarnings AttrNotInSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) AttrNotInSym0KindInference GHC.Tuple.())
-    data AttrNotInSym0 (l :: TyFun Attribute (TyFun Schema Bool -> *))
-      = forall arg. KindOf (Apply AttrNotInSym0 arg) ~ KindOf (AttrNotInSym1 arg) =>
-        AttrNotInSym0KindInference
-    type instance Apply AttrNotInSym0 l = AttrNotInSym1 l
-    type DisjointSym2 (t :: Schema) (t :: Schema) = Disjoint t t
-    instance SuppressUnusedWarnings DisjointSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) DisjointSym1KindInference GHC.Tuple.())
-    data DisjointSym1 (l :: Schema) (l :: TyFun Schema Bool)
-      = forall arg. KindOf (Apply (DisjointSym1 l) arg) ~ KindOf (DisjointSym2 l arg) =>
-        DisjointSym1KindInference
-    type instance Apply (DisjointSym1 l) l = DisjointSym2 l l
-    instance SuppressUnusedWarnings DisjointSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) DisjointSym0KindInference GHC.Tuple.())
-    data DisjointSym0 (l :: TyFun Schema (TyFun Schema Bool -> *))
-      = forall arg. KindOf (Apply DisjointSym0 arg) ~ KindOf (DisjointSym1 arg) =>
-        DisjointSym0KindInference
-    type instance Apply DisjointSym0 l = DisjointSym1 l
-    type AppendSym2 (t :: Schema) (t :: Schema) = Append t t
-    instance SuppressUnusedWarnings AppendSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) AppendSym1KindInference GHC.Tuple.())
-    data AppendSym1 (l :: Schema) (l :: TyFun Schema Schema)
-      = forall arg. KindOf (Apply (AppendSym1 l) arg) ~ KindOf (AppendSym2 l arg) =>
-        AppendSym1KindInference
-    type instance Apply (AppendSym1 l) l = AppendSym2 l l
-    instance SuppressUnusedWarnings AppendSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) AppendSym0KindInference GHC.Tuple.())
-    data AppendSym0 (l :: TyFun Schema (TyFun Schema Schema -> *))
-      = forall arg. KindOf (Apply AppendSym0 arg) ~ KindOf (AppendSym1 arg) =>
-        AppendSym0KindInference
-    type instance Apply AppendSym0 l = AppendSym1 l
-    type family Lookup (a :: [AChar]) (a :: Schema) :: U where
-      Lookup z (Sch '[]) = Any
-      Lookup name (Sch ((:) (Attr name' u) attrs)) = Case_0123456789 name name' u attrs (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs)
-    type family Occurs (a :: [AChar]) (a :: Schema) :: Bool where
-      Occurs z (Sch '[]) = FalseSym0
-      Occurs name (Sch ((:) (Attr name' z) attrs)) = Apply (Apply (:||$) (Apply (Apply (:==$) name) name')) (Apply (Apply OccursSym0 name) (Apply SchSym0 attrs))
-    type family AttrNotIn (a :: Attribute) (a :: Schema) :: Bool where
-      AttrNotIn z (Sch '[]) = TrueSym0
-      AttrNotIn (Attr name u) (Sch ((:) (Attr name' z) t)) = Apply (Apply (:&&$) (Apply (Apply (:/=$) name) name')) (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 t))
-    type family Disjoint (a :: Schema) (a :: Schema) :: Bool where
-      Disjoint (Sch '[]) z = TrueSym0
-      Disjoint (Sch ((:) h t)) s = Apply (Apply (:&&$) (Apply (Apply AttrNotInSym0 h) s)) (Apply (Apply DisjointSym0 (Apply SchSym0 t)) s)
-    type family Append (a :: Schema) (a :: Schema) :: Schema where
-      Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (:++$) s1) s2)
-    sLookup ::
-      forall (t :: [AChar]) (t :: Schema).
-      Sing t -> Sing t -> Sing (Apply (Apply LookupSym0 t) t)
-    sOccurs ::
-      forall (t :: [AChar]) (t :: Schema).
-      Sing t -> Sing t -> Sing (Apply (Apply OccursSym0 t) t)
-    sAttrNotIn ::
-      forall (t :: Attribute) (t :: Schema).
-      Sing t -> Sing t -> Sing (Apply (Apply AttrNotInSym0 t) t)
-    sDisjoint ::
-      forall (t :: Schema) (t :: Schema).
-      Sing t -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t)
-    sAppend ::
-      forall (t :: Schema) (t :: Schema).
-      Sing t -> Sing t -> Sing (Apply (Apply AppendSym0 t) t)
-    sLookup _ (SSch SNil)
-      = let
-          lambda ::
-            forall wild. (t ~ wild, t ~ Apply SchSym0 '[]) =>
-            Sing (Apply (Apply LookupSym0 wild) (Apply SchSym0 '[]))
-          lambda = undefined
-        in lambda
-    sLookup sName (SSch (SCons (SAttr sName' sU) sAttrs))
-      = let
-          lambda ::
-            forall name name' u attrs. (t ~ name,
-                                        t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') u)) attrs)) =>
-            Sing name
-            -> Sing name'
-               -> Sing u
-                  -> Sing attrs
-                     -> Sing (Apply (Apply LookupSym0 name) (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') u)) attrs)))
-          lambda name name' u attrs
-            = let
-                sScrutinee_0123456789 ::
-                  Sing (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs)
-                sScrutinee_0123456789
-                  = applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) name) name'
-              in
-                case sScrutinee_0123456789 of {
-                  STrue
-                    -> let
-                         lambda :: Sing (Case_0123456789 name name' u attrs TrueSym0)
-                         lambda = u
-                       in lambda
-                  SFalse
-                    -> let
-                         lambda :: Sing (Case_0123456789 name name' u attrs FalseSym0)
-                         lambda
-                           = applySing
-                               (applySing (singFun2 (Proxy :: Proxy LookupSym0) sLookup) name)
-                               (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) attrs)
-                       in lambda }
-        in lambda sName sName' sU sAttrs
-    sOccurs _ (SSch SNil)
-      = let
-          lambda ::
-            forall wild. (t ~ wild, t ~ Apply SchSym0 '[]) =>
-            Sing (Apply (Apply OccursSym0 wild) (Apply SchSym0 '[]))
-          lambda = SFalse
-        in lambda
-    sOccurs sName (SSch (SCons (SAttr sName' _) sAttrs))
-      = let
-          lambda ::
-            forall name name' attrs wild. (t ~ name,
-                                           t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') wild)) attrs)) =>
-            Sing name
-            -> Sing name'
-               -> Sing attrs
-                  -> Sing (Apply (Apply OccursSym0 name) (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') wild)) attrs)))
-          lambda name name' attrs
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:||$)) (%:||))
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) name) name'))
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy OccursSym0) sOccurs) name)
-                   (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) attrs))
-        in lambda sName sName' sAttrs
-    sAttrNotIn _ (SSch SNil)
-      = let
-          lambda ::
-            forall wild. (t ~ wild, t ~ Apply SchSym0 '[]) =>
-            Sing (Apply (Apply AttrNotInSym0 wild) (Apply SchSym0 '[]))
-          lambda = STrue
-        in lambda
-    sAttrNotIn (SAttr sName sU) (SSch (SCons (SAttr sName' _) sT))
-      = let
-          lambda ::
-            forall name u name' t wild. (t ~ Apply (Apply AttrSym0 name) u,
-                                         t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') wild)) t)) =>
-            Sing name
-            -> Sing u
-               -> Sing name'
-                  -> Sing t
-                     -> Sing (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') wild)) t)))
-          lambda name u name' t
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:&&$)) (%:&&))
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:/=$)) (%:/=)) name) name'))
-                (applySing
-                   (applySing
-                      (singFun2 (Proxy :: Proxy AttrNotInSym0) sAttrNotIn)
-                      (applySing
-                         (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) name) u))
-                   (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) t))
-        in lambda sName sU sName' sT
-    sDisjoint (SSch SNil) _
-      = let
-          lambda ::
-            forall wild. (t ~ Apply SchSym0 '[], t ~ wild) =>
-            Sing (Apply (Apply DisjointSym0 (Apply SchSym0 '[])) wild)
-          lambda = STrue
-        in lambda
-    sDisjoint (SSch (SCons sH sT)) sS
-      = let
-          lambda ::
-            forall h t s. (t ~ Apply SchSym0 (Apply (Apply (:$) h) t),
-                           t ~ s) =>
-            Sing h
-            -> Sing t
-               -> Sing s
-                  -> Sing (Apply (Apply DisjointSym0 (Apply SchSym0 (Apply (Apply (:$) h) t))) s)
-          lambda h t s
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:&&$)) (%:&&))
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy AttrNotInSym0) sAttrNotIn) h)
-                      s))
-                (applySing
-                   (applySing
-                      (singFun2 (Proxy :: Proxy DisjointSym0) sDisjoint)
-                      (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) t))
-                   s)
-        in lambda sH sT sS
-    sAppend (SSch sS1) (SSch sS2)
-      = let
-          lambda ::
-            forall s1 s2. (t ~ Apply SchSym0 s1, t ~ Apply SchSym0 s2) =>
-            Sing s1
-            -> Sing s2
-               -> Sing (Apply (Apply AppendSym0 (Apply SchSym0 s1)) (Apply SchSym0 s2))
-          lambda s1 s2
-            = applySing
-                (singFun1 (Proxy :: Proxy SchSym0) SSch)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy (:++$)) (%:++)) s1) s2)
-        in lambda sS1 sS2
-    data instance Sing (z :: U)
-      = z ~ BOOL => SBOOL |
-        z ~ STRING => SSTRING |
-        z ~ NAT => SNAT |
-        forall (n :: U) (n :: Nat). z ~ VEC n n => SVEC (Sing n) (Sing n)
-    type SU (z :: U) = Sing z
-    instance SingKind (KProxy :: KProxy U) where
-      type DemoteRep (KProxy :: KProxy U) = U
-      fromSing SBOOL = BOOL
-      fromSing SSTRING = STRING
-      fromSing SNAT = NAT
-      fromSing (SVEC b b) = VEC (fromSing b) (fromSing b)
-      toSing BOOL = SomeSing SBOOL
-      toSing STRING = SomeSing SSTRING
-      toSing NAT = SomeSing SNAT
-      toSing (VEC b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy U))
-                (toSing b :: SomeSing (KProxy :: KProxy Nat))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SVEC c c) }
-    instance SEq (KProxy :: KProxy U) where
-      (%:==) SBOOL SBOOL = STrue
-      (%:==) SBOOL SSTRING = SFalse
-      (%:==) SBOOL SNAT = SFalse
-      (%:==) SBOOL (SVEC _ _) = SFalse
-      (%:==) SSTRING SBOOL = SFalse
-      (%:==) SSTRING SSTRING = STrue
-      (%:==) SSTRING SNAT = SFalse
-      (%:==) SSTRING (SVEC _ _) = SFalse
-      (%:==) SNAT SBOOL = SFalse
-      (%:==) SNAT SSTRING = SFalse
-      (%:==) SNAT SNAT = STrue
-      (%:==) SNAT (SVEC _ _) = SFalse
-      (%:==) (SVEC _ _) SBOOL = SFalse
-      (%:==) (SVEC _ _) SSTRING = SFalse
-      (%:==) (SVEC _ _) SNAT = SFalse
-      (%:==) (SVEC a a) (SVEC b b) = (%:&&) ((%:==) a b) ((%:==) a b)
-    instance SDecide (KProxy :: KProxy U) where
-      (%~) SBOOL SBOOL = Proved Refl
-      (%~) SBOOL SSTRING
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SBOOL SNAT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SBOOL (SVEC _ _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SSTRING SBOOL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SSTRING SSTRING = Proved Refl
-      (%~) SSTRING SNAT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SSTRING (SVEC _ _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SNAT SBOOL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SNAT SSTRING
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SNAT SNAT = Proved Refl
-      (%~) SNAT (SVEC _ _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVEC _ _) SBOOL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVEC _ _) SSTRING
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVEC _ _) SNAT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVEC a a) (SVEC b b)
-        = case GHC.Tuple.(,) ((%~) a b) ((%~) a b) of {
-            GHC.Tuple.(,) (Proved Refl) (Proved Refl) -> Proved Refl
-            GHC.Tuple.(,) (Disproved contra) _
-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
-            GHC.Tuple.(,) _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
-    data instance Sing (z :: AChar)
-      = z ~ CA => SCA |
-        z ~ CB => SCB |
-        z ~ CC => SCC |
-        z ~ CD => SCD |
-        z ~ CE => SCE |
-        z ~ CF => SCF |
-        z ~ CG => SCG |
-        z ~ CH => SCH |
-        z ~ CI => SCI |
-        z ~ CJ => SCJ |
-        z ~ CK => SCK |
-        z ~ CL => SCL |
-        z ~ CM => SCM |
-        z ~ CN => SCN |
-        z ~ CO => SCO |
-        z ~ CP => SCP |
-        z ~ CQ => SCQ |
-        z ~ CR => SCR |
-        z ~ CS => SCS |
-        z ~ CT => SCT |
-        z ~ CU => SCU |
-        z ~ CV => SCV |
-        z ~ CW => SCW |
-        z ~ CX => SCX |
-        z ~ CY => SCY |
-        z ~ CZ => SCZ
-    type SAChar (z :: AChar) = Sing z
-    instance SingKind (KProxy :: KProxy AChar) where
-      type DemoteRep (KProxy :: KProxy AChar) = AChar
-      fromSing SCA = CA
-      fromSing SCB = CB
-      fromSing SCC = CC
-      fromSing SCD = CD
-      fromSing SCE = CE
-      fromSing SCF = CF
-      fromSing SCG = CG
-      fromSing SCH = CH
-      fromSing SCI = CI
-      fromSing SCJ = CJ
-      fromSing SCK = CK
-      fromSing SCL = CL
-      fromSing SCM = CM
-      fromSing SCN = CN
-      fromSing SCO = CO
-      fromSing SCP = CP
-      fromSing SCQ = CQ
-      fromSing SCR = CR
-      fromSing SCS = CS
-      fromSing SCT = CT
-      fromSing SCU = CU
-      fromSing SCV = CV
-      fromSing SCW = CW
-      fromSing SCX = CX
-      fromSing SCY = CY
-      fromSing SCZ = CZ
-      toSing CA = SomeSing SCA
-      toSing CB = SomeSing SCB
-      toSing CC = SomeSing SCC
-      toSing CD = SomeSing SCD
-      toSing CE = SomeSing SCE
-      toSing CF = SomeSing SCF
-      toSing CG = SomeSing SCG
-      toSing CH = SomeSing SCH
-      toSing CI = SomeSing SCI
-      toSing CJ = SomeSing SCJ
-      toSing CK = SomeSing SCK
-      toSing CL = SomeSing SCL
-      toSing CM = SomeSing SCM
-      toSing CN = SomeSing SCN
-      toSing CO = SomeSing SCO
-      toSing CP = SomeSing SCP
-      toSing CQ = SomeSing SCQ
-      toSing CR = SomeSing SCR
-      toSing CS = SomeSing SCS
-      toSing CT = SomeSing SCT
-      toSing CU = SomeSing SCU
-      toSing CV = SomeSing SCV
-      toSing CW = SomeSing SCW
-      toSing CX = SomeSing SCX
-      toSing CY = SomeSing SCY
-      toSing CZ = SomeSing SCZ
-    instance SEq (KProxy :: KProxy AChar) where
-      (%:==) SCA SCA = STrue
-      (%:==) SCA SCB = SFalse
-      (%:==) SCA SCC = SFalse
-      (%:==) SCA SCD = SFalse
-      (%:==) SCA SCE = SFalse
-      (%:==) SCA SCF = SFalse
-      (%:==) SCA SCG = SFalse
-      (%:==) SCA SCH = SFalse
-      (%:==) SCA SCI = SFalse
-      (%:==) SCA SCJ = SFalse
-      (%:==) SCA SCK = SFalse
-      (%:==) SCA SCL = SFalse
-      (%:==) SCA SCM = SFalse
-      (%:==) SCA SCN = SFalse
-      (%:==) SCA SCO = SFalse
-      (%:==) SCA SCP = SFalse
-      (%:==) SCA SCQ = SFalse
-      (%:==) SCA SCR = SFalse
-      (%:==) SCA SCS = SFalse
-      (%:==) SCA SCT = SFalse
-      (%:==) SCA SCU = SFalse
-      (%:==) SCA SCV = SFalse
-      (%:==) SCA SCW = SFalse
-      (%:==) SCA SCX = SFalse
-      (%:==) SCA SCY = SFalse
-      (%:==) SCA SCZ = SFalse
-      (%:==) SCB SCA = SFalse
-      (%:==) SCB SCB = STrue
-      (%:==) SCB SCC = SFalse
-      (%:==) SCB SCD = SFalse
-      (%:==) SCB SCE = SFalse
-      (%:==) SCB SCF = SFalse
-      (%:==) SCB SCG = SFalse
-      (%:==) SCB SCH = SFalse
-      (%:==) SCB SCI = SFalse
-      (%:==) SCB SCJ = SFalse
-      (%:==) SCB SCK = SFalse
-      (%:==) SCB SCL = SFalse
-      (%:==) SCB SCM = SFalse
-      (%:==) SCB SCN = SFalse
-      (%:==) SCB SCO = SFalse
-      (%:==) SCB SCP = SFalse
-      (%:==) SCB SCQ = SFalse
-      (%:==) SCB SCR = SFalse
-      (%:==) SCB SCS = SFalse
-      (%:==) SCB SCT = SFalse
-      (%:==) SCB SCU = SFalse
-      (%:==) SCB SCV = SFalse
-      (%:==) SCB SCW = SFalse
-      (%:==) SCB SCX = SFalse
-      (%:==) SCB SCY = SFalse
-      (%:==) SCB SCZ = SFalse
-      (%:==) SCC SCA = SFalse
-      (%:==) SCC SCB = SFalse
-      (%:==) SCC SCC = STrue
-      (%:==) SCC SCD = SFalse
-      (%:==) SCC SCE = SFalse
-      (%:==) SCC SCF = SFalse
-      (%:==) SCC SCG = SFalse
-      (%:==) SCC SCH = SFalse
-      (%:==) SCC SCI = SFalse
-      (%:==) SCC SCJ = SFalse
-      (%:==) SCC SCK = SFalse
-      (%:==) SCC SCL = SFalse
-      (%:==) SCC SCM = SFalse
-      (%:==) SCC SCN = SFalse
-      (%:==) SCC SCO = SFalse
-      (%:==) SCC SCP = SFalse
-      (%:==) SCC SCQ = SFalse
-      (%:==) SCC SCR = SFalse
-      (%:==) SCC SCS = SFalse
-      (%:==) SCC SCT = SFalse
-      (%:==) SCC SCU = SFalse
-      (%:==) SCC SCV = SFalse
-      (%:==) SCC SCW = SFalse
-      (%:==) SCC SCX = SFalse
-      (%:==) SCC SCY = SFalse
-      (%:==) SCC SCZ = SFalse
-      (%:==) SCD SCA = SFalse
-      (%:==) SCD SCB = SFalse
-      (%:==) SCD SCC = SFalse
-      (%:==) SCD SCD = STrue
-      (%:==) SCD SCE = SFalse
-      (%:==) SCD SCF = SFalse
-      (%:==) SCD SCG = SFalse
-      (%:==) SCD SCH = SFalse
-      (%:==) SCD SCI = SFalse
-      (%:==) SCD SCJ = SFalse
-      (%:==) SCD SCK = SFalse
-      (%:==) SCD SCL = SFalse
-      (%:==) SCD SCM = SFalse
-      (%:==) SCD SCN = SFalse
-      (%:==) SCD SCO = SFalse
-      (%:==) SCD SCP = SFalse
-      (%:==) SCD SCQ = SFalse
-      (%:==) SCD SCR = SFalse
-      (%:==) SCD SCS = SFalse
-      (%:==) SCD SCT = SFalse
-      (%:==) SCD SCU = SFalse
-      (%:==) SCD SCV = SFalse
-      (%:==) SCD SCW = SFalse
-      (%:==) SCD SCX = SFalse
-      (%:==) SCD SCY = SFalse
-      (%:==) SCD SCZ = SFalse
-      (%:==) SCE SCA = SFalse
-      (%:==) SCE SCB = SFalse
-      (%:==) SCE SCC = SFalse
-      (%:==) SCE SCD = SFalse
-      (%:==) SCE SCE = STrue
-      (%:==) SCE SCF = SFalse
-      (%:==) SCE SCG = SFalse
-      (%:==) SCE SCH = SFalse
-      (%:==) SCE SCI = SFalse
-      (%:==) SCE SCJ = SFalse
-      (%:==) SCE SCK = SFalse
-      (%:==) SCE SCL = SFalse
-      (%:==) SCE SCM = SFalse
-      (%:==) SCE SCN = SFalse
-      (%:==) SCE SCO = SFalse
-      (%:==) SCE SCP = SFalse
-      (%:==) SCE SCQ = SFalse
-      (%:==) SCE SCR = SFalse
-      (%:==) SCE SCS = SFalse
-      (%:==) SCE SCT = SFalse
-      (%:==) SCE SCU = SFalse
-      (%:==) SCE SCV = SFalse
-      (%:==) SCE SCW = SFalse
-      (%:==) SCE SCX = SFalse
-      (%:==) SCE SCY = SFalse
-      (%:==) SCE SCZ = SFalse
-      (%:==) SCF SCA = SFalse
-      (%:==) SCF SCB = SFalse
-      (%:==) SCF SCC = SFalse
-      (%:==) SCF SCD = SFalse
-      (%:==) SCF SCE = SFalse
-      (%:==) SCF SCF = STrue
-      (%:==) SCF SCG = SFalse
-      (%:==) SCF SCH = SFalse
-      (%:==) SCF SCI = SFalse
-      (%:==) SCF SCJ = SFalse
-      (%:==) SCF SCK = SFalse
-      (%:==) SCF SCL = SFalse
-      (%:==) SCF SCM = SFalse
-      (%:==) SCF SCN = SFalse
-      (%:==) SCF SCO = SFalse
-      (%:==) SCF SCP = SFalse
-      (%:==) SCF SCQ = SFalse
-      (%:==) SCF SCR = SFalse
-      (%:==) SCF SCS = SFalse
-      (%:==) SCF SCT = SFalse
-      (%:==) SCF SCU = SFalse
-      (%:==) SCF SCV = SFalse
-      (%:==) SCF SCW = SFalse
-      (%:==) SCF SCX = SFalse
-      (%:==) SCF SCY = SFalse
-      (%:==) SCF SCZ = SFalse
-      (%:==) SCG SCA = SFalse
-      (%:==) SCG SCB = SFalse
-      (%:==) SCG SCC = SFalse
-      (%:==) SCG SCD = SFalse
-      (%:==) SCG SCE = SFalse
-      (%:==) SCG SCF = SFalse
-      (%:==) SCG SCG = STrue
-      (%:==) SCG SCH = SFalse
-      (%:==) SCG SCI = SFalse
-      (%:==) SCG SCJ = SFalse
-      (%:==) SCG SCK = SFalse
-      (%:==) SCG SCL = SFalse
-      (%:==) SCG SCM = SFalse
-      (%:==) SCG SCN = SFalse
-      (%:==) SCG SCO = SFalse
-      (%:==) SCG SCP = SFalse
-      (%:==) SCG SCQ = SFalse
-      (%:==) SCG SCR = SFalse
-      (%:==) SCG SCS = SFalse
-      (%:==) SCG SCT = SFalse
-      (%:==) SCG SCU = SFalse
-      (%:==) SCG SCV = SFalse
-      (%:==) SCG SCW = SFalse
-      (%:==) SCG SCX = SFalse
-      (%:==) SCG SCY = SFalse
-      (%:==) SCG SCZ = SFalse
-      (%:==) SCH SCA = SFalse
-      (%:==) SCH SCB = SFalse
-      (%:==) SCH SCC = SFalse
-      (%:==) SCH SCD = SFalse
-      (%:==) SCH SCE = SFalse
-      (%:==) SCH SCF = SFalse
-      (%:==) SCH SCG = SFalse
-      (%:==) SCH SCH = STrue
-      (%:==) SCH SCI = SFalse
-      (%:==) SCH SCJ = SFalse
-      (%:==) SCH SCK = SFalse
-      (%:==) SCH SCL = SFalse
-      (%:==) SCH SCM = SFalse
-      (%:==) SCH SCN = SFalse
-      (%:==) SCH SCO = SFalse
-      (%:==) SCH SCP = SFalse
-      (%:==) SCH SCQ = SFalse
-      (%:==) SCH SCR = SFalse
-      (%:==) SCH SCS = SFalse
-      (%:==) SCH SCT = SFalse
-      (%:==) SCH SCU = SFalse
-      (%:==) SCH SCV = SFalse
-      (%:==) SCH SCW = SFalse
-      (%:==) SCH SCX = SFalse
-      (%:==) SCH SCY = SFalse
-      (%:==) SCH SCZ = SFalse
-      (%:==) SCI SCA = SFalse
-      (%:==) SCI SCB = SFalse
-      (%:==) SCI SCC = SFalse
-      (%:==) SCI SCD = SFalse
-      (%:==) SCI SCE = SFalse
-      (%:==) SCI SCF = SFalse
-      (%:==) SCI SCG = SFalse
-      (%:==) SCI SCH = SFalse
-      (%:==) SCI SCI = STrue
-      (%:==) SCI SCJ = SFalse
-      (%:==) SCI SCK = SFalse
-      (%:==) SCI SCL = SFalse
-      (%:==) SCI SCM = SFalse
-      (%:==) SCI SCN = SFalse
-      (%:==) SCI SCO = SFalse
-      (%:==) SCI SCP = SFalse
-      (%:==) SCI SCQ = SFalse
-      (%:==) SCI SCR = SFalse
-      (%:==) SCI SCS = SFalse
-      (%:==) SCI SCT = SFalse
-      (%:==) SCI SCU = SFalse
-      (%:==) SCI SCV = SFalse
-      (%:==) SCI SCW = SFalse
-      (%:==) SCI SCX = SFalse
-      (%:==) SCI SCY = SFalse
-      (%:==) SCI SCZ = SFalse
-      (%:==) SCJ SCA = SFalse
-      (%:==) SCJ SCB = SFalse
-      (%:==) SCJ SCC = SFalse
-      (%:==) SCJ SCD = SFalse
-      (%:==) SCJ SCE = SFalse
-      (%:==) SCJ SCF = SFalse
-      (%:==) SCJ SCG = SFalse
-      (%:==) SCJ SCH = SFalse
-      (%:==) SCJ SCI = SFalse
-      (%:==) SCJ SCJ = STrue
-      (%:==) SCJ SCK = SFalse
-      (%:==) SCJ SCL = SFalse
-      (%:==) SCJ SCM = SFalse
-      (%:==) SCJ SCN = SFalse
-      (%:==) SCJ SCO = SFalse
-      (%:==) SCJ SCP = SFalse
-      (%:==) SCJ SCQ = SFalse
-      (%:==) SCJ SCR = SFalse
-      (%:==) SCJ SCS = SFalse
-      (%:==) SCJ SCT = SFalse
-      (%:==) SCJ SCU = SFalse
-      (%:==) SCJ SCV = SFalse
-      (%:==) SCJ SCW = SFalse
-      (%:==) SCJ SCX = SFalse
-      (%:==) SCJ SCY = SFalse
-      (%:==) SCJ SCZ = SFalse
-      (%:==) SCK SCA = SFalse
-      (%:==) SCK SCB = SFalse
-      (%:==) SCK SCC = SFalse
-      (%:==) SCK SCD = SFalse
-      (%:==) SCK SCE = SFalse
-      (%:==) SCK SCF = SFalse
-      (%:==) SCK SCG = SFalse
-      (%:==) SCK SCH = SFalse
-      (%:==) SCK SCI = SFalse
-      (%:==) SCK SCJ = SFalse
-      (%:==) SCK SCK = STrue
-      (%:==) SCK SCL = SFalse
-      (%:==) SCK SCM = SFalse
-      (%:==) SCK SCN = SFalse
-      (%:==) SCK SCO = SFalse
-      (%:==) SCK SCP = SFalse
-      (%:==) SCK SCQ = SFalse
-      (%:==) SCK SCR = SFalse
-      (%:==) SCK SCS = SFalse
-      (%:==) SCK SCT = SFalse
-      (%:==) SCK SCU = SFalse
-      (%:==) SCK SCV = SFalse
-      (%:==) SCK SCW = SFalse
-      (%:==) SCK SCX = SFalse
-      (%:==) SCK SCY = SFalse
-      (%:==) SCK SCZ = SFalse
-      (%:==) SCL SCA = SFalse
-      (%:==) SCL SCB = SFalse
-      (%:==) SCL SCC = SFalse
-      (%:==) SCL SCD = SFalse
-      (%:==) SCL SCE = SFalse
-      (%:==) SCL SCF = SFalse
-      (%:==) SCL SCG = SFalse
-      (%:==) SCL SCH = SFalse
-      (%:==) SCL SCI = SFalse
-      (%:==) SCL SCJ = SFalse
-      (%:==) SCL SCK = SFalse
-      (%:==) SCL SCL = STrue
-      (%:==) SCL SCM = SFalse
-      (%:==) SCL SCN = SFalse
-      (%:==) SCL SCO = SFalse
-      (%:==) SCL SCP = SFalse
-      (%:==) SCL SCQ = SFalse
-      (%:==) SCL SCR = SFalse
-      (%:==) SCL SCS = SFalse
-      (%:==) SCL SCT = SFalse
-      (%:==) SCL SCU = SFalse
-      (%:==) SCL SCV = SFalse
-      (%:==) SCL SCW = SFalse
-      (%:==) SCL SCX = SFalse
-      (%:==) SCL SCY = SFalse
-      (%:==) SCL SCZ = SFalse
-      (%:==) SCM SCA = SFalse
-      (%:==) SCM SCB = SFalse
-      (%:==) SCM SCC = SFalse
-      (%:==) SCM SCD = SFalse
-      (%:==) SCM SCE = SFalse
-      (%:==) SCM SCF = SFalse
-      (%:==) SCM SCG = SFalse
-      (%:==) SCM SCH = SFalse
-      (%:==) SCM SCI = SFalse
-      (%:==) SCM SCJ = SFalse
-      (%:==) SCM SCK = SFalse
-      (%:==) SCM SCL = SFalse
-      (%:==) SCM SCM = STrue
-      (%:==) SCM SCN = SFalse
-      (%:==) SCM SCO = SFalse
-      (%:==) SCM SCP = SFalse
-      (%:==) SCM SCQ = SFalse
-      (%:==) SCM SCR = SFalse
-      (%:==) SCM SCS = SFalse
-      (%:==) SCM SCT = SFalse
-      (%:==) SCM SCU = SFalse
-      (%:==) SCM SCV = SFalse
-      (%:==) SCM SCW = SFalse
-      (%:==) SCM SCX = SFalse
-      (%:==) SCM SCY = SFalse
-      (%:==) SCM SCZ = SFalse
-      (%:==) SCN SCA = SFalse
-      (%:==) SCN SCB = SFalse
-      (%:==) SCN SCC = SFalse
-      (%:==) SCN SCD = SFalse
-      (%:==) SCN SCE = SFalse
-      (%:==) SCN SCF = SFalse
-      (%:==) SCN SCG = SFalse
-      (%:==) SCN SCH = SFalse
-      (%:==) SCN SCI = SFalse
-      (%:==) SCN SCJ = SFalse
-      (%:==) SCN SCK = SFalse
-      (%:==) SCN SCL = SFalse
-      (%:==) SCN SCM = SFalse
-      (%:==) SCN SCN = STrue
-      (%:==) SCN SCO = SFalse
-      (%:==) SCN SCP = SFalse
-      (%:==) SCN SCQ = SFalse
-      (%:==) SCN SCR = SFalse
-      (%:==) SCN SCS = SFalse
-      (%:==) SCN SCT = SFalse
-      (%:==) SCN SCU = SFalse
-      (%:==) SCN SCV = SFalse
-      (%:==) SCN SCW = SFalse
-      (%:==) SCN SCX = SFalse
-      (%:==) SCN SCY = SFalse
-      (%:==) SCN SCZ = SFalse
-      (%:==) SCO SCA = SFalse
-      (%:==) SCO SCB = SFalse
-      (%:==) SCO SCC = SFalse
-      (%:==) SCO SCD = SFalse
-      (%:==) SCO SCE = SFalse
-      (%:==) SCO SCF = SFalse
-      (%:==) SCO SCG = SFalse
-      (%:==) SCO SCH = SFalse
-      (%:==) SCO SCI = SFalse
-      (%:==) SCO SCJ = SFalse
-      (%:==) SCO SCK = SFalse
-      (%:==) SCO SCL = SFalse
-      (%:==) SCO SCM = SFalse
-      (%:==) SCO SCN = SFalse
-      (%:==) SCO SCO = STrue
-      (%:==) SCO SCP = SFalse
-      (%:==) SCO SCQ = SFalse
-      (%:==) SCO SCR = SFalse
-      (%:==) SCO SCS = SFalse
-      (%:==) SCO SCT = SFalse
-      (%:==) SCO SCU = SFalse
-      (%:==) SCO SCV = SFalse
-      (%:==) SCO SCW = SFalse
-      (%:==) SCO SCX = SFalse
-      (%:==) SCO SCY = SFalse
-      (%:==) SCO SCZ = SFalse
-      (%:==) SCP SCA = SFalse
-      (%:==) SCP SCB = SFalse
-      (%:==) SCP SCC = SFalse
-      (%:==) SCP SCD = SFalse
-      (%:==) SCP SCE = SFalse
-      (%:==) SCP SCF = SFalse
-      (%:==) SCP SCG = SFalse
-      (%:==) SCP SCH = SFalse
-      (%:==) SCP SCI = SFalse
-      (%:==) SCP SCJ = SFalse
-      (%:==) SCP SCK = SFalse
-      (%:==) SCP SCL = SFalse
-      (%:==) SCP SCM = SFalse
-      (%:==) SCP SCN = SFalse
-      (%:==) SCP SCO = SFalse
-      (%:==) SCP SCP = STrue
-      (%:==) SCP SCQ = SFalse
-      (%:==) SCP SCR = SFalse
-      (%:==) SCP SCS = SFalse
-      (%:==) SCP SCT = SFalse
-      (%:==) SCP SCU = SFalse
-      (%:==) SCP SCV = SFalse
-      (%:==) SCP SCW = SFalse
-      (%:==) SCP SCX = SFalse
-      (%:==) SCP SCY = SFalse
-      (%:==) SCP SCZ = SFalse
-      (%:==) SCQ SCA = SFalse
-      (%:==) SCQ SCB = SFalse
-      (%:==) SCQ SCC = SFalse
-      (%:==) SCQ SCD = SFalse
-      (%:==) SCQ SCE = SFalse
-      (%:==) SCQ SCF = SFalse
-      (%:==) SCQ SCG = SFalse
-      (%:==) SCQ SCH = SFalse
-      (%:==) SCQ SCI = SFalse
-      (%:==) SCQ SCJ = SFalse
-      (%:==) SCQ SCK = SFalse
-      (%:==) SCQ SCL = SFalse
-      (%:==) SCQ SCM = SFalse
-      (%:==) SCQ SCN = SFalse
-      (%:==) SCQ SCO = SFalse
-      (%:==) SCQ SCP = SFalse
-      (%:==) SCQ SCQ = STrue
-      (%:==) SCQ SCR = SFalse
-      (%:==) SCQ SCS = SFalse
-      (%:==) SCQ SCT = SFalse
-      (%:==) SCQ SCU = SFalse
-      (%:==) SCQ SCV = SFalse
-      (%:==) SCQ SCW = SFalse
-      (%:==) SCQ SCX = SFalse
-      (%:==) SCQ SCY = SFalse
-      (%:==) SCQ SCZ = SFalse
-      (%:==) SCR SCA = SFalse
-      (%:==) SCR SCB = SFalse
-      (%:==) SCR SCC = SFalse
-      (%:==) SCR SCD = SFalse
-      (%:==) SCR SCE = SFalse
-      (%:==) SCR SCF = SFalse
-      (%:==) SCR SCG = SFalse
-      (%:==) SCR SCH = SFalse
-      (%:==) SCR SCI = SFalse
-      (%:==) SCR SCJ = SFalse
-      (%:==) SCR SCK = SFalse
-      (%:==) SCR SCL = SFalse
-      (%:==) SCR SCM = SFalse
-      (%:==) SCR SCN = SFalse
-      (%:==) SCR SCO = SFalse
-      (%:==) SCR SCP = SFalse
-      (%:==) SCR SCQ = SFalse
-      (%:==) SCR SCR = STrue
-      (%:==) SCR SCS = SFalse
-      (%:==) SCR SCT = SFalse
-      (%:==) SCR SCU = SFalse
-      (%:==) SCR SCV = SFalse
-      (%:==) SCR SCW = SFalse
-      (%:==) SCR SCX = SFalse
-      (%:==) SCR SCY = SFalse
-      (%:==) SCR SCZ = SFalse
-      (%:==) SCS SCA = SFalse
-      (%:==) SCS SCB = SFalse
-      (%:==) SCS SCC = SFalse
-      (%:==) SCS SCD = SFalse
-      (%:==) SCS SCE = SFalse
-      (%:==) SCS SCF = SFalse
-      (%:==) SCS SCG = SFalse
-      (%:==) SCS SCH = SFalse
-      (%:==) SCS SCI = SFalse
-      (%:==) SCS SCJ = SFalse
-      (%:==) SCS SCK = SFalse
-      (%:==) SCS SCL = SFalse
-      (%:==) SCS SCM = SFalse
-      (%:==) SCS SCN = SFalse
-      (%:==) SCS SCO = SFalse
-      (%:==) SCS SCP = SFalse
-      (%:==) SCS SCQ = SFalse
-      (%:==) SCS SCR = SFalse
-      (%:==) SCS SCS = STrue
-      (%:==) SCS SCT = SFalse
-      (%:==) SCS SCU = SFalse
-      (%:==) SCS SCV = SFalse
-      (%:==) SCS SCW = SFalse
-      (%:==) SCS SCX = SFalse
-      (%:==) SCS SCY = SFalse
-      (%:==) SCS SCZ = SFalse
-      (%:==) SCT SCA = SFalse
-      (%:==) SCT SCB = SFalse
-      (%:==) SCT SCC = SFalse
-      (%:==) SCT SCD = SFalse
-      (%:==) SCT SCE = SFalse
-      (%:==) SCT SCF = SFalse
-      (%:==) SCT SCG = SFalse
-      (%:==) SCT SCH = SFalse
-      (%:==) SCT SCI = SFalse
-      (%:==) SCT SCJ = SFalse
-      (%:==) SCT SCK = SFalse
-      (%:==) SCT SCL = SFalse
-      (%:==) SCT SCM = SFalse
-      (%:==) SCT SCN = SFalse
-      (%:==) SCT SCO = SFalse
-      (%:==) SCT SCP = SFalse
-      (%:==) SCT SCQ = SFalse
-      (%:==) SCT SCR = SFalse
-      (%:==) SCT SCS = SFalse
-      (%:==) SCT SCT = STrue
-      (%:==) SCT SCU = SFalse
-      (%:==) SCT SCV = SFalse
-      (%:==) SCT SCW = SFalse
-      (%:==) SCT SCX = SFalse
-      (%:==) SCT SCY = SFalse
-      (%:==) SCT SCZ = SFalse
-      (%:==) SCU SCA = SFalse
-      (%:==) SCU SCB = SFalse
-      (%:==) SCU SCC = SFalse
-      (%:==) SCU SCD = SFalse
-      (%:==) SCU SCE = SFalse
-      (%:==) SCU SCF = SFalse
-      (%:==) SCU SCG = SFalse
-      (%:==) SCU SCH = SFalse
-      (%:==) SCU SCI = SFalse
-      (%:==) SCU SCJ = SFalse
-      (%:==) SCU SCK = SFalse
-      (%:==) SCU SCL = SFalse
-      (%:==) SCU SCM = SFalse
-      (%:==) SCU SCN = SFalse
-      (%:==) SCU SCO = SFalse
-      (%:==) SCU SCP = SFalse
-      (%:==) SCU SCQ = SFalse
-      (%:==) SCU SCR = SFalse
-      (%:==) SCU SCS = SFalse
-      (%:==) SCU SCT = SFalse
-      (%:==) SCU SCU = STrue
-      (%:==) SCU SCV = SFalse
-      (%:==) SCU SCW = SFalse
-      (%:==) SCU SCX = SFalse
-      (%:==) SCU SCY = SFalse
-      (%:==) SCU SCZ = SFalse
-      (%:==) SCV SCA = SFalse
-      (%:==) SCV SCB = SFalse
-      (%:==) SCV SCC = SFalse
-      (%:==) SCV SCD = SFalse
-      (%:==) SCV SCE = SFalse
-      (%:==) SCV SCF = SFalse
-      (%:==) SCV SCG = SFalse
-      (%:==) SCV SCH = SFalse
-      (%:==) SCV SCI = SFalse
-      (%:==) SCV SCJ = SFalse
-      (%:==) SCV SCK = SFalse
-      (%:==) SCV SCL = SFalse
-      (%:==) SCV SCM = SFalse
-      (%:==) SCV SCN = SFalse
-      (%:==) SCV SCO = SFalse
-      (%:==) SCV SCP = SFalse
-      (%:==) SCV SCQ = SFalse
-      (%:==) SCV SCR = SFalse
-      (%:==) SCV SCS = SFalse
-      (%:==) SCV SCT = SFalse
-      (%:==) SCV SCU = SFalse
-      (%:==) SCV SCV = STrue
-      (%:==) SCV SCW = SFalse
-      (%:==) SCV SCX = SFalse
-      (%:==) SCV SCY = SFalse
-      (%:==) SCV SCZ = SFalse
-      (%:==) SCW SCA = SFalse
-      (%:==) SCW SCB = SFalse
-      (%:==) SCW SCC = SFalse
-      (%:==) SCW SCD = SFalse
-      (%:==) SCW SCE = SFalse
-      (%:==) SCW SCF = SFalse
-      (%:==) SCW SCG = SFalse
-      (%:==) SCW SCH = SFalse
-      (%:==) SCW SCI = SFalse
-      (%:==) SCW SCJ = SFalse
-      (%:==) SCW SCK = SFalse
-      (%:==) SCW SCL = SFalse
-      (%:==) SCW SCM = SFalse
-      (%:==) SCW SCN = SFalse
-      (%:==) SCW SCO = SFalse
-      (%:==) SCW SCP = SFalse
-      (%:==) SCW SCQ = SFalse
-      (%:==) SCW SCR = SFalse
-      (%:==) SCW SCS = SFalse
-      (%:==) SCW SCT = SFalse
-      (%:==) SCW SCU = SFalse
-      (%:==) SCW SCV = SFalse
-      (%:==) SCW SCW = STrue
-      (%:==) SCW SCX = SFalse
-      (%:==) SCW SCY = SFalse
-      (%:==) SCW SCZ = SFalse
-      (%:==) SCX SCA = SFalse
-      (%:==) SCX SCB = SFalse
-      (%:==) SCX SCC = SFalse
-      (%:==) SCX SCD = SFalse
-      (%:==) SCX SCE = SFalse
-      (%:==) SCX SCF = SFalse
-      (%:==) SCX SCG = SFalse
-      (%:==) SCX SCH = SFalse
-      (%:==) SCX SCI = SFalse
-      (%:==) SCX SCJ = SFalse
-      (%:==) SCX SCK = SFalse
-      (%:==) SCX SCL = SFalse
-      (%:==) SCX SCM = SFalse
-      (%:==) SCX SCN = SFalse
-      (%:==) SCX SCO = SFalse
-      (%:==) SCX SCP = SFalse
-      (%:==) SCX SCQ = SFalse
-      (%:==) SCX SCR = SFalse
-      (%:==) SCX SCS = SFalse
-      (%:==) SCX SCT = SFalse
-      (%:==) SCX SCU = SFalse
-      (%:==) SCX SCV = SFalse
-      (%:==) SCX SCW = SFalse
-      (%:==) SCX SCX = STrue
-      (%:==) SCX SCY = SFalse
-      (%:==) SCX SCZ = SFalse
-      (%:==) SCY SCA = SFalse
-      (%:==) SCY SCB = SFalse
-      (%:==) SCY SCC = SFalse
-      (%:==) SCY SCD = SFalse
-      (%:==) SCY SCE = SFalse
-      (%:==) SCY SCF = SFalse
-      (%:==) SCY SCG = SFalse
-      (%:==) SCY SCH = SFalse
-      (%:==) SCY SCI = SFalse
-      (%:==) SCY SCJ = SFalse
-      (%:==) SCY SCK = SFalse
-      (%:==) SCY SCL = SFalse
-      (%:==) SCY SCM = SFalse
-      (%:==) SCY SCN = SFalse
-      (%:==) SCY SCO = SFalse
-      (%:==) SCY SCP = SFalse
-      (%:==) SCY SCQ = SFalse
-      (%:==) SCY SCR = SFalse
-      (%:==) SCY SCS = SFalse
-      (%:==) SCY SCT = SFalse
-      (%:==) SCY SCU = SFalse
-      (%:==) SCY SCV = SFalse
-      (%:==) SCY SCW = SFalse
-      (%:==) SCY SCX = SFalse
-      (%:==) SCY SCY = STrue
-      (%:==) SCY SCZ = SFalse
-      (%:==) SCZ SCA = SFalse
-      (%:==) SCZ SCB = SFalse
-      (%:==) SCZ SCC = SFalse
-      (%:==) SCZ SCD = SFalse
-      (%:==) SCZ SCE = SFalse
-      (%:==) SCZ SCF = SFalse
-      (%:==) SCZ SCG = SFalse
-      (%:==) SCZ SCH = SFalse
-      (%:==) SCZ SCI = SFalse
-      (%:==) SCZ SCJ = SFalse
-      (%:==) SCZ SCK = SFalse
-      (%:==) SCZ SCL = SFalse
-      (%:==) SCZ SCM = SFalse
-      (%:==) SCZ SCN = SFalse
-      (%:==) SCZ SCO = SFalse
-      (%:==) SCZ SCP = SFalse
-      (%:==) SCZ SCQ = SFalse
-      (%:==) SCZ SCR = SFalse
-      (%:==) SCZ SCS = SFalse
-      (%:==) SCZ SCT = SFalse
-      (%:==) SCZ SCU = SFalse
-      (%:==) SCZ SCV = SFalse
-      (%:==) SCZ SCW = SFalse
-      (%:==) SCZ SCX = SFalse
-      (%:==) SCZ SCY = SFalse
-      (%:==) SCZ SCZ = STrue
-    instance SDecide (KProxy :: KProxy AChar) where
-      (%~) SCA SCA = Proved Refl
-      (%~) SCA SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCA SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCB = Proved Refl
-      (%~) SCB SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCB SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCC = Proved Refl
-      (%~) SCC SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCC SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCD = Proved Refl
-      (%~) SCD SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCD SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCE = Proved Refl
-      (%~) SCE SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCE SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCF = Proved Refl
-      (%~) SCF SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCF SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCG = Proved Refl
-      (%~) SCG SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCG SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCH = Proved Refl
-      (%~) SCH SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCH SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCI = Proved Refl
-      (%~) SCI SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCI SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCJ = Proved Refl
-      (%~) SCJ SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCJ SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCK = Proved Refl
-      (%~) SCK SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCK SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCL = Proved Refl
-      (%~) SCL SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCL SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCM = Proved Refl
-      (%~) SCM SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCM SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCN = Proved Refl
-      (%~) SCN SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCN SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCO = Proved Refl
-      (%~) SCO SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCO SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCP = Proved Refl
-      (%~) SCP SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCP SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCQ = Proved Refl
-      (%~) SCQ SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCQ SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCR = Proved Refl
-      (%~) SCR SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCR SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCS = Proved Refl
-      (%~) SCS SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCS SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCT = Proved Refl
-      (%~) SCT SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCT SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCU = Proved Refl
-      (%~) SCU SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCU SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCV = Proved Refl
-      (%~) SCV SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCV SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCW = Proved Refl
-      (%~) SCW SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCW SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCX = Proved Refl
-      (%~) SCX SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCX SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCY SCY = Proved Refl
-      (%~) SCY SCZ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCA
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCB
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCC
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCD
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCE
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCF
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCG
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCH
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCI
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCJ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCK
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCL
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCM
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCN
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCO
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCP
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCQ
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCR
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCS
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCT
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCU
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCV
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCW
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCX
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCY
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SCZ SCZ = Proved Refl
-    data instance Sing (z :: Attribute)
-      = forall (n :: [AChar]) (n :: U). z ~ Attr n n =>
-        SAttr (Sing n) (Sing n)
-    type SAttribute (z :: Attribute) = Sing z
-    instance SingKind (KProxy :: KProxy Attribute) where
-      type DemoteRep (KProxy :: KProxy Attribute) = Attribute
-      fromSing (SAttr b b) = Attr (fromSing b) (fromSing b)
-      toSing (Attr b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy [AChar]))
-                (toSing b :: SomeSing (KProxy :: KProxy U))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SAttr c c) }
-    data instance Sing (z :: Schema)
-      = forall (n :: [Attribute]). z ~ Sch n => SSch (Sing n)
-    type SSchema (z :: Schema) = Sing z
-    instance SingKind (KProxy :: KProxy Schema) where
-      type DemoteRep (KProxy :: KProxy Schema) = Schema
-      fromSing (SSch b) = Sch (fromSing b)
-      toSing (Sch b)
-        = case toSing b :: SomeSing (KProxy :: KProxy [Attribute]) of {
-            SomeSing c -> SomeSing (SSch c) }
-    instance SingI BOOL where
-      sing = SBOOL
-    instance SingI STRING where
-      sing = SSTRING
-    instance SingI NAT where
-      sing = SNAT
-    instance (SingI n, SingI n) =>
-             SingI (VEC (n :: U) (n :: Nat)) where
-      sing = SVEC sing sing
-    instance SingI CA where
-      sing = SCA
-    instance SingI CB where
-      sing = SCB
-    instance SingI CC where
-      sing = SCC
-    instance SingI CD where
-      sing = SCD
-    instance SingI CE where
-      sing = SCE
-    instance SingI CF where
-      sing = SCF
-    instance SingI CG where
-      sing = SCG
-    instance SingI CH where
-      sing = SCH
-    instance SingI CI where
-      sing = SCI
-    instance SingI CJ where
-      sing = SCJ
-    instance SingI CK where
-      sing = SCK
-    instance SingI CL where
-      sing = SCL
-    instance SingI CM where
-      sing = SCM
-    instance SingI CN where
-      sing = SCN
-    instance SingI CO where
-      sing = SCO
-    instance SingI CP where
-      sing = SCP
-    instance SingI CQ where
-      sing = SCQ
-    instance SingI CR where
-      sing = SCR
-    instance SingI CS where
-      sing = SCS
-    instance SingI CT where
-      sing = SCT
-    instance SingI CU where
-      sing = SCU
-    instance SingI CV where
-      sing = SCV
-    instance SingI CW where
-      sing = SCW
-    instance SingI CX where
-      sing = SCX
-    instance SingI CY where
-      sing = SCY
-    instance SingI CZ where
-      sing = SCZ
-    instance (SingI n, SingI n) =>
-             SingI (Attr (n :: [AChar]) (n :: U)) where
-      sing = SAttr sing sing
-    instance SingI n => SingI (Sch (n :: [Attribute])) where
-      sing = SSch sing
-GradingClient/Database.hs:0:0: Splicing declarations
-    return [] ======> GradingClient/Database.hs:0:0:
-GradingClient/Database.hs:(0,0)-(0,0): Splicing expression
-    cases ''Row [| r |] [| changeId (n ++ (getId r)) r |]
-  ======>
-    case r of {
-      EmptyRow _ -> changeId ((++) n (getId r)) r
-      ConsRow _ _ -> changeId ((++) n (getId r)) r }
diff --git a/tests/compile-and-dump/GradingClient/Database.hs b/tests/compile-and-dump/GradingClient/Database.hs
--- a/tests/compile-and-dump/GradingClient/Database.hs
+++ b/tests/compile-and-dump/GradingClient/Database.hs
@@ -11,7 +11,7 @@
 {-# LANGUAGE PolyKinds, DataKinds, TemplateHaskell, TypeFamilies,
     GADTs, TypeOperators, RankNTypes, FlexibleContexts, UndecidableInstances,
     FlexibleInstances, ScopedTypeVariables, MultiParamTypeClasses,
-    OverlappingInstances, ConstraintKinds, CPP #-}
+    ConstraintKinds, CPP #-}
 {-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
 
 -- The OverlappingInstances is needed only to allow the InC and SubsetC classes.
@@ -28,7 +28,12 @@
 import Data.Singletons.TH
 import Control.Monad
 import Data.List hiding ( tail )
-import Control.Monad.Error
+
+#ifdef MODERN_MTL
+import Control.Monad.Except  ( throwError )
+#else
+import Control.Monad.Error   ( throwError )
+#endif
 
 $(singletons [d|
   -- Basic Nat type
diff --git a/tests/compile-and-dump/GradingClient/Main.ghc710.template b/tests/compile-and-dump/GradingClient/Main.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/GradingClient/Main.ghc710.template
@@ -0,0 +1,162 @@
+GradingClient/Main.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| lastName, firstName, yearName, gradeName, majorName :: [AChar]
+          lastName = [CL, CA, CS, CT]
+          firstName = [CF, CI, CR, CS, CT]
+          yearName = [CY, CE, CA, CR]
+          gradeName = [CG, CR, CA, CD, CE]
+          majorName = [CM, CA, CJ, CO, CR]
+          gradingSchema :: Schema
+          gradingSchema
+            = Sch
+                [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT,
+                 Attr gradeName NAT, Attr majorName BOOL]
+          names :: Schema
+          names = Sch [Attr firstName STRING, Attr lastName STRING] |]
+  ======>
+    lastName :: [AChar]
+    firstName :: [AChar]
+    yearName :: [AChar]
+    gradeName :: [AChar]
+    majorName :: [AChar]
+    lastName = [CL, CA, CS, CT]
+    firstName = [CF, CI, CR, CS, CT]
+    yearName = [CY, CE, CA, CR]
+    gradeName = [CG, CR, CA, CD, CE]
+    majorName = [CM, CA, CJ, CO, CR]
+    gradingSchema :: Schema
+    gradingSchema
+      = Sch
+          [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT,
+           Attr gradeName NAT, Attr majorName BOOL]
+    names :: Schema
+    names = Sch [Attr firstName STRING, Attr lastName STRING]
+    type MajorNameSym0 = MajorName
+    type GradeNameSym0 = GradeName
+    type YearNameSym0 = YearName
+    type FirstNameSym0 = FirstName
+    type LastNameSym0 = LastName
+    type GradingSchemaSym0 = GradingSchema
+    type NamesSym0 = Names
+    type family MajorName :: [AChar] where
+      MajorName = Apply (Apply (:$) CMSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CJSym0) (Apply (Apply (:$) COSym0) (Apply (Apply (:$) CRSym0) '[]))))
+    type family GradeName :: [AChar] where
+      GradeName = Apply (Apply (:$) CGSym0) (Apply (Apply (:$) CRSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CDSym0) (Apply (Apply (:$) CESym0) '[]))))
+    type family YearName :: [AChar] where
+      YearName = Apply (Apply (:$) CYSym0) (Apply (Apply (:$) CESym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CRSym0) '[])))
+    type family FirstName :: [AChar] where
+      FirstName = Apply (Apply (:$) CFSym0) (Apply (Apply (:$) CISym0) (Apply (Apply (:$) CRSym0) (Apply (Apply (:$) CSSym0) (Apply (Apply (:$) CTSym0) '[]))))
+    type family LastName :: [AChar] where
+      LastName = Apply (Apply (:$) CLSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CSSym0) (Apply (Apply (:$) CTSym0) '[])))
+    type family GradingSchema :: Schema where
+      GradingSchema = Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 YearNameSym0) NATSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 GradeNameSym0) NATSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 MajorNameSym0) BOOLSym0)) '[])))))
+    type family Names :: Schema where
+      Names = Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) '[]))
+    sMajorName :: Sing (MajorNameSym0 :: [AChar])
+    sGradeName :: Sing (GradeNameSym0 :: [AChar])
+    sYearName :: Sing (YearNameSym0 :: [AChar])
+    sFirstName :: Sing (FirstNameSym0 :: [AChar])
+    sLastName :: Sing (LastNameSym0 :: [AChar])
+    sGradingSchema :: Sing (GradingSchemaSym0 :: Schema)
+    sNames :: Sing (NamesSym0 :: Schema)
+    sMajorName
+      = applySing
+          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCM)
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA)
+             (applySing
+                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCJ)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCO)
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR) SNil))))
+    sGradeName
+      = applySing
+          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCG)
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR)
+             (applySing
+                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCD)
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCE) SNil))))
+    sYearName
+      = applySing
+          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCY)
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCE)
+             (applySing
+                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR) SNil)))
+    sFirstName
+      = applySing
+          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCF)
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCI)
+             (applySing
+                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCS)
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCT) SNil))))
+    sLastName
+      = applySing
+          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCL)
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA)
+             (applySing
+                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCS)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCT) SNil)))
+    sGradingSchema
+      = applySing
+          (singFun1 (Proxy :: Proxy SchSym0) SSch)
+          (applySing
+             (applySing
+                (singFun2 (Proxy :: Proxy (:$)) SCons)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sLastName)
+                   SSTRING))
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sFirstName)
+                      SSTRING))
+                (applySing
+                   (applySing
+                      (singFun2 (Proxy :: Proxy (:$)) SCons)
+                      (applySing
+                         (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sYearName)
+                         SNAT))
+                   (applySing
+                      (applySing
+                         (singFun2 (Proxy :: Proxy (:$)) SCons)
+                         (applySing
+                            (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sGradeName)
+                            SNAT))
+                      (applySing
+                         (applySing
+                            (singFun2 (Proxy :: Proxy (:$)) SCons)
+                            (applySing
+                               (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sMajorName)
+                               SBOOL))
+                         SNil)))))
+    sNames
+      = applySing
+          (singFun1 (Proxy :: Proxy SchSym0) SSch)
+          (applySing
+             (applySing
+                (singFun2 (Proxy :: Proxy (:$)) SCons)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sFirstName)
+                   SSTRING))
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sLastName)
+                      SSTRING))
+                SNil))
diff --git a/tests/compile-and-dump/GradingClient/Main.ghc78.template b/tests/compile-and-dump/GradingClient/Main.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/GradingClient/Main.ghc78.template
+++ /dev/null
@@ -1,163 +0,0 @@
-GradingClient/Main.hs:0:0: Splicing declarations
-    singletons
-      [d| lastName, majorName, gradeName, yearName, firstName :: [AChar]
-          lastName = [CL, CA, CS, CT]
-          firstName = [CF, CI, CR, CS, CT]
-          yearName = [CY, CE, CA, CR]
-          gradeName = [CG, CR, CA, CD, CE]
-          majorName = [CM, CA, CJ, CO, CR]
-          gradingSchema :: Schema
-          gradingSchema
-            = Sch
-                [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT,
-                 Attr gradeName NAT, Attr majorName BOOL]
-          names :: Schema
-          names = Sch [Attr firstName STRING, Attr lastName STRING] |]
-  ======>
-    GradingClient/Main.hs:(0,0)-(0,0)
-    lastName :: [AChar]
-    majorName :: [AChar]
-    gradeName :: [AChar]
-    yearName :: [AChar]
-    firstName :: [AChar]
-    lastName = [CL, CA, CS, CT]
-    firstName = [CF, CI, CR, CS, CT]
-    yearName = [CY, CE, CA, CR]
-    gradeName = [CG, CR, CA, CD, CE]
-    majorName = [CM, CA, CJ, CO, CR]
-    gradingSchema :: Schema
-    gradingSchema
-      = Sch
-          [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT,
-           Attr gradeName NAT, Attr majorName BOOL]
-    names :: Schema
-    names = Sch [Attr firstName STRING, Attr lastName STRING]
-    type MajorNameSym0 = MajorName
-    type GradeNameSym0 = GradeName
-    type YearNameSym0 = YearName
-    type FirstNameSym0 = FirstName
-    type LastNameSym0 = LastName
-    type GradingSchemaSym0 = GradingSchema
-    type NamesSym0 = Names
-    type MajorName =
-        (Apply (Apply (:$) CMSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CJSym0) (Apply (Apply (:$) COSym0) (Apply (Apply (:$) CRSym0) '[])))) :: [AChar])
-    type GradeName =
-        (Apply (Apply (:$) CGSym0) (Apply (Apply (:$) CRSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CDSym0) (Apply (Apply (:$) CESym0) '[])))) :: [AChar])
-    type YearName =
-        (Apply (Apply (:$) CYSym0) (Apply (Apply (:$) CESym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CRSym0) '[]))) :: [AChar])
-    type FirstName =
-        (Apply (Apply (:$) CFSym0) (Apply (Apply (:$) CISym0) (Apply (Apply (:$) CRSym0) (Apply (Apply (:$) CSSym0) (Apply (Apply (:$) CTSym0) '[])))) :: [AChar])
-    type LastName =
-        (Apply (Apply (:$) CLSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CSSym0) (Apply (Apply (:$) CTSym0) '[]))) :: [AChar])
-    type GradingSchema =
-        (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 YearNameSym0) NATSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 GradeNameSym0) NATSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 MajorNameSym0) BOOLSym0)) '[]))))) :: Schema)
-    type Names =
-        (Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) '[])) :: Schema)
-    sMajorName :: Sing MajorNameSym0
-    sGradeName :: Sing GradeNameSym0
-    sYearName :: Sing YearNameSym0
-    sFirstName :: Sing FirstNameSym0
-    sLastName :: Sing LastNameSym0
-    sGradingSchema :: Sing GradingSchemaSym0
-    sNames :: Sing NamesSym0
-    sMajorName
-      = applySing
-          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCM)
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA)
-             (applySing
-                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCJ)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCO)
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR) SNil))))
-    sGradeName
-      = applySing
-          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCG)
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR)
-             (applySing
-                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCD)
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCE) SNil))))
-    sYearName
-      = applySing
-          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCY)
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCE)
-             (applySing
-                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR) SNil)))
-    sFirstName
-      = applySing
-          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCF)
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCI)
-             (applySing
-                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCS)
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCT) SNil))))
-    sLastName
-      = applySing
-          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCL)
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA)
-             (applySing
-                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCS)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCT) SNil)))
-    sGradingSchema
-      = applySing
-          (singFun1 (Proxy :: Proxy SchSym0) SSch)
-          (applySing
-             (applySing
-                (singFun2 (Proxy :: Proxy (:$)) SCons)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sLastName)
-                   SSTRING))
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sFirstName)
-                      SSTRING))
-                (applySing
-                   (applySing
-                      (singFun2 (Proxy :: Proxy (:$)) SCons)
-                      (applySing
-                         (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sYearName)
-                         SNAT))
-                   (applySing
-                      (applySing
-                         (singFun2 (Proxy :: Proxy (:$)) SCons)
-                         (applySing
-                            (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sGradeName)
-                            SNAT))
-                      (applySing
-                         (applySing
-                            (singFun2 (Proxy :: Proxy (:$)) SCons)
-                            (applySing
-                               (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sMajorName)
-                               SBOOL))
-                         SNil)))))
-    sNames
-      = applySing
-          (singFun1 (Proxy :: Proxy SchSym0) SSch)
-          (applySing
-             (applySing
-                (singFun2 (Proxy :: Proxy (:$)) SCons)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sFirstName)
-                   SSTRING))
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sLastName)
-                      SSTRING))
-                SNil))
diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc710.template b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc710.template
@@ -0,0 +1,242 @@
+InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations
+    singletons [d| data Nat = Zero | Succ Nat |]
+  ======>
+    data Nat = Zero | Succ Nat
+    type ZeroSym0 = Zero
+    type SuccSym1 (t :: Nat) = Succ t
+    instance SuppressUnusedWarnings SuccSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
+    data SuccSym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
+        SuccSym0KindInference
+    type instance Apply SuccSym0 l = SuccSym1 l
+    data instance Sing (z :: Nat)
+      = z ~ Zero => SZero |
+        forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat))
+    type SNat = (Sing :: Nat -> *)
+    instance SingKind (KProxy :: KProxy Nat) where
+      type DemoteRep (KProxy :: KProxy Nat) = Nat
+      fromSing SZero = Zero
+      fromSing (SSucc b) = Succ (fromSing b)
+      toSing Zero = SomeSing SZero
+      toSing (Succ b)
+        = case toSing b :: SomeSing (KProxy :: KProxy Nat) of {
+            SomeSing c -> SomeSing (SSucc c) }
+    instance SingI Zero where
+      sing = SZero
+    instance SingI n => SingI (Succ (n :: Nat)) where
+      sing = SSucc sing
+InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| leq :: Nat -> Nat -> Bool
+          leq Zero _ = True
+          leq (Succ _) Zero = False
+          leq (Succ a) (Succ b) = leq a b
+          insert :: Nat -> [Nat] -> [Nat]
+          insert n [] = [n]
+          insert n (h : t)
+            = if leq n h then (n : h : t) else h : (insert n t)
+          insertionSort :: [Nat] -> [Nat]
+          insertionSort [] = []
+          insertionSort (h : t) = insert h (insertionSort t) |]
+  ======>
+    leq :: Nat -> Nat -> Bool
+    leq Zero _ = True
+    leq (Succ _) Zero = False
+    leq (Succ a) (Succ b) = leq a b
+    insert :: Nat -> [Nat] -> [Nat]
+    insert n GHC.Types.[] = [n]
+    insert n (h GHC.Types.: t)
+      = if leq n h then
+            (n GHC.Types.: (h GHC.Types.: t))
+        else
+            (h GHC.Types.: (insert n t))
+    insertionSort :: [Nat] -> [Nat]
+    insertionSort GHC.Types.[] = []
+    insertionSort (h GHC.Types.: t) = insert h (insertionSort t)
+    type Let0123456789Scrutinee_0123456789Sym3 t t t =
+        Let0123456789Scrutinee_0123456789 t t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>
+        Let0123456789Scrutinee_0123456789Sym2KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
+        Let0123456789Scrutinee_0123456789Sym1KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 n h t where
+      Let0123456789Scrutinee_0123456789 n h t = Apply (Apply LeqSym0 n) h
+    type family Case_0123456789 n h t t where
+      Case_0123456789 n h t True = Apply (Apply (:$) n) (Apply (Apply (:$) h) t)
+      Case_0123456789 n h t False = Apply (Apply (:$) h) (Apply (Apply InsertSym0 n) t)
+    type LeqSym2 (t :: Nat) (t :: Nat) = Leq t t
+    instance SuppressUnusedWarnings LeqSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LeqSym1KindInference GHC.Tuple.())
+    data LeqSym1 (l :: Nat) (l :: TyFun Nat Bool)
+      = forall arg. KindOf (Apply (LeqSym1 l) arg) ~ KindOf (LeqSym2 l arg) =>
+        LeqSym1KindInference
+    type instance Apply (LeqSym1 l) l = LeqSym2 l l
+    instance SuppressUnusedWarnings LeqSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LeqSym0KindInference GHC.Tuple.())
+    data LeqSym0 (l :: TyFun Nat (TyFun Nat Bool -> *))
+      = forall arg. KindOf (Apply LeqSym0 arg) ~ KindOf (LeqSym1 arg) =>
+        LeqSym0KindInference
+    type instance Apply LeqSym0 l = LeqSym1 l
+    type InsertSym2 (t :: Nat) (t :: [Nat]) = Insert t t
+    instance SuppressUnusedWarnings InsertSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) InsertSym1KindInference GHC.Tuple.())
+    data InsertSym1 (l :: Nat) (l :: TyFun [Nat] [Nat])
+      = forall arg. KindOf (Apply (InsertSym1 l) arg) ~ KindOf (InsertSym2 l arg) =>
+        InsertSym1KindInference
+    type instance Apply (InsertSym1 l) l = InsertSym2 l l
+    instance SuppressUnusedWarnings InsertSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) InsertSym0KindInference GHC.Tuple.())
+    data InsertSym0 (l :: TyFun Nat (TyFun [Nat] [Nat] -> *))
+      = forall arg. KindOf (Apply InsertSym0 arg) ~ KindOf (InsertSym1 arg) =>
+        InsertSym0KindInference
+    type instance Apply InsertSym0 l = InsertSym1 l
+    type InsertionSortSym1 (t :: [Nat]) = InsertionSort t
+    instance SuppressUnusedWarnings InsertionSortSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) InsertionSortSym0KindInference GHC.Tuple.())
+    data InsertionSortSym0 (l :: TyFun [Nat] [Nat])
+      = forall arg. KindOf (Apply InsertionSortSym0 arg) ~ KindOf (InsertionSortSym1 arg) =>
+        InsertionSortSym0KindInference
+    type instance Apply InsertionSortSym0 l = InsertionSortSym1 l
+    type family Leq (a :: Nat) (a :: Nat) :: Bool where
+      Leq Zero _z_0123456789 = TrueSym0
+      Leq (Succ _z_0123456789) Zero = FalseSym0
+      Leq (Succ a) (Succ b) = Apply (Apply LeqSym0 a) b
+    type family Insert (a :: Nat) (a :: [Nat]) :: [Nat] where
+      Insert n '[] = Apply (Apply (:$) n) '[]
+      Insert n ((:) h t) = Case_0123456789 n h t (Let0123456789Scrutinee_0123456789Sym3 n h t)
+    type family InsertionSort (a :: [Nat]) :: [Nat] where
+      InsertionSort '[] = '[]
+      InsertionSort ((:) h t) = Apply (Apply InsertSym0 h) (Apply InsertionSortSym0 t)
+    sLeq ::
+      forall (t :: Nat) (t :: Nat).
+      Sing t -> Sing t -> Sing (Apply (Apply LeqSym0 t) t :: Bool)
+    sInsert ::
+      forall (t :: Nat) (t :: [Nat]).
+      Sing t -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat])
+    sInsertionSort ::
+      forall (t :: [Nat]).
+      Sing t -> Sing (Apply InsertionSortSym0 t :: [Nat])
+    sLeq SZero _s_z_0123456789
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ ZeroSym0, t ~ _z_0123456789) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply LeqSym0 ZeroSym0) _z_0123456789 :: Bool)
+          lambda _z_0123456789 = STrue
+        in lambda _s_z_0123456789
+    sLeq (SSucc _s_z_0123456789) SZero
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ Apply SuccSym0 _z_0123456789,
+                                   t ~ ZeroSym0) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply LeqSym0 (Apply SuccSym0 _z_0123456789)) ZeroSym0 :: Bool)
+          lambda _z_0123456789 = SFalse
+        in lambda _s_z_0123456789
+    sLeq (SSucc sA) (SSucc sB)
+      = let
+          lambda ::
+            forall a b. (t ~ Apply SuccSym0 a, t ~ Apply SuccSym0 b) =>
+            Sing a
+            -> Sing b
+               -> Sing (Apply (Apply LeqSym0 (Apply SuccSym0 a)) (Apply SuccSym0 b) :: Bool)
+          lambda a b
+            = applySing
+                (applySing (singFun2 (Proxy :: Proxy LeqSym0) sLeq) a) b
+        in lambda sA sB
+    sInsert sN SNil
+      = let
+          lambda ::
+            forall n. (t ~ n, t ~ '[]) =>
+            Sing n -> Sing (Apply (Apply InsertSym0 n) '[] :: [Nat])
+          lambda n
+            = applySing
+                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) n) SNil
+        in lambda sN
+    sInsert sN (SCons sH sT)
+      = let
+          lambda ::
+            forall n h t. (t ~ n, t ~ Apply (Apply (:$) h) t) =>
+            Sing n
+            -> Sing h
+               -> Sing t
+                  -> Sing (Apply (Apply InsertSym0 n) (Apply (Apply (:$) h) t) :: [Nat])
+          lambda n h t
+            = let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym3 n h t)
+                sScrutinee_0123456789
+                  = applySing
+                      (applySing (singFun2 (Proxy :: Proxy LeqSym0) sLeq) n) h
+              in  case sScrutinee_0123456789 of {
+                    STrue
+                      -> let
+                           lambda ::
+                             TrueSym0 ~ Let0123456789Scrutinee_0123456789Sym3 n h t =>
+                             Sing (Case_0123456789 n h t TrueSym0)
+                           lambda
+                             = applySing
+                                 (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) n)
+                                 (applySing (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) h) t)
+                         in lambda
+                    SFalse
+                      -> let
+                           lambda ::
+                             FalseSym0 ~ Let0123456789Scrutinee_0123456789Sym3 n h t =>
+                             Sing (Case_0123456789 n h t FalseSym0)
+                           lambda
+                             = applySing
+                                 (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) h)
+                                 (applySing
+                                    (applySing (singFun2 (Proxy :: Proxy InsertSym0) sInsert) n) t)
+                         in lambda } ::
+                    Sing (Case_0123456789 n h t (Let0123456789Scrutinee_0123456789Sym3 n h t))
+        in lambda sN sH sT
+    sInsertionSort SNil
+      = let
+          lambda :: t ~ '[] => Sing (Apply InsertionSortSym0 '[] :: [Nat])
+          lambda = SNil
+        in lambda
+    sInsertionSort (SCons sH sT)
+      = let
+          lambda ::
+            forall h t. t ~ Apply (Apply (:$) h) t =>
+            Sing h
+            -> Sing t
+               -> Sing (Apply InsertionSortSym0 (Apply (Apply (:$) h) t) :: [Nat])
+          lambda h t
+            = applySing
+                (applySing (singFun2 (Proxy :: Proxy InsertSym0) sInsert) h)
+                (applySing
+                   (singFun1 (Proxy :: Proxy InsertionSortSym0) sInsertionSort) t)
+        in lambda sH sT
diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template
+++ /dev/null
@@ -1,236 +0,0 @@
-InsertionSort/InsertionSortImp.hs:0:0: Splicing declarations
-    singletons [d| data Nat = Zero | Succ Nat |]
-  ======>
-    InsertionSort/InsertionSortImp.hs:(0,0)-(0,0)
-    data Nat = Zero | Succ Nat
-    type ZeroSym0 = Zero
-    type SuccSym1 (t :: Nat) = Succ t
-    instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
-    data SuccSym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
-        SuccSym0KindInference
-    type instance Apply SuccSym0 l = SuccSym1 l
-    data instance Sing (z :: Nat)
-      = z ~ Zero => SZero |
-        forall (n :: Nat). z ~ Succ n => SSucc (Sing n)
-    type SNat (z :: Nat) = Sing z
-    instance SingKind (KProxy :: KProxy Nat) where
-      type DemoteRep (KProxy :: KProxy Nat) = Nat
-      fromSing SZero = Zero
-      fromSing (SSucc b) = Succ (fromSing b)
-      toSing Zero = SomeSing SZero
-      toSing (Succ b)
-        = case toSing b :: SomeSing (KProxy :: KProxy Nat) of {
-            SomeSing c -> SomeSing (SSucc c) }
-    instance SingI Zero where
-      sing = SZero
-    instance SingI n => SingI (Succ (n :: Nat)) where
-      sing = SSucc sing
-InsertionSort/InsertionSortImp.hs:0:0: Splicing declarations
-    singletons
-      [d| leq :: Nat -> Nat -> Bool
-          leq Zero _ = True
-          leq (Succ _) Zero = False
-          leq (Succ a) (Succ b) = leq a b
-          insert :: Nat -> [Nat] -> [Nat]
-          insert n [] = [n]
-          insert n (h : t)
-            = if leq n h then (n : h : t) else h : (insert n t)
-          insertionSort :: [Nat] -> [Nat]
-          insertionSort [] = []
-          insertionSort (h : t) = insert h (insertionSort t) |]
-  ======>
-    InsertionSort/InsertionSortImp.hs:(0,0)-(0,0)
-    leq :: Nat -> Nat -> Bool
-    leq Zero _ = True
-    leq (Succ _) Zero = False
-    leq (Succ a) (Succ b) = leq a b
-    insert :: Nat -> [Nat] -> [Nat]
-    insert n GHC.Types.[] = [n]
-    insert n (h GHC.Types.: t)
-      = if leq n h then
-            (n GHC.Types.: (h GHC.Types.: t))
-        else
-            (h GHC.Types.: (insert n t))
-    insertionSort :: [Nat] -> [Nat]
-    insertionSort GHC.Types.[] = []
-    insertionSort (h GHC.Types.: t) = insert h (insertionSort t)
-    type Let0123456789Scrutinee_0123456789Sym3 t t t =
-        Let0123456789Scrutinee_0123456789 t t t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>
-        Let0123456789Scrutinee_0123456789Sym2KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 n h t =
-        Apply (Apply LeqSym0 n) h
-    type family Case_0123456789 n h t t where
-      Case_0123456789 n h t True = Apply (Apply (:$) n) (Apply (Apply (:$) h) t)
-      Case_0123456789 n h t False = Apply (Apply (:$) h) (Apply (Apply InsertSym0 n) t)
-    type LeqSym2 (t :: Nat) (t :: Nat) = Leq t t
-    instance SuppressUnusedWarnings LeqSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LeqSym1KindInference GHC.Tuple.())
-    data LeqSym1 (l :: Nat) (l :: TyFun Nat Bool)
-      = forall arg. KindOf (Apply (LeqSym1 l) arg) ~ KindOf (LeqSym2 l arg) =>
-        LeqSym1KindInference
-    type instance Apply (LeqSym1 l) l = LeqSym2 l l
-    instance SuppressUnusedWarnings LeqSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LeqSym0KindInference GHC.Tuple.())
-    data LeqSym0 (l :: TyFun Nat (TyFun Nat Bool -> *))
-      = forall arg. KindOf (Apply LeqSym0 arg) ~ KindOf (LeqSym1 arg) =>
-        LeqSym0KindInference
-    type instance Apply LeqSym0 l = LeqSym1 l
-    type InsertSym2 (t :: Nat) (t :: [Nat]) = Insert t t
-    instance SuppressUnusedWarnings InsertSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) InsertSym1KindInference GHC.Tuple.())
-    data InsertSym1 (l :: Nat) (l :: TyFun [Nat] [Nat])
-      = forall arg. KindOf (Apply (InsertSym1 l) arg) ~ KindOf (InsertSym2 l arg) =>
-        InsertSym1KindInference
-    type instance Apply (InsertSym1 l) l = InsertSym2 l l
-    instance SuppressUnusedWarnings InsertSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) InsertSym0KindInference GHC.Tuple.())
-    data InsertSym0 (l :: TyFun Nat (TyFun [Nat] [Nat] -> *))
-      = forall arg. KindOf (Apply InsertSym0 arg) ~ KindOf (InsertSym1 arg) =>
-        InsertSym0KindInference
-    type instance Apply InsertSym0 l = InsertSym1 l
-    type InsertionSortSym1 (t :: [Nat]) = InsertionSort t
-    instance SuppressUnusedWarnings InsertionSortSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) InsertionSortSym0KindInference GHC.Tuple.())
-    data InsertionSortSym0 (l :: TyFun [Nat] [Nat])
-      = forall arg. KindOf (Apply InsertionSortSym0 arg) ~ KindOf (InsertionSortSym1 arg) =>
-        InsertionSortSym0KindInference
-    type instance Apply InsertionSortSym0 l = InsertionSortSym1 l
-    type family Leq (a :: Nat) (a :: Nat) :: Bool where
-      Leq Zero z = TrueSym0
-      Leq (Succ z) Zero = FalseSym0
-      Leq (Succ a) (Succ b) = Apply (Apply LeqSym0 a) b
-    type family Insert (a :: Nat) (a :: [Nat]) :: [Nat] where
-      Insert n '[] = Apply (Apply (:$) n) '[]
-      Insert n ((:) h t) = Case_0123456789 n h t (Let0123456789Scrutinee_0123456789Sym3 n h t)
-    type family InsertionSort (a :: [Nat]) :: [Nat] where
-      InsertionSort '[] = '[]
-      InsertionSort ((:) h t) = Apply (Apply InsertSym0 h) (Apply InsertionSortSym0 t)
-    sLeq ::
-      forall (t :: Nat) (t :: Nat).
-      Sing t -> Sing t -> Sing (Apply (Apply LeqSym0 t) t)
-    sInsert ::
-      forall (t :: Nat) (t :: [Nat]).
-      Sing t -> Sing t -> Sing (Apply (Apply InsertSym0 t) t)
-    sInsertionSort ::
-      forall (t :: [Nat]). Sing t -> Sing (Apply InsertionSortSym0 t)
-    sLeq SZero _
-      = let
-          lambda ::
-            forall wild. (t ~ ZeroSym0, t ~ wild) =>
-            Sing (Apply (Apply LeqSym0 ZeroSym0) wild)
-          lambda = STrue
-        in lambda
-    sLeq (SSucc _) SZero
-      = let
-          lambda ::
-            forall wild. (t ~ Apply SuccSym0 wild, t ~ ZeroSym0) =>
-            Sing (Apply (Apply LeqSym0 (Apply SuccSym0 wild)) ZeroSym0)
-          lambda = SFalse
-        in lambda
-    sLeq (SSucc sA) (SSucc sB)
-      = let
-          lambda ::
-            forall a b. (t ~ Apply SuccSym0 a, t ~ Apply SuccSym0 b) =>
-            Sing a
-            -> Sing b
-               -> Sing (Apply (Apply LeqSym0 (Apply SuccSym0 a)) (Apply SuccSym0 b))
-          lambda a b
-            = applySing
-                (applySing (singFun2 (Proxy :: Proxy LeqSym0) sLeq) a) b
-        in lambda sA sB
-    sInsert sN SNil
-      = let
-          lambda ::
-            forall n. (t ~ n, t ~ '[]) =>
-            Sing n -> Sing (Apply (Apply InsertSym0 n) '[])
-          lambda n
-            = applySing
-                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) n) SNil
-        in lambda sN
-    sInsert sN (SCons sH sT)
-      = let
-          lambda ::
-            forall n h t. (t ~ n, t ~ Apply (Apply (:$) h) t) =>
-            Sing n
-            -> Sing h
-               -> Sing t
-                  -> Sing (Apply (Apply InsertSym0 n) (Apply (Apply (:$) h) t))
-          lambda n h t
-            = let
-                sScrutinee_0123456789 ::
-                  Sing (Let0123456789Scrutinee_0123456789Sym3 n h t)
-                sScrutinee_0123456789
-                  = applySing
-                      (applySing (singFun2 (Proxy :: Proxy LeqSym0) sLeq) n) h
-              in
-                case sScrutinee_0123456789 of {
-                  STrue
-                    -> let
-                         lambda :: Sing (Case_0123456789 n h t TrueSym0)
-                         lambda
-                           = applySing
-                               (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) n)
-                               (applySing (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) h) t)
-                       in lambda
-                  SFalse
-                    -> let
-                         lambda :: Sing (Case_0123456789 n h t FalseSym0)
-                         lambda
-                           = applySing
-                               (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) h)
-                               (applySing
-                                  (applySing (singFun2 (Proxy :: Proxy InsertSym0) sInsert) n) t)
-                       in lambda }
-        in lambda sN sH sT
-    sInsertionSort SNil
-      = let
-          lambda :: t ~ '[] => Sing (Apply InsertionSortSym0 '[])
-          lambda = SNil
-        in lambda
-    sInsertionSort (SCons sH sT)
-      = let
-          lambda ::
-            forall h t. t ~ Apply (Apply (:$) h) t =>
-            Sing h
-            -> Sing t
-               -> Sing (Apply InsertionSortSym0 (Apply (Apply (:$) h) t))
-          lambda h t
-            = applySing
-                (applySing (singFun2 (Proxy :: Proxy InsertSym0) sInsert) h)
-                (applySing
-                   (singFun1 (Proxy :: Proxy InsertionSortSym0) sInsertionSort) t)
-        in lambda sH sT
diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.hs b/tests/compile-and-dump/InsertionSort/InsertionSortImp.hs
--- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.hs
+++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.hs
@@ -27,7 +27,7 @@
 
 -}
 
-{-# LANGUAGE IncoherentInstances #-}
+{-# LANGUAGE IncoherentInstances, ConstraintKinds #-}
 
 module InsertionSort.InsertionSortImp where
 
@@ -35,9 +35,8 @@
 import Data.Singletons.SuppressUnusedWarnings
 import Data.Singletons.TH
 
--- We use the Dict data type from Edward Kmett's constraints package to be
--- able to return dictionaries from functions
-import Data.Constraint
+data Dict c where
+  Dict :: c => Dict c
 
 -- Natural numbers, defined with singleton counterparts
 $(singletons [d|
diff --git a/tests/compile-and-dump/Promote/BadBoundedDeriving.ghc78.template b/tests/compile-and-dump/Promote/BadBoundedDeriving.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/BadBoundedDeriving.ghc78.template
+++ /dev/null
@@ -1,5 +0,0 @@
-
-Promote/BadBoundedDeriving.hs:0:0:
-    Can't derive promoted Bounded instance for Foo_0123456789 datatype.
-
-Promote/BadBoundedDeriving.hs:0:0: Q monad failure
diff --git a/tests/compile-and-dump/Promote/BadBoundedDeriving.hs b/tests/compile-and-dump/Promote/BadBoundedDeriving.hs
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/BadBoundedDeriving.hs
+++ /dev/null
@@ -1,8 +0,0 @@
-module Promote.BadBoundedDeriving where
-
-import Data.Promotion.Prelude
-import Data.Promotion.TH
-
-$(promote [d|
-  data Foo a = Foo | Bar a deriving (Bounded)
-  |])
diff --git a/tests/compile-and-dump/Promote/BoundedDeriving.ghc78.template b/tests/compile-and-dump/Promote/BoundedDeriving.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/BoundedDeriving.ghc78.template
+++ /dev/null
@@ -1,80 +0,0 @@
-Promote/BoundedDeriving.hs:0:0: Splicing declarations
-    promote
-      [d| data Foo1
-            = Foo1
-            deriving (Bounded)
-          data Foo2
-            = A | B | C | D | E
-            deriving (Bounded)
-          data Foo3 a
-            = Foo3 a
-            deriving (Bounded)
-          data Foo4 (a :: *) (b :: *)
-            = Foo41 | Foo42
-            deriving (Bounded)
-          data Pair
-            = Pair Bool Bool
-            deriving (Bounded) |]
-  ======>
-    Promote/BoundedDeriving.hs:(0,0)-(0,0)
-    data Foo1
-      = Foo1
-      deriving (Bounded)
-    data Foo2
-      = A | B | C | D | E
-      deriving (Bounded)
-    data Foo3 a
-      = Foo3 a
-      deriving (Bounded)
-    data Foo4 (a :: *) (b :: *)
-      = Foo41 | Foo42
-      deriving (Bounded)
-    data Pair
-      = Pair Bool Bool
-      deriving (Bounded)
-    instance PBounded (KProxy :: KProxy Foo1) where
-      type MinBound = Foo1
-      type MaxBound = Foo1
-    type Foo1Sym0 = Foo1
-    instance PBounded (KProxy :: KProxy Foo2) where
-      type MinBound = A
-      type MaxBound = E
-    type ASym0 = A
-    type BSym0 = B
-    type CSym0 = C
-    type DSym0 = D
-    type ESym0 = E
-    instance PBounded (KProxy :: KProxy (Foo3 k)) where
-      type MinBound = Foo3 MinBound
-      type MaxBound = Foo3 MaxBound
-    type Foo3Sym1 (t :: a) = Foo3 t
-    instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
-    data Foo3Sym0 (l :: TyFun a (Foo3 a))
-      = forall arg. Data.Singletons.KindOf (Apply Foo3Sym0 arg) ~ Data.Singletons.KindOf (Foo3Sym1 arg) =>
-        Foo3Sym0KindInference
-    type instance Apply Foo3Sym0 l = Foo3Sym1 l
-    instance PBounded (KProxy :: KProxy (Foo4 k k)) where
-      type MinBound = Foo41
-      type MaxBound = Foo42
-    type Foo41Sym0 = Foo41
-    type Foo42Sym0 = Foo42
-    instance PBounded (KProxy :: KProxy Pair) where
-      type MinBound = Pair MinBound MinBound
-      type MaxBound = Pair MaxBound MaxBound
-    type PairSym2 (t :: Bool) (t :: Bool) = Pair t t
-    instance SuppressUnusedWarnings PairSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
-    data PairSym1 (l :: Bool) (l :: TyFun Bool Pair)
-      = forall arg. Data.Singletons.KindOf (Apply (PairSym1 l) arg) ~ Data.Singletons.KindOf (PairSym2 l arg) =>
-        PairSym1KindInference
-    type instance Apply (PairSym1 l) l = PairSym2 l l
-    instance SuppressUnusedWarnings PairSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
-    data PairSym0 (l :: TyFun Bool (TyFun Bool Pair -> *))
-      = forall arg. Data.Singletons.KindOf (Apply PairSym0 arg) ~ Data.Singletons.KindOf (PairSym1 arg) =>
-        PairSym0KindInference
-    type instance Apply PairSym0 l = PairSym1 l
diff --git a/tests/compile-and-dump/Promote/BoundedDeriving.hs b/tests/compile-and-dump/Promote/BoundedDeriving.hs
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/BoundedDeriving.hs
+++ /dev/null
@@ -1,51 +0,0 @@
-module Promote.BoundedDeriving where
-
-import Data.Promotion.Prelude
-import Data.Promotion.TH
-
-$(promote [d|
-  data Foo1 = Foo1 deriving (Bounded)
-  data Foo2 = A | B | C | D | E deriving (Bounded)
-  data Foo3 a = Foo3 a deriving (Bounded)
-  data Foo4 (a :: *) (b :: *) = Foo41 | Foo42 deriving Bounded
-
-  data Pair = Pair Bool Bool
-                  deriving Bounded
-
-  |])
-
-foo1a :: Proxy (MinBound :: Foo1)
-foo1a = Proxy
-
-foo1b :: Proxy 'Foo1
-foo1b = foo1a
-
-foo1c :: Proxy (MaxBound :: Foo1)
-foo1c = Proxy
-
-foo1d :: Proxy 'Foo1
-foo1d = foo1c
-
-foo2a :: Proxy (MinBound :: Foo2)
-foo2a = Proxy
-
-foo2b :: Proxy 'A
-foo2b = foo2a
-
-foo2c :: Proxy (MaxBound :: Foo2)
-foo2c = Proxy
-
-foo2d :: Proxy 'E
-foo2d = foo2c
-
-foo3a :: Proxy (MinBound :: Foo3 Bool)
-foo3a = Proxy
-
-foo3b :: Proxy ('Foo3 False)
-foo3b = foo3a
-
-foo3c :: Proxy (MaxBound :: Foo3 Bool)
-foo3c = Proxy
-
-foo3d :: Proxy ('Foo3 True)
-foo3d = foo3c
diff --git a/tests/compile-and-dump/Promote/Classes.ghc78.template b/tests/compile-and-dump/Promote/Classes.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/Classes.ghc78.template
+++ /dev/null
@@ -1,158 +0,0 @@
-Promote/Classes.hs:0:0: Splicing declarations
-    promote
-      [d| const :: a -> b -> a
-          const x _ = x
-          fooCompare :: Foo -> Foo -> Ordering
-          fooCompare A A = EQ
-          fooCompare A _ = LT
-          fooCompare _ _ = GT
-          
-          class MyOrd a where
-            mycompare :: a -> a -> Ordering
-            (<=>) :: a -> a -> Ordering
-            (<=>) = mycompare
-          data Foo = A | B
-          
-          instance MyOrd Foo where
-            mycompare = fooCompare
-          instance MyOrd () where
-            mycompare _ = const EQ
-          instance MyOrd Nat where
-            Zero `mycompare` Zero = EQ
-            Zero `mycompare` (Succ _) = LT
-            (Succ _) `mycompare` Zero = GT
-            (Succ n) `mycompare` (Succ m) = m `mycompare` n |]
-  ======>
-    Promote/Classes.hs:(0,0)-(0,0)
-    const :: forall a b. a -> b -> a
-    const x _ = x
-    class MyOrd a where
-      mycompare :: a -> a -> Ordering
-      (<=>) :: a -> a -> Ordering
-      (<=>) = mycompare
-    instance MyOrd Nat where
-      mycompare Zero Zero = EQ
-      mycompare Zero (Succ _) = LT
-      mycompare (Succ _) Zero = GT
-      mycompare (Succ n) (Succ m) = (m `mycompare` n)
-    instance MyOrd () where
-      mycompare _ = const EQ
-    data Foo = A | B
-    fooCompare :: Foo -> Foo -> Ordering
-    fooCompare A A = EQ
-    fooCompare A _ = LT
-    fooCompare _ _ = GT
-    instance MyOrd Foo where
-      mycompare = fooCompare
-    type FooCompareSym2 (t :: Foo) (t :: Foo) = FooCompare t t
-    instance SuppressUnusedWarnings FooCompareSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooCompareSym1KindInference GHC.Tuple.())
-    data FooCompareSym1 (l :: Foo) (l :: TyFun Foo Ordering)
-      = forall arg. KindOf (Apply (FooCompareSym1 l) arg) ~ KindOf (FooCompareSym2 l arg) =>
-        FooCompareSym1KindInference
-    type instance Apply (FooCompareSym1 l) l = FooCompareSym2 l l
-    instance SuppressUnusedWarnings FooCompareSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooCompareSym0KindInference GHC.Tuple.())
-    data FooCompareSym0 (l :: TyFun Foo (TyFun Foo Ordering -> *))
-      = forall arg. KindOf (Apply FooCompareSym0 arg) ~ KindOf (FooCompareSym1 arg) =>
-        FooCompareSym0KindInference
-    type instance Apply FooCompareSym0 l = FooCompareSym1 l
-    type ConstSym2 (t :: a) (t :: b) = Const t t
-    instance SuppressUnusedWarnings ConstSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ConstSym1KindInference GHC.Tuple.())
-    data ConstSym1 (l :: a) (l :: TyFun b a)
-      = forall arg. KindOf (Apply (ConstSym1 l) arg) ~ KindOf (ConstSym2 l arg) =>
-        ConstSym1KindInference
-    type instance Apply (ConstSym1 l) l = ConstSym2 l l
-    instance SuppressUnusedWarnings ConstSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ConstSym0KindInference GHC.Tuple.())
-    data ConstSym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. KindOf (Apply ConstSym0 arg) ~ KindOf (ConstSym1 arg) =>
-        ConstSym0KindInference
-    type instance Apply ConstSym0 l = ConstSym1 l
-    type family FooCompare (a :: Foo) (a :: Foo) :: Ordering where
-      FooCompare A A = EQSym0
-      FooCompare A z = LTSym0
-      FooCompare z z = GTSym0
-    type family Const (a :: a) (a :: b) :: a where
-      Const x z = x
-    type MycompareSym2 (t :: a) (t :: a) = Mycompare t t
-    instance SuppressUnusedWarnings MycompareSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) MycompareSym1KindInference GHC.Tuple.())
-    data MycompareSym1 (l :: a) (l :: TyFun a Ordering)
-      = forall arg. KindOf (Apply (MycompareSym1 l) arg) ~ KindOf (MycompareSym2 l arg) =>
-        MycompareSym1KindInference
-    type instance Apply (MycompareSym1 l) l = MycompareSym2 l l
-    instance SuppressUnusedWarnings MycompareSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) MycompareSym0KindInference GHC.Tuple.())
-    data MycompareSym0 (l :: TyFun a (TyFun a Ordering -> *))
-      = forall arg. KindOf (Apply MycompareSym0 arg) ~ KindOf (MycompareSym1 arg) =>
-        MycompareSym0KindInference
-    type instance Apply MycompareSym0 l = MycompareSym1 l
-    type (:<=>$$$) (t :: a) (t :: a) = (:<=>) t t
-    instance SuppressUnusedWarnings (:<=>$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<=>$$###) GHC.Tuple.())
-    data (:<=>$$) (l :: a) (l :: TyFun a Ordering)
-      = forall arg. KindOf (Apply ((:<=>$$) l) arg) ~ KindOf ((:<=>$$$) l arg) =>
-        (:<=>$$###)
-    type instance Apply ((:<=>$$) l) l = (:<=>$$$) l l
-    instance SuppressUnusedWarnings (:<=>$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<=>$###) GHC.Tuple.())
-    data (:<=>$) (l :: TyFun a (TyFun a Ordering -> *))
-      = forall arg. KindOf (Apply (:<=>$) arg) ~ KindOf ((:<=>$$) arg) =>
-        (:<=>$###)
-    type instance Apply (:<=>$) l = (:<=>$$) l
-    class kproxy ~ KProxy => PMyOrd (kproxy :: KProxy a) where
-      type family Mycompare (arg :: a) (arg :: a) :: Ordering
-      type family (:<=>) (arg :: a) (arg :: a) :: Ordering
-      type instance (:<=>) (a_0123456789 :: a) (a_0123456789 :: a) = (Apply (Apply MycompareSym0 a_0123456789) a_0123456789 :: Ordering)
-    instance PMyOrd (KProxy :: KProxy Nat) where
-      type Mycompare (Zero :: Nat) (Zero :: Nat) = (EQSym0 :: Ordering)
-      type Mycompare (Zero :: Nat) (Succ z :: Nat) = (LTSym0 :: Ordering)
-      type Mycompare (Succ z :: Nat) (Zero :: Nat) = (GTSym0 :: Ordering)
-      type Mycompare (Succ n :: Nat) (Succ m :: Nat) = (Apply (Apply MycompareSym0 m) n :: Ordering)
-    instance PMyOrd (KProxy :: KProxy ()) where
-      type Mycompare (z :: ()) (a_0123456789 :: ()) = (Apply (Apply ConstSym0 EQSym0) a_0123456789 :: Ordering)
-    instance PMyOrd (KProxy :: KProxy Foo) where
-      type Mycompare (a_0123456789 :: Foo) (a_0123456789 :: Foo) = (Apply (Apply FooCompareSym0 a_0123456789) a_0123456789 :: Ordering)
-    type ASym0 = A
-    type BSym0 = B
-Promote/Classes.hs:0:0: Splicing declarations
-    promote
-      [d| data Nat' = Zero' | Succ' Nat'
-          
-          instance MyOrd Nat' where
-            Zero' `mycompare` Zero' = EQ
-            Zero' `mycompare` (Succ' _) = LT
-            (Succ' _) `mycompare` Zero' = GT
-            (Succ' n) `mycompare` (Succ' m) = m `mycompare` n |]
-  ======>
-    Promote/Classes.hs:(0,0)-(0,0)
-    data Nat' = Zero' | Succ' Nat'
-    instance MyOrd Nat' where
-      mycompare Zero' Zero' = EQ
-      mycompare Zero' (Succ' _) = LT
-      mycompare (Succ' _) Zero' = GT
-      mycompare (Succ' n) (Succ' m) = (m `mycompare` n)
-    instance PMyOrd (KProxy :: KProxy Nat') where
-      type Mycompare (Zero' :: Nat') (Zero' :: Nat') = (EQSym0 :: Ordering)
-      type Mycompare (Zero' :: Nat') (Succ' z :: Nat') = (LTSym0 :: Ordering)
-      type Mycompare (Succ' z :: Nat') (Zero' :: Nat') = (GTSym0 :: Ordering)
-      type Mycompare (Succ' n :: Nat') (Succ' m :: Nat') = (Apply (Apply MycompareSym0 m) n :: Ordering)
-    type Zero'Sym0 = Zero'
-    type Succ'Sym1 (t :: Nat') = Succ' t
-    instance SuppressUnusedWarnings Succ'Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Succ'Sym0KindInference GHC.Tuple.())
-    data Succ'Sym0 (l :: TyFun Nat' Nat')
-      = forall arg. KindOf (Apply Succ'Sym0 arg) ~ KindOf (Succ'Sym1 arg) =>
-        Succ'Sym0KindInference
-    type instance Apply Succ'Sym0 l = Succ'Sym1 l
diff --git a/tests/compile-and-dump/Promote/Classes.hs b/tests/compile-and-dump/Promote/Classes.hs
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/Classes.hs
+++ /dev/null
@@ -1,73 +0,0 @@
-module Promote.Classes where
-
-import Prelude hiding (Ord(..), const)
-import Singletons.Nat
-import Data.Singletons
-import Data.Singletons.TH
-import Data.Singletons.Prelude.Ord (EQSym0, LTSym0, GTSym0)
-
-$(promote [d|
-  const :: a -> b -> a
-  const x _ = x
-
-  class MyOrd a where
-    mycompare :: a -> a -> Ordering
-    (<=>) :: a -> a -> Ordering
-    (<=>) = mycompare
---    infix 4 <=>  infix decls don't work due to #65
-
-  instance MyOrd Nat where
-    Zero `mycompare` Zero = EQ
-    Zero `mycompare` (Succ _) = LT
-    (Succ _) `mycompare` Zero = GT
-    (Succ n) `mycompare` (Succ m) = m `mycompare` n
-
-    -- test eta-expansion
-  instance MyOrd () where
-    mycompare _ = const EQ
-
-  data Foo = A | B
-
-  fooCompare :: Foo -> Foo -> Ordering
-  fooCompare A A = EQ
-  fooCompare A _ = LT
-  fooCompare _ _ = GT
-
-  instance MyOrd Foo where
-    -- test that values in instance definitions are eta-expanded
-    mycompare = fooCompare
- |])
-
--- check promotion across different splices (#55)
-$(promote [d|
-  data Nat' = Zero' | Succ' Nat'
-  instance MyOrd Nat' where
-    Zero' `mycompare` Zero' = EQ
-    Zero' `mycompare` (Succ' _) = LT
-    (Succ' _) `mycompare` Zero' = GT
-    (Succ' n) `mycompare` (Succ' m) = m `mycompare` n
- |])
-
-foo1a :: Proxy (Zero `Mycompare` (Succ Zero))
-foo1a = Proxy
-
-foo1b :: Proxy LT
-foo1b = foo1a
-
-foo2a :: Proxy (A `Mycompare` A)
-foo2a = Proxy
-
-foo2b :: Proxy EQ
-foo2b = foo2a
-
-foo3a :: Proxy ('() `Mycompare` '())
-foo3a = Proxy
-
-foo3b :: Proxy EQ
-foo3b = foo3a
-
-foo4a :: Proxy (Succ' Zero' :<=> Zero')
-foo4a = Proxy
-
-foo4b :: Proxy GT
-foo4b = foo4a
diff --git a/tests/compile-and-dump/Promote/Constructors.ghc710.template b/tests/compile-and-dump/Promote/Constructors.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/Constructors.ghc710.template
@@ -0,0 +1,79 @@
+Promote/Constructors.hs:(0,0)-(0,0): Splicing declarations
+    promote
+      [d| data Foo = Foo | Foo :+ Foo
+          data Bar = Bar Bar Bar Bar Bar Foo |]
+  ======>
+    data Foo = Foo | Foo :+ Foo
+    data Bar = Bar Bar Bar Bar Bar Foo
+    type FooSym0 = Foo
+    type (:+$$$) (t :: Foo) (t :: Foo) = (:+) t t
+    instance SuppressUnusedWarnings (:+$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
+    data (:+$$) (l :: Foo) (l :: TyFun Foo Foo)
+      = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) =>
+        :+$$###
+    type instance Apply ((:+$$) l) l = (:+$$$) l l
+    instance SuppressUnusedWarnings (:+$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
+    data (:+$) (l :: TyFun Foo (TyFun Foo Foo -> *))
+      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
+        :+$###
+    type instance Apply (:+$) l = (:+$$) l
+    type BarSym5 (t :: Bar)
+                 (t :: Bar)
+                 (t :: Bar)
+                 (t :: Bar)
+                 (t :: Foo) =
+        Bar t t t t t
+    instance SuppressUnusedWarnings BarSym4 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym4KindInference GHC.Tuple.())
+    data BarSym4 (l :: Bar)
+                 (l :: Bar)
+                 (l :: Bar)
+                 (l :: Bar)
+                 (l :: TyFun Foo Bar)
+      = forall arg. KindOf (Apply (BarSym4 l l l l) arg) ~ KindOf (BarSym5 l l l l arg) =>
+        BarSym4KindInference
+    type instance Apply (BarSym4 l l l l) l = BarSym5 l l l l l
+    instance SuppressUnusedWarnings BarSym3 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym3KindInference GHC.Tuple.())
+    data BarSym3 (l :: Bar)
+                 (l :: Bar)
+                 (l :: Bar)
+                 (l :: TyFun Bar (TyFun Foo Bar -> *))
+      = forall arg. KindOf (Apply (BarSym3 l l l) arg) ~ KindOf (BarSym4 l l l arg) =>
+        BarSym3KindInference
+    type instance Apply (BarSym3 l l l) l = BarSym4 l l l l
+    instance SuppressUnusedWarnings BarSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym2KindInference GHC.Tuple.())
+    data BarSym2 (l :: Bar)
+                 (l :: Bar)
+                 (l :: TyFun Bar (TyFun Bar (TyFun Foo Bar -> *) -> *))
+      = forall arg. KindOf (Apply (BarSym2 l l) arg) ~ KindOf (BarSym3 l l arg) =>
+        BarSym2KindInference
+    type instance Apply (BarSym2 l l) l = BarSym3 l l l
+    instance SuppressUnusedWarnings BarSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.())
+    data BarSym1 (l :: Bar)
+                 (l :: TyFun Bar (TyFun Bar (TyFun Bar (TyFun Foo Bar -> *) -> *)
+                                  -> *))
+      = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) =>
+        BarSym1KindInference
+    type instance Apply (BarSym1 l) l = BarSym2 l l
+    instance SuppressUnusedWarnings BarSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
+    data BarSym0 (l :: TyFun Bar (TyFun Bar (TyFun Bar (TyFun Bar (TyFun Foo Bar
+                                                                   -> *)
+                                                        -> *)
+                                             -> *)
+                                  -> *))
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
+        BarSym0KindInference
+    type instance Apply BarSym0 l = BarSym1 l
diff --git a/tests/compile-and-dump/Promote/Constructors.ghc78.template b/tests/compile-and-dump/Promote/Constructors.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/Constructors.ghc78.template
+++ /dev/null
@@ -1,80 +0,0 @@
-Promote/Constructors.hs:0:0: Splicing declarations
-    promote
-      [d| data Foo = Foo | Foo :+ Foo
-          data Bar = Bar Bar Bar Bar Bar Foo |]
-  ======>
-    Promote/Constructors.hs:(0,0)-(0,0)
-    data Foo = Foo | Foo :+ Foo
-    data Bar = Bar Bar Bar Bar Bar Foo
-    type FooSym0 = Foo
-    type (:+$$$) (t :: Foo) (t :: Foo) = (:+) t t
-    instance SuppressUnusedWarnings (:+$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
-    data (:+$$) (l :: Foo) (l :: TyFun Foo Foo)
-      = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) =>
-        (:+$$###)
-    type instance Apply ((:+$$) l) l = (:+$$$) l l
-    instance SuppressUnusedWarnings (:+$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
-    data (:+$) (l :: TyFun Foo (TyFun Foo Foo -> *))
-      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
-        (:+$###)
-    type instance Apply (:+$) l = (:+$$) l
-    type BarSym5 (t :: Bar)
-                 (t :: Bar)
-                 (t :: Bar)
-                 (t :: Bar)
-                 (t :: Foo) =
-        Bar t t t t t
-    instance SuppressUnusedWarnings BarSym4 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BarSym4KindInference GHC.Tuple.())
-    data BarSym4 (l :: Bar)
-                 (l :: Bar)
-                 (l :: Bar)
-                 (l :: Bar)
-                 (l :: TyFun Foo Bar)
-      = forall arg. KindOf (Apply (BarSym4 l l l l) arg) ~ KindOf (BarSym5 l l l l arg) =>
-        BarSym4KindInference
-    type instance Apply (BarSym4 l l l l) l = BarSym5 l l l l l
-    instance SuppressUnusedWarnings BarSym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BarSym3KindInference GHC.Tuple.())
-    data BarSym3 (l :: Bar)
-                 (l :: Bar)
-                 (l :: Bar)
-                 (l :: TyFun Bar (TyFun Foo Bar -> *))
-      = forall arg. KindOf (Apply (BarSym3 l l l) arg) ~ KindOf (BarSym4 l l l arg) =>
-        BarSym3KindInference
-    type instance Apply (BarSym3 l l l) l = BarSym4 l l l l
-    instance SuppressUnusedWarnings BarSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BarSym2KindInference GHC.Tuple.())
-    data BarSym2 (l :: Bar)
-                 (l :: Bar)
-                 (l :: TyFun Bar (TyFun Bar (TyFun Foo Bar -> *) -> *))
-      = forall arg. KindOf (Apply (BarSym2 l l) arg) ~ KindOf (BarSym3 l l arg) =>
-        BarSym2KindInference
-    type instance Apply (BarSym2 l l) l = BarSym3 l l l
-    instance SuppressUnusedWarnings BarSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.())
-    data BarSym1 (l :: Bar)
-                 (l :: TyFun Bar (TyFun Bar (TyFun Bar (TyFun Foo Bar -> *) -> *)
-                                  -> *))
-      = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) =>
-        BarSym1KindInference
-    type instance Apply (BarSym1 l) l = BarSym2 l l
-    instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
-    data BarSym0 (l :: TyFun Bar (TyFun Bar (TyFun Bar (TyFun Bar (TyFun Foo Bar
-                                                                   -> *)
-                                                        -> *)
-                                             -> *)
-                                  -> *))
-      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
-        BarSym0KindInference
-    type instance Apply BarSym0 l = BarSym1 l
diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.ghc710.template b/tests/compile-and-dump/Promote/GenDefunSymbols.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/GenDefunSymbols.ghc710.template
@@ -0,0 +1,45 @@
+Promote/GenDefunSymbols.hs:0:0:: Splicing declarations
+    genDefunSymbols [''LiftMaybe, ''NatT, '':+]
+  ======>
+    type LiftMaybeSym2 (t :: TyFun a b -> *) (t :: Maybe a) =
+        LiftMaybe t t
+    instance SuppressUnusedWarnings LiftMaybeSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LiftMaybeSym1KindInference GHC.Tuple.())
+    data LiftMaybeSym1 (l :: TyFun a b -> *)
+                       (l :: TyFun (Maybe a) (Maybe b))
+      = forall arg. Data.Singletons.KindOf (Apply (LiftMaybeSym1 l) arg) ~ Data.Singletons.KindOf (LiftMaybeSym2 l arg) =>
+        LiftMaybeSym1KindInference
+    type instance Apply (LiftMaybeSym1 l) l = LiftMaybeSym2 l l
+    instance SuppressUnusedWarnings LiftMaybeSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LiftMaybeSym0KindInference GHC.Tuple.())
+    data LiftMaybeSym0 (l :: TyFun (TyFun a b
+                                    -> *) (TyFun (Maybe a) (Maybe b) -> *))
+      = forall arg. Data.Singletons.KindOf (Apply LiftMaybeSym0 arg) ~ Data.Singletons.KindOf (LiftMaybeSym1 arg) =>
+        LiftMaybeSym0KindInference
+    type instance Apply LiftMaybeSym0 l = LiftMaybeSym1 l
+    type ZeroSym0 = Zero
+    type SuccSym1 (t :: NatT) = Succ t
+    instance SuppressUnusedWarnings SuccSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
+    data SuccSym0 (l :: TyFun NatT NatT)
+      = forall arg. Data.Singletons.KindOf (Apply SuccSym0 arg) ~ Data.Singletons.KindOf (SuccSym1 arg) =>
+        SuccSym0KindInference
+    type instance Apply SuccSym0 l = SuccSym1 l
+    type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
+    instance SuppressUnusedWarnings (:+$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
+    data (:+$$) (l :: Nat) l
+      = forall arg. Data.Singletons.KindOf (Apply ((:+$$) l) arg) ~ Data.Singletons.KindOf ((:+$$$) l arg) =>
+        :+$$###
+    type instance Apply ((:+$$) l) l = (:+$$$) l l
+    instance SuppressUnusedWarnings (:+$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
+    data (:+$) l
+      = forall arg. Data.Singletons.KindOf (Apply (:+$) arg) ~ Data.Singletons.KindOf ((:+$$) arg) =>
+        :+$###
+    type instance Apply (:+$) l = (:+$$) l
diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.ghc78.template b/tests/compile-and-dump/Promote/GenDefunSymbols.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/GenDefunSymbols.ghc78.template
+++ /dev/null
@@ -1,46 +0,0 @@
-Promote/GenDefunSymbols.hs:0:0: Splicing declarations
-    genDefunSymbols [''LiftMaybe, ''NatT, '':+]
-  ======>
-    Promote/GenDefunSymbols.hs:0:0:
-    type LiftMaybeSym2 (t :: TyFun a b -> *) (t :: Maybe a) =
-        LiftMaybe t t
-    instance SuppressUnusedWarnings LiftMaybeSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LiftMaybeSym1KindInference GHC.Tuple.())
-    data LiftMaybeSym1 (l :: TyFun a b -> *)
-                       (l :: TyFun (Maybe a) (Maybe b))
-      = forall arg. Data.Singletons.KindOf (Apply (LiftMaybeSym1 l) arg) ~ Data.Singletons.KindOf (LiftMaybeSym2 l arg) =>
-        LiftMaybeSym1KindInference
-    type instance Apply (LiftMaybeSym1 l) l = LiftMaybeSym2 l l
-    instance SuppressUnusedWarnings LiftMaybeSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LiftMaybeSym0KindInference GHC.Tuple.())
-    data LiftMaybeSym0 (l :: TyFun (TyFun a b
-                                    -> *) (TyFun (Maybe a) (Maybe b) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply LiftMaybeSym0 arg) ~ Data.Singletons.KindOf (LiftMaybeSym1 arg) =>
-        LiftMaybeSym0KindInference
-    type instance Apply LiftMaybeSym0 l = LiftMaybeSym1 l
-    type ZeroSym0 = Zero
-    type SuccSym1 (t :: NatT) = Succ t
-    instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
-    data SuccSym0 (l :: TyFun NatT NatT)
-      = forall arg. Data.Singletons.KindOf (Apply SuccSym0 arg) ~ Data.Singletons.KindOf (SuccSym1 arg) =>
-        SuccSym0KindInference
-    type instance Apply SuccSym0 l = SuccSym1 l
-    type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
-    instance SuppressUnusedWarnings (:+$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
-    data (:+$$) (l :: Nat) l
-      = forall arg. Data.Singletons.KindOf (Apply ((:+$$) l) arg) ~ Data.Singletons.KindOf ((:+$$$) l arg) =>
-        (:+$$###)
-    type instance Apply ((:+$$) l) l = (:+$$$) l l
-    instance SuppressUnusedWarnings (:+$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
-    data (:+$) l
-      = forall arg. Data.Singletons.KindOf (Apply (:+$) arg) ~ Data.Singletons.KindOf ((:+$$) arg) =>
-        (:+$###)
-    type instance Apply (:+$) l = (:+$$) l
diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.hs b/tests/compile-and-dump/Promote/GenDefunSymbols.hs
--- a/tests/compile-and-dump/Promote/GenDefunSymbols.hs
+++ b/tests/compile-and-dump/Promote/GenDefunSymbols.hs
@@ -7,15 +7,9 @@
 import Data.Singletons.SuppressUnusedWarnings
 import GHC.TypeLits
 
-#if __GLASGOW_HASKELL__ >= 707
 type family LiftMaybe (f :: TyFun a b -> *) (x :: Maybe a) :: Maybe b where
     LiftMaybe f Nothing = Nothing
     LiftMaybe f (Just a) = Just (Apply f a)
-#else
-type family LiftMaybe (f :: TyFun a b -> *) (x :: Maybe a) :: Maybe b
-type instance LiftMaybe f Nothing = Nothing
-type instance LiftMaybe f (Just a) = Just (Apply f a)
-#endif
 
 data NatT = Zero | Succ NatT
 
diff --git a/tests/compile-and-dump/Promote/Newtypes.ghc710.template b/tests/compile-and-dump/Promote/Newtypes.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/Newtypes.ghc710.template
@@ -0,0 +1,42 @@
+Promote/Newtypes.hs:(0,0)-(0,0): Splicing declarations
+    promote
+      [d| newtype Foo
+            = Foo Nat
+            deriving (Eq)
+          newtype Bar = Bar {unBar :: Nat} |]
+  ======>
+    newtype Foo
+      = Foo Nat
+      deriving (Eq)
+    newtype Bar = Bar {unBar :: Nat}
+    type UnBarSym1 (t :: Bar) = UnBar t
+    instance SuppressUnusedWarnings UnBarSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) UnBarSym0KindInference GHC.Tuple.())
+    data UnBarSym0 (l :: TyFun Bar Nat)
+      = forall arg. KindOf (Apply UnBarSym0 arg) ~ KindOf (UnBarSym1 arg) =>
+        UnBarSym0KindInference
+    type instance Apply UnBarSym0 l = UnBarSym1 l
+    type family UnBar (a :: Bar) :: Nat where
+      UnBar (Bar field) = field
+    type family Equals_0123456789 (a :: Foo) (b :: Foo) :: Bool where
+      Equals_0123456789 (Foo a) (Foo b) = (:==) a b
+      Equals_0123456789 (a :: Foo) (b :: Foo) = FalseSym0
+    instance PEq (KProxy :: KProxy Foo) where
+      type (:==) (a :: Foo) (b :: Foo) = Equals_0123456789 a b
+    type FooSym1 (t :: Nat) = Foo t
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun Nat Foo)
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type BarSym1 (t :: Nat) = Bar t
+    instance SuppressUnusedWarnings BarSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
+    data BarSym0 (l :: TyFun Nat Bar)
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
+        BarSym0KindInference
+    type instance Apply BarSym0 l = BarSym1 l
diff --git a/tests/compile-and-dump/Promote/Newtypes.ghc78.template b/tests/compile-and-dump/Promote/Newtypes.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/Newtypes.ghc78.template
+++ /dev/null
@@ -1,43 +0,0 @@
-Promote/Newtypes.hs:0:0: Splicing declarations
-    promote
-      [d| newtype Foo
-            = Foo Nat
-            deriving (Eq)
-          newtype Bar = Bar {unBar :: Nat} |]
-  ======>
-    Promote/Newtypes.hs:(0,0)-(0,0)
-    newtype Foo
-      = Foo Nat
-      deriving (Eq)
-    newtype Bar = Bar {unBar :: Nat}
-    type UnBarSym1 (t :: Bar) = UnBar t
-    instance SuppressUnusedWarnings UnBarSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) UnBarSym0KindInference GHC.Tuple.())
-    data UnBarSym0 (l :: TyFun Bar Nat)
-      = forall arg. KindOf (Apply UnBarSym0 arg) ~ KindOf (UnBarSym1 arg) =>
-        UnBarSym0KindInference
-    type instance Apply UnBarSym0 l = UnBarSym1 l
-    type family UnBar (a :: Bar) :: Nat where
-      UnBar (Bar field) = field
-    type family Equals_0123456789 (a :: Foo) (b :: Foo) :: Bool where
-      Equals_0123456789 (Foo a) (Foo b) = (:==) a b
-      Equals_0123456789 (a :: Foo) (b :: Foo) = FalseSym0
-    instance PEq (KProxy :: KProxy Foo) where
-      type (:==) (a :: Foo) (b :: Foo) = Equals_0123456789 a b
-    type FooSym1 (t :: Nat) = Foo t
-    instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
-    data FooSym0 (l :: TyFun Nat Foo)
-      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
-        FooSym0KindInference
-    type instance Apply FooSym0 l = FooSym1 l
-    type BarSym1 (t :: Nat) = Bar t
-    instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
-    data BarSym0 (l :: TyFun Nat Bar)
-      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
-        BarSym0KindInference
-    type instance Apply BarSym0 l = BarSym1 l
diff --git a/tests/compile-and-dump/Promote/OrdDeriving.ghc78.template b/tests/compile-and-dump/Promote/OrdDeriving.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/OrdDeriving.ghc78.template
+++ /dev/null
@@ -1,304 +0,0 @@
-Promote/OrdDeriving.hs:0:0: Splicing declarations
-    promote
-      [d| data Nat
-            = Zero | Succ Nat
-            deriving (Eq, Ord)
-          data Foo a b c d
-            = A a b c d |
-              B a b c d |
-              C a b c d |
-              D a b c d |
-              E a b c d |
-              F a b c d
-            deriving (Eq, Ord) |]
-  ======>
-    Promote/OrdDeriving.hs:(0,0)-(0,0)
-    data Nat
-      = Zero | Succ Nat
-      deriving (Eq, Ord)
-    data Foo a b c d
-      = A a b c d |
-        B a b c d |
-        C a b c d |
-        D a b c d |
-        E a b c d |
-        F a b c d
-      deriving (Eq, Ord)
-    type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where
-      Equals_0123456789 Zero Zero = TrueSym0
-      Equals_0123456789 (Succ a) (Succ b) = (:==) a b
-      Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0
-    instance PEq (KProxy :: KProxy Nat) where
-      type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b
-    instance POrd (KProxy :: KProxy Nat) where
-      type Compare Zero Zero = EQ
-      type Compare Zero (Succ rhs) = LT
-      type Compare (Succ lhs) Zero = GT
-      type Compare (Succ lhs) (Succ rhs) = ThenCmp EQ (Compare lhs rhs)
-    type ZeroSym0 = Zero
-    type SuccSym1 (t :: Nat) = Succ t
-    instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
-    data SuccSym0 (l :: TyFun Nat Nat)
-      = forall arg. Data.Singletons.KindOf (Apply SuccSym0 arg) ~ Data.Singletons.KindOf (SuccSym1 arg) =>
-        SuccSym0KindInference
-    type instance Apply SuccSym0 l = SuccSym1 l
-    type family Equals_0123456789 (a :: Foo k k k k)
-                                  (b :: Foo k k k k) :: Bool where
-      Equals_0123456789 (A a a a a) (A b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
-      Equals_0123456789 (B a a a a) (B b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
-      Equals_0123456789 (C a a a a) (C b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
-      Equals_0123456789 (D a a a a) (D b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
-      Equals_0123456789 (E a a a a) (E b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
-      Equals_0123456789 (F a a a a) (F b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
-      Equals_0123456789 (a :: Foo k k k k) (b :: Foo k k k k) = FalseSym0
-    instance PEq (KProxy :: KProxy (Foo k k k k)) where
-      type (:==) (a :: Foo k k k k) (b :: Foo k k k k) = Equals_0123456789 a b
-    instance POrd (KProxy :: KProxy (Foo k k k k)) where
-      type Compare (A lhs lhs lhs lhs) (A rhs rhs rhs rhs) = ThenCmp (ThenCmp (ThenCmp (ThenCmp EQ (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)
-      type Compare (A lhs lhs lhs lhs) (B rhs rhs rhs rhs) = LT
-      type Compare (A lhs lhs lhs lhs) (C rhs rhs rhs rhs) = LT
-      type Compare (A lhs lhs lhs lhs) (D rhs rhs rhs rhs) = LT
-      type Compare (A lhs lhs lhs lhs) (E rhs rhs rhs rhs) = LT
-      type Compare (A lhs lhs lhs lhs) (F rhs rhs rhs rhs) = LT
-      type Compare (B lhs lhs lhs lhs) (A rhs rhs rhs rhs) = GT
-      type Compare (B lhs lhs lhs lhs) (B rhs rhs rhs rhs) = ThenCmp (ThenCmp (ThenCmp (ThenCmp EQ (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)
-      type Compare (B lhs lhs lhs lhs) (C rhs rhs rhs rhs) = LT
-      type Compare (B lhs lhs lhs lhs) (D rhs rhs rhs rhs) = LT
-      type Compare (B lhs lhs lhs lhs) (E rhs rhs rhs rhs) = LT
-      type Compare (B lhs lhs lhs lhs) (F rhs rhs rhs rhs) = LT
-      type Compare (C lhs lhs lhs lhs) (A rhs rhs rhs rhs) = GT
-      type Compare (C lhs lhs lhs lhs) (B rhs rhs rhs rhs) = GT
-      type Compare (C lhs lhs lhs lhs) (C rhs rhs rhs rhs) = ThenCmp (ThenCmp (ThenCmp (ThenCmp EQ (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)
-      type Compare (C lhs lhs lhs lhs) (D rhs rhs rhs rhs) = LT
-      type Compare (C lhs lhs lhs lhs) (E rhs rhs rhs rhs) = LT
-      type Compare (C lhs lhs lhs lhs) (F rhs rhs rhs rhs) = LT
-      type Compare (D lhs lhs lhs lhs) (A rhs rhs rhs rhs) = GT
-      type Compare (D lhs lhs lhs lhs) (B rhs rhs rhs rhs) = GT
-      type Compare (D lhs lhs lhs lhs) (C rhs rhs rhs rhs) = GT
-      type Compare (D lhs lhs lhs lhs) (D rhs rhs rhs rhs) = ThenCmp (ThenCmp (ThenCmp (ThenCmp EQ (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)
-      type Compare (D lhs lhs lhs lhs) (E rhs rhs rhs rhs) = LT
-      type Compare (D lhs lhs lhs lhs) (F rhs rhs rhs rhs) = LT
-      type Compare (E lhs lhs lhs lhs) (A rhs rhs rhs rhs) = GT
-      type Compare (E lhs lhs lhs lhs) (B rhs rhs rhs rhs) = GT
-      type Compare (E lhs lhs lhs lhs) (C rhs rhs rhs rhs) = GT
-      type Compare (E lhs lhs lhs lhs) (D rhs rhs rhs rhs) = GT
-      type Compare (E lhs lhs lhs lhs) (E rhs rhs rhs rhs) = ThenCmp (ThenCmp (ThenCmp (ThenCmp EQ (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)
-      type Compare (E lhs lhs lhs lhs) (F rhs rhs rhs rhs) = LT
-      type Compare (F lhs lhs lhs lhs) (A rhs rhs rhs rhs) = GT
-      type Compare (F lhs lhs lhs lhs) (B rhs rhs rhs rhs) = GT
-      type Compare (F lhs lhs lhs lhs) (C rhs rhs rhs rhs) = GT
-      type Compare (F lhs lhs lhs lhs) (D rhs rhs rhs rhs) = GT
-      type Compare (F lhs lhs lhs lhs) (E rhs rhs rhs rhs) = GT
-      type Compare (F lhs lhs lhs lhs) (F rhs rhs rhs rhs) = ThenCmp (ThenCmp (ThenCmp (ThenCmp EQ (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)) (Compare lhs rhs)
-    type ASym4 (t :: a) (t :: b) (t :: c) (t :: d) = A t t t t
-    instance SuppressUnusedWarnings ASym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ASym3KindInference GHC.Tuple.())
-    data ASym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. Data.Singletons.KindOf (Apply (ASym3 l l l) arg) ~ Data.Singletons.KindOf (ASym4 l l l arg) =>
-        ASym3KindInference
-    type instance Apply (ASym3 l l l) l = ASym4 l l l l
-    instance SuppressUnusedWarnings ASym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ASym2KindInference GHC.Tuple.())
-    data ASym2 (l :: a)
-               (l :: b)
-               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (ASym2 l l) arg) ~ Data.Singletons.KindOf (ASym3 l l arg) =>
-        ASym2KindInference
-    type instance Apply (ASym2 l l) l = ASym3 l l l
-    instance SuppressUnusedWarnings ASym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ASym1KindInference GHC.Tuple.())
-    data ASym1 (l :: a)
-               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (ASym1 l) arg) ~ Data.Singletons.KindOf (ASym2 l arg) =>
-        ASym1KindInference
-    type instance Apply (ASym1 l) l = ASym2 l l
-    instance SuppressUnusedWarnings ASym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ASym0KindInference GHC.Tuple.())
-    data ASym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
-                                                -> *)
-                                       -> *)
-                              -> *))
-      = forall arg. Data.Singletons.KindOf (Apply ASym0 arg) ~ Data.Singletons.KindOf (ASym1 arg) =>
-        ASym0KindInference
-    type instance Apply ASym0 l = ASym1 l
-    type BSym4 (t :: a) (t :: b) (t :: c) (t :: d) = B t t t t
-    instance SuppressUnusedWarnings BSym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BSym3KindInference GHC.Tuple.())
-    data BSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. Data.Singletons.KindOf (Apply (BSym3 l l l) arg) ~ Data.Singletons.KindOf (BSym4 l l l arg) =>
-        BSym3KindInference
-    type instance Apply (BSym3 l l l) l = BSym4 l l l l
-    instance SuppressUnusedWarnings BSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BSym2KindInference GHC.Tuple.())
-    data BSym2 (l :: a)
-               (l :: b)
-               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (BSym2 l l) arg) ~ Data.Singletons.KindOf (BSym3 l l arg) =>
-        BSym2KindInference
-    type instance Apply (BSym2 l l) l = BSym3 l l l
-    instance SuppressUnusedWarnings BSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BSym1KindInference GHC.Tuple.())
-    data BSym1 (l :: a)
-               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (BSym1 l) arg) ~ Data.Singletons.KindOf (BSym2 l arg) =>
-        BSym1KindInference
-    type instance Apply (BSym1 l) l = BSym2 l l
-    instance SuppressUnusedWarnings BSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BSym0KindInference GHC.Tuple.())
-    data BSym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
-                                                -> *)
-                                       -> *)
-                              -> *))
-      = forall arg. Data.Singletons.KindOf (Apply BSym0 arg) ~ Data.Singletons.KindOf (BSym1 arg) =>
-        BSym0KindInference
-    type instance Apply BSym0 l = BSym1 l
-    type CSym4 (t :: a) (t :: b) (t :: c) (t :: d) = C t t t t
-    instance SuppressUnusedWarnings CSym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) CSym3KindInference GHC.Tuple.())
-    data CSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. Data.Singletons.KindOf (Apply (CSym3 l l l) arg) ~ Data.Singletons.KindOf (CSym4 l l l arg) =>
-        CSym3KindInference
-    type instance Apply (CSym3 l l l) l = CSym4 l l l l
-    instance SuppressUnusedWarnings CSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) CSym2KindInference GHC.Tuple.())
-    data CSym2 (l :: a)
-               (l :: b)
-               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (CSym2 l l) arg) ~ Data.Singletons.KindOf (CSym3 l l arg) =>
-        CSym2KindInference
-    type instance Apply (CSym2 l l) l = CSym3 l l l
-    instance SuppressUnusedWarnings CSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) CSym1KindInference GHC.Tuple.())
-    data CSym1 (l :: a)
-               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (CSym1 l) arg) ~ Data.Singletons.KindOf (CSym2 l arg) =>
-        CSym1KindInference
-    type instance Apply (CSym1 l) l = CSym2 l l
-    instance SuppressUnusedWarnings CSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) CSym0KindInference GHC.Tuple.())
-    data CSym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
-                                                -> *)
-                                       -> *)
-                              -> *))
-      = forall arg. Data.Singletons.KindOf (Apply CSym0 arg) ~ Data.Singletons.KindOf (CSym1 arg) =>
-        CSym0KindInference
-    type instance Apply CSym0 l = CSym1 l
-    type DSym4 (t :: a) (t :: b) (t :: c) (t :: d) = D t t t t
-    instance SuppressUnusedWarnings DSym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) DSym3KindInference GHC.Tuple.())
-    data DSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. Data.Singletons.KindOf (Apply (DSym3 l l l) arg) ~ Data.Singletons.KindOf (DSym4 l l l arg) =>
-        DSym3KindInference
-    type instance Apply (DSym3 l l l) l = DSym4 l l l l
-    instance SuppressUnusedWarnings DSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) DSym2KindInference GHC.Tuple.())
-    data DSym2 (l :: a)
-               (l :: b)
-               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (DSym2 l l) arg) ~ Data.Singletons.KindOf (DSym3 l l arg) =>
-        DSym2KindInference
-    type instance Apply (DSym2 l l) l = DSym3 l l l
-    instance SuppressUnusedWarnings DSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) DSym1KindInference GHC.Tuple.())
-    data DSym1 (l :: a)
-               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (DSym1 l) arg) ~ Data.Singletons.KindOf (DSym2 l arg) =>
-        DSym1KindInference
-    type instance Apply (DSym1 l) l = DSym2 l l
-    instance SuppressUnusedWarnings DSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) DSym0KindInference GHC.Tuple.())
-    data DSym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
-                                                -> *)
-                                       -> *)
-                              -> *))
-      = forall arg. Data.Singletons.KindOf (Apply DSym0 arg) ~ Data.Singletons.KindOf (DSym1 arg) =>
-        DSym0KindInference
-    type instance Apply DSym0 l = DSym1 l
-    type ESym4 (t :: a) (t :: b) (t :: c) (t :: d) = E t t t t
-    instance SuppressUnusedWarnings ESym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ESym3KindInference GHC.Tuple.())
-    data ESym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. Data.Singletons.KindOf (Apply (ESym3 l l l) arg) ~ Data.Singletons.KindOf (ESym4 l l l arg) =>
-        ESym3KindInference
-    type instance Apply (ESym3 l l l) l = ESym4 l l l l
-    instance SuppressUnusedWarnings ESym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ESym2KindInference GHC.Tuple.())
-    data ESym2 (l :: a)
-               (l :: b)
-               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (ESym2 l l) arg) ~ Data.Singletons.KindOf (ESym3 l l arg) =>
-        ESym2KindInference
-    type instance Apply (ESym2 l l) l = ESym3 l l l
-    instance SuppressUnusedWarnings ESym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ESym1KindInference GHC.Tuple.())
-    data ESym1 (l :: a)
-               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (ESym1 l) arg) ~ Data.Singletons.KindOf (ESym2 l arg) =>
-        ESym1KindInference
-    type instance Apply (ESym1 l) l = ESym2 l l
-    instance SuppressUnusedWarnings ESym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ESym0KindInference GHC.Tuple.())
-    data ESym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
-                                                -> *)
-                                       -> *)
-                              -> *))
-      = forall arg. Data.Singletons.KindOf (Apply ESym0 arg) ~ Data.Singletons.KindOf (ESym1 arg) =>
-        ESym0KindInference
-    type instance Apply ESym0 l = ESym1 l
-    type FSym4 (t :: a) (t :: b) (t :: c) (t :: d) = F t t t t
-    instance SuppressUnusedWarnings FSym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FSym3KindInference GHC.Tuple.())
-    data FSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
-      = forall arg. Data.Singletons.KindOf (Apply (FSym3 l l l) arg) ~ Data.Singletons.KindOf (FSym4 l l l arg) =>
-        FSym3KindInference
-    type instance Apply (FSym3 l l l) l = FSym4 l l l l
-    instance SuppressUnusedWarnings FSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FSym2KindInference GHC.Tuple.())
-    data FSym2 (l :: a)
-               (l :: b)
-               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (FSym2 l l) arg) ~ Data.Singletons.KindOf (FSym3 l l arg) =>
-        FSym2KindInference
-    type instance Apply (FSym2 l l) l = FSym3 l l l
-    instance SuppressUnusedWarnings FSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FSym1KindInference GHC.Tuple.())
-    data FSym1 (l :: a)
-               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
-      = forall arg. Data.Singletons.KindOf (Apply (FSym1 l) arg) ~ Data.Singletons.KindOf (FSym2 l arg) =>
-        FSym1KindInference
-    type instance Apply (FSym1 l) l = FSym2 l l
-    instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FSym0KindInference GHC.Tuple.())
-    data FSym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
-                                                -> *)
-                                       -> *)
-                              -> *))
-      = forall arg. Data.Singletons.KindOf (Apply FSym0 arg) ~ Data.Singletons.KindOf (FSym1 arg) =>
-        FSym0KindInference
-    type instance Apply FSym0 l = FSym1 l
diff --git a/tests/compile-and-dump/Promote/OrdDeriving.hs b/tests/compile-and-dump/Promote/OrdDeriving.hs
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/OrdDeriving.hs
+++ /dev/null
@@ -1,28 +0,0 @@
-module Promote.OrdDeriving where
-
-import Data.Promotion.Prelude
-import Data.Promotion.TH
-
-$(promote [d|
-  data Nat = Zero | Succ Nat
-    deriving (Eq, Ord)
-
-  data Foo a b c d = A a b c d
-                   | B a b c d
-                   | C a b c d
-                   | D a b c d
-                   | E a b c d
-                   | F a b c d deriving (Eq,Ord)
-  |])
-
-foo1a :: Proxy (Zero :< Succ Zero)
-foo1a = Proxy
-
-foo1b :: Proxy True
-foo1b = foo1a
-
-foo2a :: Proxy (Succ (Succ Zero) `Compare` Zero)
-foo2a = Proxy
-
-foo2b :: Proxy GT
-foo2b = foo2a
diff --git a/tests/compile-and-dump/Promote/Pragmas.ghc710.template b/tests/compile-and-dump/Promote/Pragmas.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/Pragmas.ghc710.template
@@ -0,0 +1,12 @@
+Promote/Pragmas.hs:(0,0)-(0,0): Splicing declarations
+    promote
+      [d| {-# INLINE foo #-}
+          foo :: Bool
+          foo = True |]
+  ======>
+    {-# INLINE foo #-}
+    foo :: Bool
+    foo = True
+    type FooSym0 = Foo
+    type family Foo :: Bool where
+      Foo = TrueSym0
diff --git a/tests/compile-and-dump/Promote/Pragmas.ghc78.template b/tests/compile-and-dump/Promote/Pragmas.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/Pragmas.ghc78.template
+++ /dev/null
@@ -1,12 +0,0 @@
-Promote/Pragmas.hs:0:0: Splicing declarations
-    promote
-      [d| {-# INLINE foo #-}
-          foo :: Bool
-          foo = True |]
-  ======>
-    Promote/Pragmas.hs:(0,0)-(0,0)
-    {-# INLINE foo #-}
-    foo :: Bool
-    foo = True
-    type FooSym0 = Foo
-    type Foo = (TrueSym0 :: Bool)
diff --git a/tests/compile-and-dump/Promote/Prelude.ghc710.template b/tests/compile-and-dump/Promote/Prelude.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Promote/Prelude.ghc710.template
@@ -0,0 +1,17 @@
+Promote/Prelude.hs:(0,0)-(0,0): Splicing declarations
+    promoteOnly
+      [d| odd :: Nat -> Bool
+          odd 0 = False
+          odd n = not . odd $ n - 1 |]
+  ======>
+    type OddSym1 (t :: Nat) = Odd t
+    instance SuppressUnusedWarnings OddSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) OddSym0KindInference GHC.Tuple.())
+    data OddSym0 (l :: TyFun Nat Bool)
+      = forall arg. Data.Singletons.KindOf (Apply OddSym0 arg) ~ Data.Singletons.KindOf (OddSym1 arg) =>
+        OddSym0KindInference
+    type instance Apply OddSym0 l = OddSym1 l
+    type family Odd (a :: Nat) :: Bool where
+      Odd 0 = FalseSym0
+      Odd n = Apply (Apply ($$) (Apply (Apply (:.$) NotSym0) OddSym0)) (Apply (Apply (:-$) n) (FromInteger 1))
diff --git a/tests/compile-and-dump/Promote/Prelude.ghc78.template b/tests/compile-and-dump/Promote/Prelude.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/Prelude.ghc78.template
+++ /dev/null
@@ -1,18 +0,0 @@
-Promote/Prelude.hs:0:0: Splicing declarations
-    promoteOnly
-      [d| odd :: Nat -> Bool
-          odd 0 = False
-          odd n = not . odd $ n - 1 |]
-  ======>
-    Promote/Prelude.hs:(0,0)-(0,0)
-    type OddSym1 (t :: Nat) = Odd t
-    instance SuppressUnusedWarnings OddSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) OddSym0KindInference GHC.Tuple.())
-    data OddSym0 (l :: TyFun Nat Bool)
-      = forall arg. Data.Singletons.KindOf (Apply OddSym0 arg) ~ Data.Singletons.KindOf (OddSym1 arg) =>
-        OddSym0KindInference
-    type instance Apply OddSym0 l = OddSym1 l
-    type family Odd (a :: Nat) :: Bool where
-      Odd 0 = FalseSym0
-      Odd n = Apply (Apply ($$) (Apply (Apply (:.$) NotSym0) OddSym0)) (Apply (Apply (:-$) n) 1)
diff --git a/tests/compile-and-dump/Promote/Prelude.hs b/tests/compile-and-dump/Promote/Prelude.hs
--- a/tests/compile-and-dump/Promote/Prelude.hs
+++ b/tests/compile-and-dump/Promote/Prelude.hs
@@ -4,6 +4,7 @@
 import Data.Promotion.Prelude
 import Data.Promotion.Prelude.List
 import Data.Proxy
+import GHC.TypeLits
 
 lengthTest1a :: Proxy (Length '[True, True, True, True])
 lengthTest1a = Proxy
diff --git a/tests/compile-and-dump/Promote/TopLevelPatterns.ghc78.template b/tests/compile-and-dump/Promote/TopLevelPatterns.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/TopLevelPatterns.ghc78.template
+++ /dev/null
@@ -1,152 +0,0 @@
-Promote/TopLevelPatterns.hs:0:0: Splicing declarations
-    promote
-      [d| id :: a -> a
-          id x = x
-          not :: Bool -> Bool
-          not True = False
-          not False = True
-          f, g :: Bool -> Bool
-          [f, g] = [not, id]
-          h, i :: Bool -> Bool
-          (h, i) = (f, g)
-          j, k :: Bool
-          (Bar j k) = Bar True (h False)
-          l, m :: Bool
-          [l, m] = [not True, id False]
-          
-          data Bool = False | True
-          data Foo = Bar Bool Bool |]
-  ======>
-    Promote/TopLevelPatterns.hs:(0,0)-(0,0)
-    data Bool = False | True
-    data Foo = Bar Bool Bool
-    id :: forall a. a -> a
-    id x = x
-    not :: Bool -> Bool
-    not True = False
-    not False = True
-    f :: Bool -> Bool
-    g :: Bool -> Bool
-    [f, g] = [not, id]
-    h :: Bool -> Bool
-    i :: Bool -> Bool
-    (h, i) = (f, g)
-    j :: Bool
-    k :: Bool
-    Bar j k = Bar True (h False)
-    l :: Bool
-    m :: Bool
-    [l, m] = [not True, id False]
-    type family Case_0123456789 a_0123456789 t where
-      Case_0123456789 a_0123456789 '[y_0123456789, z] = y_0123456789
-    type family Case_0123456789 a_0123456789 t where
-      Case_0123456789 a_0123456789 '[z, y_0123456789] = y_0123456789
-    type family Case_0123456789 a_0123456789 t where
-      Case_0123456789 a_0123456789 '(y_0123456789, z) = y_0123456789
-    type family Case_0123456789 a_0123456789 t where
-      Case_0123456789 a_0123456789 '(z, y_0123456789) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 (Bar y_0123456789 z) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 (Bar z y_0123456789) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 '[y_0123456789, z] = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 '[z, y_0123456789] = y_0123456789
-    type NotSym1 (t :: Bool) = Not t
-    instance SuppressUnusedWarnings NotSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) NotSym0KindInference GHC.Tuple.())
-    data NotSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply NotSym0 arg) ~ KindOf (NotSym1 arg) =>
-        NotSym0KindInference
-    type instance Apply NotSym0 l = NotSym1 l
-    type IdSym1 (t :: a) = Id t
-    instance SuppressUnusedWarnings IdSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.())
-    data IdSym0 (l :: TyFun a a)
-      = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) =>
-        IdSym0KindInference
-    type instance Apply IdSym0 l = IdSym1 l
-    type FSym1 (t :: Bool) = F t
-    instance SuppressUnusedWarnings FSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) FSym0KindInference GHC.Tuple.())
-    data FSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply FSym0 arg) ~ KindOf (FSym1 arg) =>
-        FSym0KindInference
-    type instance Apply FSym0 l = FSym1 l
-    type GSym1 (t :: Bool) = G t
-    instance SuppressUnusedWarnings GSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) GSym0KindInference GHC.Tuple.())
-    data GSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply GSym0 arg) ~ KindOf (GSym1 arg) =>
-        GSym0KindInference
-    type instance Apply GSym0 l = GSym1 l
-    type HSym1 (t :: Bool) = H t
-    instance SuppressUnusedWarnings HSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) HSym0KindInference GHC.Tuple.())
-    data HSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply HSym0 arg) ~ KindOf (HSym1 arg) =>
-        HSym0KindInference
-    type instance Apply HSym0 l = HSym1 l
-    type ISym1 (t :: Bool) = I t
-    instance SuppressUnusedWarnings ISym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) ISym0KindInference GHC.Tuple.())
-    data ISym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply ISym0 arg) ~ KindOf (ISym1 arg) =>
-        ISym0KindInference
-    type instance Apply ISym0 l = ISym1 l
-    type JSym0 = J
-    type KSym0 = K
-    type LSym0 = L
-    type MSym0 = M
-    type X_0123456789Sym0 = X_0123456789
-    type X_0123456789Sym0 = X_0123456789
-    type X_0123456789Sym0 = X_0123456789
-    type X_0123456789Sym0 = X_0123456789
-    type family Not (a :: Bool) :: Bool where
-      Not True = FalseSym0
-      Not False = TrueSym0
-    type family Id (a :: a) :: a where
-      Id x = x
-    type family F (a :: Bool) :: Bool where
-      F a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789
-    type family G (a :: Bool) :: Bool where
-      G a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789
-    type family H (a :: Bool) :: Bool where
-      H a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789
-    type family I (a :: Bool) :: Bool where
-      I a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789
-    type J = (Case_0123456789 X_0123456789Sym0 :: Bool)
-    type K = (Case_0123456789 X_0123456789Sym0 :: Bool)
-    type L = (Case_0123456789 X_0123456789Sym0 :: Bool)
-    type M = (Case_0123456789 X_0123456789Sym0 :: Bool)
-    type X_0123456789 =
-        Apply (Apply (:$) NotSym0) (Apply (Apply (:$) IdSym0) '[])
-    type X_0123456789 = Apply (Apply Tuple2Sym0 FSym0) GSym0
-    type X_0123456789 =
-        Apply (Apply BarSym0 TrueSym0) (Apply HSym0 FalseSym0)
-    type X_0123456789 =
-        Apply (Apply (:$) (Apply NotSym0 TrueSym0)) (Apply (Apply (:$) (Apply IdSym0 FalseSym0)) '[])
-    type FalseSym0 = False
-    type TrueSym0 = True
-    type BarSym2 (t :: Bool) (t :: Bool) = Bar t t
-    instance SuppressUnusedWarnings BarSym1 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.())
-    data BarSym1 (l :: Bool) (l :: TyFun Bool Foo)
-      = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) =>
-        BarSym1KindInference
-    type instance Apply (BarSym1 l) l = BarSym2 l l
-    instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
-    data BarSym0 (l :: TyFun Bool (TyFun Bool Foo -> *))
-      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
-        BarSym0KindInference
-    type instance Apply BarSym0 l = BarSym1 l
diff --git a/tests/compile-and-dump/Promote/TopLevelPatterns.hs b/tests/compile-and-dump/Promote/TopLevelPatterns.hs
deleted file mode 100644
--- a/tests/compile-and-dump/Promote/TopLevelPatterns.hs
+++ /dev/null
@@ -1,34 +0,0 @@
-{-# LANGUAGE NoImplicitPrelude #-}
-{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
-
-module Promote.TopLevelPatterns where
-
-import Data.Singletons
-import Data.Singletons.Prelude.List
-import Data.Singletons.SuppressUnusedWarnings
-import Data.Singletons.TH hiding (STrue, SFalse, TrueSym0, FalseSym0)
-
--- Remove this test once #54 is fixed
-$(promote [d|
-  data Bool = False | True
-  data Foo = Bar Bool Bool
-
-  id :: a -> a
-  id x = x
-
-  not :: Bool -> Bool
-  not True  = False
-  not False = True
-
-  f,g :: Bool -> Bool
-  [f,g] = [not, id]
-
-  h,i :: Bool -> Bool
-  (h,i) = (f, g)
-
-  j,k :: Bool
-  (Bar j k) = Bar True (h False)
-
-  l,m :: Bool
-  [l,m] = [not True, id False]
- |])
diff --git a/tests/compile-and-dump/Singletons/AsPattern.ghc710.template b/tests/compile-and-dump/Singletons/AsPattern.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/AsPattern.ghc710.template
@@ -0,0 +1,393 @@
+Singletons/AsPattern.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| maybePlus :: Maybe Nat -> Maybe Nat
+          maybePlus (Just n) = Just (plus (Succ Zero) n)
+          maybePlus p@Nothing = p
+          bar :: Maybe Nat -> Maybe Nat
+          bar x@(Just _) = x
+          bar Nothing = Nothing
+          baz_ :: Maybe Baz -> Maybe Baz
+          baz_ p@Nothing = p
+          baz_ p@(Just (Baz _ _ _)) = p
+          tup :: (Nat, Nat) -> (Nat, Nat)
+          tup p@(_, _) = p
+          foo :: [Nat] -> [Nat]
+          foo p@[] = p
+          foo p@[_] = p
+          foo p@(_ : _ : _) = p
+          
+          data Baz = Baz Nat Nat Nat |]
+  ======>
+    maybePlus :: Maybe Nat -> Maybe Nat
+    maybePlus (Just n) = Just (plus (Succ Zero) n)
+    maybePlus p@Nothing = p
+    bar :: Maybe Nat -> Maybe Nat
+    bar x@(Just _) = x
+    bar Nothing = Nothing
+    data Baz = Baz Nat Nat Nat
+    baz_ :: Maybe Baz -> Maybe Baz
+    baz_ p@Nothing = p
+    baz_ p@(Just (Baz _ _ _)) = p
+    tup :: (Nat, Nat) -> (Nat, Nat)
+    tup p@(_, _) = p
+    foo :: [Nat] -> [Nat]
+    foo p@GHC.Types.[] = p
+    foo p@[_] = p
+    foo p@(_ GHC.Types.: (_ GHC.Types.: _)) = p
+    type BazSym3 (t :: Nat) (t :: Nat) (t :: Nat) = Baz t t t
+    instance SuppressUnusedWarnings BazSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BazSym2KindInference GHC.Tuple.())
+    data BazSym2 (l :: Nat) (l :: Nat) (l :: TyFun Nat Baz)
+      = forall arg. KindOf (Apply (BazSym2 l l) arg) ~ KindOf (BazSym3 l l arg) =>
+        BazSym2KindInference
+    type instance Apply (BazSym2 l l) l = BazSym3 l l l
+    instance SuppressUnusedWarnings BazSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BazSym1KindInference GHC.Tuple.())
+    data BazSym1 (l :: Nat) (l :: TyFun Nat (TyFun Nat Baz -> *))
+      = forall arg. KindOf (Apply (BazSym1 l) arg) ~ KindOf (BazSym2 l arg) =>
+        BazSym1KindInference
+    type instance Apply (BazSym1 l) l = BazSym2 l l
+    instance SuppressUnusedWarnings BazSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.())
+    data BazSym0 (l :: TyFun Nat (TyFun Nat (TyFun Nat Baz -> *) -> *))
+      = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>
+        BazSym0KindInference
+    type instance Apply BazSym0 l = BazSym1 l
+    type Let0123456789PSym0 = Let0123456789P
+    type family Let0123456789P where
+      Let0123456789P = '[]
+    type Let0123456789PSym1 t = Let0123456789P t
+    instance SuppressUnusedWarnings Let0123456789PSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())
+    data Let0123456789PSym0 l
+      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>
+        Let0123456789PSym0KindInference
+    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l
+    type family Let0123456789P wild_0123456789 where
+      Let0123456789P wild_0123456789 = Apply (Apply (:$) wild_0123456789) '[]
+    type Let0123456789PSym3 t t t = Let0123456789P t t t
+    instance SuppressUnusedWarnings Let0123456789PSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym2KindInference GHC.Tuple.())
+    data Let0123456789PSym2 l l l
+      = forall arg. KindOf (Apply (Let0123456789PSym2 l l) arg) ~ KindOf (Let0123456789PSym3 l l arg) =>
+        Let0123456789PSym2KindInference
+    type instance Apply (Let0123456789PSym2 l l) l = Let0123456789PSym3 l l l
+    instance SuppressUnusedWarnings Let0123456789PSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())
+    data Let0123456789PSym1 l l
+      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>
+        Let0123456789PSym1KindInference
+    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l
+    instance SuppressUnusedWarnings Let0123456789PSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())
+    data Let0123456789PSym0 l
+      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>
+        Let0123456789PSym0KindInference
+    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l
+    type family Let0123456789P wild_0123456789
+                               wild_0123456789
+                               wild_0123456789 where
+      Let0123456789P wild_0123456789 wild_0123456789 wild_0123456789 = Apply (Apply (:$) wild_0123456789) (Apply (Apply (:$) wild_0123456789) wild_0123456789)
+    type Let0123456789PSym2 t t = Let0123456789P t t
+    instance SuppressUnusedWarnings Let0123456789PSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())
+    data Let0123456789PSym1 l l
+      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>
+        Let0123456789PSym1KindInference
+    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l
+    instance SuppressUnusedWarnings Let0123456789PSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())
+    data Let0123456789PSym0 l
+      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>
+        Let0123456789PSym0KindInference
+    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l
+    type family Let0123456789P wild_0123456789 wild_0123456789 where
+      Let0123456789P wild_0123456789 wild_0123456789 = Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789
+    type Let0123456789PSym0 = Let0123456789P
+    type family Let0123456789P where
+      Let0123456789P = NothingSym0
+    type Let0123456789PSym3 t t t = Let0123456789P t t t
+    instance SuppressUnusedWarnings Let0123456789PSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym2KindInference GHC.Tuple.())
+    data Let0123456789PSym2 l l l
+      = forall arg. KindOf (Apply (Let0123456789PSym2 l l) arg) ~ KindOf (Let0123456789PSym3 l l arg) =>
+        Let0123456789PSym2KindInference
+    type instance Apply (Let0123456789PSym2 l l) l = Let0123456789PSym3 l l l
+    instance SuppressUnusedWarnings Let0123456789PSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())
+    data Let0123456789PSym1 l l
+      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>
+        Let0123456789PSym1KindInference
+    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l
+    instance SuppressUnusedWarnings Let0123456789PSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())
+    data Let0123456789PSym0 l
+      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>
+        Let0123456789PSym0KindInference
+    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l
+    type family Let0123456789P wild_0123456789
+                               wild_0123456789
+                               wild_0123456789 where
+      Let0123456789P wild_0123456789 wild_0123456789 wild_0123456789 = Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789)
+    type Let0123456789XSym1 t = Let0123456789X t
+    instance SuppressUnusedWarnings Let0123456789XSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789XSym0KindInference GHC.Tuple.())
+    data Let0123456789XSym0 l
+      = forall arg. KindOf (Apply Let0123456789XSym0 arg) ~ KindOf (Let0123456789XSym1 arg) =>
+        Let0123456789XSym0KindInference
+    type instance Apply Let0123456789XSym0 l = Let0123456789XSym1 l
+    type family Let0123456789X wild_0123456789 where
+      Let0123456789X wild_0123456789 = Apply JustSym0 wild_0123456789
+    type Let0123456789PSym0 = Let0123456789P
+    type family Let0123456789P where
+      Let0123456789P = NothingSym0
+    type FooSym1 (t :: [Nat]) = Foo t
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun [Nat] [Nat])
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type TupSym1 (t :: (Nat, Nat)) = Tup t
+    instance SuppressUnusedWarnings TupSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) TupSym0KindInference GHC.Tuple.())
+    data TupSym0 (l :: TyFun (Nat, Nat) (Nat, Nat))
+      = forall arg. KindOf (Apply TupSym0 arg) ~ KindOf (TupSym1 arg) =>
+        TupSym0KindInference
+    type instance Apply TupSym0 l = TupSym1 l
+    type Baz_Sym1 (t :: Maybe Baz) = Baz_ t
+    instance SuppressUnusedWarnings Baz_Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Baz_Sym0KindInference GHC.Tuple.())
+    data Baz_Sym0 (l :: TyFun (Maybe Baz) (Maybe Baz))
+      = forall arg. KindOf (Apply Baz_Sym0 arg) ~ KindOf (Baz_Sym1 arg) =>
+        Baz_Sym0KindInference
+    type instance Apply Baz_Sym0 l = Baz_Sym1 l
+    type BarSym1 (t :: Maybe Nat) = Bar t
+    instance SuppressUnusedWarnings BarSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
+    data BarSym0 (l :: TyFun (Maybe Nat) (Maybe Nat))
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
+        BarSym0KindInference
+    type instance Apply BarSym0 l = BarSym1 l
+    type MaybePlusSym1 (t :: Maybe Nat) = MaybePlus t
+    instance SuppressUnusedWarnings MaybePlusSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MaybePlusSym0KindInference GHC.Tuple.())
+    data MaybePlusSym0 (l :: TyFun (Maybe Nat) (Maybe Nat))
+      = forall arg. KindOf (Apply MaybePlusSym0 arg) ~ KindOf (MaybePlusSym1 arg) =>
+        MaybePlusSym0KindInference
+    type instance Apply MaybePlusSym0 l = MaybePlusSym1 l
+    type family Foo (a :: [Nat]) :: [Nat] where
+      Foo '[] = Let0123456789PSym0
+      Foo '[wild_0123456789] = Let0123456789PSym1 wild_0123456789
+      Foo ((:) wild_0123456789 ((:) wild_0123456789 wild_0123456789)) = Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789
+    type family Tup (a :: (Nat, Nat)) :: (Nat, Nat) where
+      Tup '(wild_0123456789,
+            wild_0123456789) = Let0123456789PSym2 wild_0123456789 wild_0123456789
+    type family Baz_ (a :: Maybe Baz) :: Maybe Baz where
+      Baz_ Nothing = Let0123456789PSym0
+      Baz_ (Just (Baz wild_0123456789 wild_0123456789 wild_0123456789)) = Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789
+    type family Bar (a :: Maybe Nat) :: Maybe Nat where
+      Bar (Just wild_0123456789) = Let0123456789XSym1 wild_0123456789
+      Bar Nothing = NothingSym0
+    type family MaybePlus (a :: Maybe Nat) :: Maybe Nat where
+      MaybePlus (Just n) = Apply JustSym0 (Apply (Apply PlusSym0 (Apply SuccSym0 ZeroSym0)) n)
+      MaybePlus Nothing = Let0123456789PSym0
+    sFoo ::
+      forall (t :: [Nat]). Sing t -> Sing (Apply FooSym0 t :: [Nat])
+    sTup ::
+      forall (t :: (Nat, Nat)).
+      Sing t -> Sing (Apply TupSym0 t :: (Nat, Nat))
+    sBaz_ ::
+      forall (t :: Maybe Baz).
+      Sing t -> Sing (Apply Baz_Sym0 t :: Maybe Baz)
+    sBar ::
+      forall (t :: Maybe Nat).
+      Sing t -> Sing (Apply BarSym0 t :: Maybe Nat)
+    sMaybePlus ::
+      forall (t :: Maybe Nat).
+      Sing t -> Sing (Apply MaybePlusSym0 t :: Maybe Nat)
+    sFoo SNil
+      = let
+          lambda :: t ~ '[] => Sing (Apply FooSym0 '[] :: [Nat])
+          lambda
+            = let
+                sP :: Sing Let0123456789PSym0
+                sP = SNil
+              in sP
+        in lambda
+    sFoo (SCons sWild_0123456789 SNil)
+      = let
+          lambda ::
+            forall wild_0123456789. t ~ Apply (Apply (:$) wild_0123456789) '[] =>
+            Sing wild_0123456789
+            -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) '[]) :: [Nat])
+          lambda wild_0123456789
+            = let
+                sP :: Sing (Let0123456789PSym1 wild_0123456789)
+                sP
+                  = applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)
+                      SNil
+              in sP
+        in lambda sWild_0123456789
+    sFoo
+      (SCons sWild_0123456789 (SCons sWild_0123456789 sWild_0123456789))
+      = let
+          lambda ::
+            forall wild_0123456789
+                   wild_0123456789
+                   wild_0123456789. t ~ Apply (Apply (:$) wild_0123456789) (Apply (Apply (:$) wild_0123456789) wild_0123456789) =>
+            Sing wild_0123456789
+            -> Sing wild_0123456789
+               -> Sing wild_0123456789
+                  -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) (Apply (Apply (:$) wild_0123456789) wild_0123456789)) :: [Nat])
+          lambda wild_0123456789 wild_0123456789 wild_0123456789
+            = let
+                sP ::
+                  Sing (Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789)
+                sP
+                  = applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)
+                      (applySing
+                         (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)
+                         wild_0123456789)
+              in sP
+        in lambda sWild_0123456789 sWild_0123456789 sWild_0123456789
+    sTup (STuple2 sWild_0123456789 sWild_0123456789)
+      = let
+          lambda ::
+            forall wild_0123456789
+                   wild_0123456789. t ~ Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789 =>
+            Sing wild_0123456789
+            -> Sing wild_0123456789
+               -> Sing (Apply TupSym0 (Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789) :: (Nat,
+                                                                                                     Nat))
+          lambda wild_0123456789 wild_0123456789
+            = let
+                sP :: Sing (Let0123456789PSym2 wild_0123456789 wild_0123456789)
+                sP
+                  = applySing
+                      (applySing
+                         (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) wild_0123456789)
+                      wild_0123456789
+              in sP
+        in lambda sWild_0123456789 sWild_0123456789
+    sBaz_ SNothing
+      = let
+          lambda ::
+            t ~ NothingSym0 => Sing (Apply Baz_Sym0 NothingSym0 :: Maybe Baz)
+          lambda
+            = let
+                sP :: Sing Let0123456789PSym0
+                sP = SNothing
+              in sP
+        in lambda
+    sBaz_
+      (SJust (SBaz sWild_0123456789 sWild_0123456789 sWild_0123456789))
+      = let
+          lambda ::
+            forall wild_0123456789
+                   wild_0123456789
+                   wild_0123456789. t ~ Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789) =>
+            Sing wild_0123456789
+            -> Sing wild_0123456789
+               -> Sing wild_0123456789
+                  -> Sing (Apply Baz_Sym0 (Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789)) :: Maybe Baz)
+          lambda wild_0123456789 wild_0123456789 wild_0123456789
+            = let
+                sP ::
+                  Sing (Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789)
+                sP
+                  = applySing
+                      (singFun1 (Proxy :: Proxy JustSym0) SJust)
+                      (applySing
+                         (applySing
+                            (applySing
+                               (singFun3 (Proxy :: Proxy BazSym0) SBaz) wild_0123456789)
+                            wild_0123456789)
+                         wild_0123456789)
+              in sP
+        in lambda sWild_0123456789 sWild_0123456789 sWild_0123456789
+    sBar (SJust sWild_0123456789)
+      = let
+          lambda ::
+            forall wild_0123456789. t ~ Apply JustSym0 wild_0123456789 =>
+            Sing wild_0123456789
+            -> Sing (Apply BarSym0 (Apply JustSym0 wild_0123456789) :: Maybe Nat)
+          lambda wild_0123456789
+            = let
+                sX :: Sing (Let0123456789XSym1 wild_0123456789)
+                sX
+                  = applySing
+                      (singFun1 (Proxy :: Proxy JustSym0) SJust) wild_0123456789
+              in sX
+        in lambda sWild_0123456789
+    sBar SNothing
+      = let
+          lambda ::
+            t ~ NothingSym0 => Sing (Apply BarSym0 NothingSym0 :: Maybe Nat)
+          lambda = SNothing
+        in lambda
+    sMaybePlus (SJust sN)
+      = let
+          lambda ::
+            forall n. t ~ Apply JustSym0 n =>
+            Sing n
+            -> Sing (Apply MaybePlusSym0 (Apply JustSym0 n) :: Maybe Nat)
+          lambda n
+            = applySing
+                (singFun1 (Proxy :: Proxy JustSym0) SJust)
+                (applySing
+                   (applySing
+                      (singFun2 (Proxy :: Proxy PlusSym0) sPlus)
+                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+                   n)
+        in lambda sN
+    sMaybePlus SNothing
+      = let
+          lambda ::
+            t ~ NothingSym0 =>
+            Sing (Apply MaybePlusSym0 NothingSym0 :: Maybe Nat)
+          lambda
+            = let
+                sP :: Sing Let0123456789PSym0
+                sP = SNothing
+              in sP
+        in lambda
+    data instance Sing (z :: Baz)
+      = forall (n :: Nat) (n :: Nat) (n :: Nat). z ~ Baz n n n =>
+        SBaz (Sing (n :: Nat)) (Sing (n :: Nat)) (Sing (n :: Nat))
+    type SBaz = (Sing :: Baz -> *)
+    instance SingKind (KProxy :: KProxy Baz) where
+      type DemoteRep (KProxy :: KProxy Baz) = Baz
+      fromSing (SBaz b b b) = Baz (fromSing b) (fromSing b) (fromSing b)
+      toSing (Baz b b b)
+        = case
+              GHC.Tuple.(,,)
+                (toSing b :: SomeSing (KProxy :: KProxy Nat))
+                (toSing b :: SomeSing (KProxy :: KProxy Nat))
+                (toSing b :: SomeSing (KProxy :: KProxy Nat))
+          of {
+            GHC.Tuple.(,,) (SomeSing c) (SomeSing c) (SomeSing c)
+              -> SomeSing (SBaz c c c) }
+    instance (SingI n, SingI n, SingI n) =>
+             SingI (Baz (n :: Nat) (n :: Nat) (n :: Nat)) where
+      sing = SBaz sing sing sing
diff --git a/tests/compile-and-dump/Singletons/AsPattern.ghc78.template b/tests/compile-and-dump/Singletons/AsPattern.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/AsPattern.ghc78.template
+++ /dev/null
@@ -1,362 +0,0 @@
-Singletons/AsPattern.hs:0:0: Splicing declarations
-    singletons
-      [d| maybePlus :: Maybe Nat -> Maybe Nat
-          maybePlus (Just n) = Just (plus (Succ Zero) n)
-          maybePlus p@Nothing = p
-          bar :: Maybe Nat -> Maybe Nat
-          bar x@(Just _) = x
-          bar Nothing = Nothing
-          baz_ :: Maybe Baz -> Maybe Baz
-          baz_ p@Nothing = p
-          baz_ p@(Just (Baz _ _ _)) = p
-          tup :: (Nat, Nat) -> (Nat, Nat)
-          tup p@(_, _) = p
-          foo :: [Nat] -> [Nat]
-          foo p@[] = p
-          foo p@[_] = p
-          foo p@(_ : _) = p
-          
-          data Baz = Baz Nat Nat Nat |]
-  ======>
-    Singletons/AsPattern.hs:(0,0)-(0,0)
-    maybePlus :: Maybe Nat -> Maybe Nat
-    maybePlus (Just n) = Just (plus (Succ Zero) n)
-    maybePlus p@Nothing = p
-    bar :: Maybe Nat -> Maybe Nat
-    bar x@(Just _) = x
-    bar Nothing = Nothing
-    data Baz = Baz Nat Nat Nat
-    baz_ :: Maybe Baz -> Maybe Baz
-    baz_ p@Nothing = p
-    baz_ p@(Just (Baz _ _ _)) = p
-    tup :: (Nat, Nat) -> (Nat, Nat)
-    tup p@(_, _) = p
-    foo :: [Nat] -> [Nat]
-    foo p@GHC.Types.[] = p
-    foo p@[_] = p
-    foo p@(_ GHC.Types.: _) = p
-    type BazSym3 (t :: Nat) (t :: Nat) (t :: Nat) = Baz t t t
-    instance SuppressUnusedWarnings BazSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BazSym2KindInference GHC.Tuple.())
-    data BazSym2 (l :: Nat) (l :: Nat) (l :: TyFun Nat Baz)
-      = forall arg. KindOf (Apply (BazSym2 l l) arg) ~ KindOf (BazSym3 l l arg) =>
-        BazSym2KindInference
-    type instance Apply (BazSym2 l l) l = BazSym3 l l l
-    instance SuppressUnusedWarnings BazSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BazSym1KindInference GHC.Tuple.())
-    data BazSym1 (l :: Nat) (l :: TyFun Nat (TyFun Nat Baz -> *))
-      = forall arg. KindOf (Apply (BazSym1 l) arg) ~ KindOf (BazSym2 l arg) =>
-        BazSym1KindInference
-    type instance Apply (BazSym1 l) l = BazSym2 l l
-    instance SuppressUnusedWarnings BazSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.())
-    data BazSym0 (l :: TyFun Nat (TyFun Nat (TyFun Nat Baz -> *) -> *))
-      = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>
-        BazSym0KindInference
-    type instance Apply BazSym0 l = BazSym1 l
-    type Let0123456789PSym0 = Let0123456789P
-    type Let0123456789P = '[]
-    type Let0123456789PSym1 t = Let0123456789P t
-    instance SuppressUnusedWarnings Let0123456789PSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())
-    data Let0123456789PSym0 l
-      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>
-        Let0123456789PSym0KindInference
-    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l
-    type Let0123456789P wild_0123456789 =
-        Apply (Apply (:$) wild_0123456789) '[]
-    type Let0123456789PSym2 t t = Let0123456789P t t
-    instance SuppressUnusedWarnings Let0123456789PSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())
-    data Let0123456789PSym1 l l
-      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>
-        Let0123456789PSym1KindInference
-    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l
-    instance SuppressUnusedWarnings Let0123456789PSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())
-    data Let0123456789PSym0 l
-      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>
-        Let0123456789PSym0KindInference
-    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l
-    type Let0123456789P wild_0123456789 wild_0123456789 =
-        Apply (Apply (:$) wild_0123456789) wild_0123456789
-    type Let0123456789PSym2 t t = Let0123456789P t t
-    instance SuppressUnusedWarnings Let0123456789PSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())
-    data Let0123456789PSym1 l l
-      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>
-        Let0123456789PSym1KindInference
-    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l
-    instance SuppressUnusedWarnings Let0123456789PSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())
-    data Let0123456789PSym0 l
-      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>
-        Let0123456789PSym0KindInference
-    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l
-    type Let0123456789P wild_0123456789 wild_0123456789 =
-        Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789
-    type Let0123456789PSym0 = Let0123456789P
-    type Let0123456789P = NothingSym0
-    type Let0123456789PSym3 t t t = Let0123456789P t t t
-    instance SuppressUnusedWarnings Let0123456789PSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789PSym2KindInference GHC.Tuple.())
-    data Let0123456789PSym2 l l l
-      = forall arg. KindOf (Apply (Let0123456789PSym2 l l) arg) ~ KindOf (Let0123456789PSym3 l l arg) =>
-        Let0123456789PSym2KindInference
-    type instance Apply (Let0123456789PSym2 l l) l = Let0123456789PSym3 l l l
-    instance SuppressUnusedWarnings Let0123456789PSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())
-    data Let0123456789PSym1 l l
-      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>
-        Let0123456789PSym1KindInference
-    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l
-    instance SuppressUnusedWarnings Let0123456789PSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())
-    data Let0123456789PSym0 l
-      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>
-        Let0123456789PSym0KindInference
-    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l
-    type Let0123456789P wild_0123456789
-                         wild_0123456789
-                         wild_0123456789 =
-        Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789)
-    type Let0123456789XSym1 t = Let0123456789X t
-    instance SuppressUnusedWarnings Let0123456789XSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789XSym0KindInference GHC.Tuple.())
-    data Let0123456789XSym0 l
-      = forall arg. KindOf (Apply Let0123456789XSym0 arg) ~ KindOf (Let0123456789XSym1 arg) =>
-        Let0123456789XSym0KindInference
-    type instance Apply Let0123456789XSym0 l = Let0123456789XSym1 l
-    type Let0123456789X wild_0123456789 =
-        Apply JustSym0 wild_0123456789
-    type Let0123456789PSym0 = Let0123456789P
-    type Let0123456789P = NothingSym0
-    type FooSym1 (t :: [Nat]) = Foo t
-    instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
-    data FooSym0 (l :: TyFun [Nat] [Nat])
-      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
-        FooSym0KindInference
-    type instance Apply FooSym0 l = FooSym1 l
-    type TupSym1 (t :: (Nat, Nat)) = Tup t
-    instance SuppressUnusedWarnings TupSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) TupSym0KindInference GHC.Tuple.())
-    data TupSym0 (l :: TyFun (Nat, Nat) (Nat, Nat))
-      = forall arg. KindOf (Apply TupSym0 arg) ~ KindOf (TupSym1 arg) =>
-        TupSym0KindInference
-    type instance Apply TupSym0 l = TupSym1 l
-    type Baz_Sym1 (t :: Maybe Baz) = Baz_ t
-    instance SuppressUnusedWarnings Baz_Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Baz_Sym0KindInference GHC.Tuple.())
-    data Baz_Sym0 (l :: TyFun (Maybe Baz) (Maybe Baz))
-      = forall arg. KindOf (Apply Baz_Sym0 arg) ~ KindOf (Baz_Sym1 arg) =>
-        Baz_Sym0KindInference
-    type instance Apply Baz_Sym0 l = Baz_Sym1 l
-    type BarSym1 (t :: Maybe Nat) = Bar t
-    instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
-    data BarSym0 (l :: TyFun (Maybe Nat) (Maybe Nat))
-      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
-        BarSym0KindInference
-    type instance Apply BarSym0 l = BarSym1 l
-    type MaybePlusSym1 (t :: Maybe Nat) = MaybePlus t
-    instance SuppressUnusedWarnings MaybePlusSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) MaybePlusSym0KindInference GHC.Tuple.())
-    data MaybePlusSym0 (l :: TyFun (Maybe Nat) (Maybe Nat))
-      = forall arg. KindOf (Apply MaybePlusSym0 arg) ~ KindOf (MaybePlusSym1 arg) =>
-        MaybePlusSym0KindInference
-    type instance Apply MaybePlusSym0 l = MaybePlusSym1 l
-    type family Foo (a :: [Nat]) :: [Nat] where
-      Foo '[] = Let0123456789PSym0
-      Foo '[wild_0123456789] = Let0123456789PSym1 wild_0123456789
-      Foo ((:) wild_0123456789 wild_0123456789) = Let0123456789PSym2 wild_0123456789 wild_0123456789
-    type family Tup (a :: (Nat, Nat)) :: (Nat, Nat) where
-      Tup '(wild_0123456789,
-            wild_0123456789) = Let0123456789PSym2 wild_0123456789 wild_0123456789
-    type family Baz_ (a :: Maybe Baz) :: Maybe Baz where
-      Baz_ Nothing = Let0123456789PSym0
-      Baz_ (Just (Baz wild_0123456789 wild_0123456789 wild_0123456789)) = Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789
-    type family Bar (a :: Maybe Nat) :: Maybe Nat where
-      Bar (Just wild_0123456789) = Let0123456789XSym1 wild_0123456789
-      Bar Nothing = NothingSym0
-    type family MaybePlus (a :: Maybe Nat) :: Maybe Nat where
-      MaybePlus (Just n) = Apply JustSym0 (Apply (Apply PlusSym0 (Apply SuccSym0 ZeroSym0)) n)
-      MaybePlus Nothing = Let0123456789PSym0
-    sFoo :: forall (t :: [Nat]). Sing t -> Sing (Apply FooSym0 t)
-    sTup :: forall (t :: (Nat, Nat)). Sing t -> Sing (Apply TupSym0 t)
-    sBaz_ :: forall (t :: Maybe Baz). Sing t -> Sing (Apply Baz_Sym0 t)
-    sBar :: forall (t :: Maybe Nat). Sing t -> Sing (Apply BarSym0 t)
-    sMaybePlus ::
-      forall (t :: Maybe Nat). Sing t -> Sing (Apply MaybePlusSym0 t)
-    sFoo SNil
-      = let
-          lambda :: t ~ '[] => Sing (Apply FooSym0 '[])
-          lambda
-            = let
-                sP :: Sing Let0123456789PSym0
-                sP = SNil
-              in sP
-        in lambda
-    sFoo (SCons sWild_0123456789 SNil)
-      = let
-          lambda ::
-            forall wild_0123456789. t ~ Apply (Apply (:$) wild_0123456789) '[] =>
-            Sing wild_0123456789
-            -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) '[]))
-          lambda wild_0123456789
-            = let
-                sP :: Sing (Let0123456789PSym1 wild_0123456789)
-                sP
-                  = applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)
-                      SNil
-              in sP
-        in lambda sWild_0123456789
-    sFoo (SCons sWild_0123456789 sWild_0123456789)
-      = let
-          lambda ::
-            forall wild_0123456789
-                   wild_0123456789. t ~ Apply (Apply (:$) wild_0123456789) wild_0123456789 =>
-            Sing wild_0123456789
-            -> Sing wild_0123456789
-               -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) wild_0123456789))
-          lambda wild_0123456789 wild_0123456789
-            = let
-                sP :: Sing (Let0123456789PSym2 wild_0123456789 wild_0123456789)
-                sP
-                  = applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)
-                      wild_0123456789
-              in sP
-        in lambda sWild_0123456789 sWild_0123456789
-    sTup (STuple2 sWild_0123456789 sWild_0123456789)
-      = let
-          lambda ::
-            forall wild_0123456789
-                   wild_0123456789. t ~ Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789 =>
-            Sing wild_0123456789
-            -> Sing wild_0123456789
-               -> Sing (Apply TupSym0 (Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789))
-          lambda wild_0123456789 wild_0123456789
-            = let
-                sP :: Sing (Let0123456789PSym2 wild_0123456789 wild_0123456789)
-                sP
-                  = applySing
-                      (applySing
-                         (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) wild_0123456789)
-                      wild_0123456789
-              in sP
-        in lambda sWild_0123456789 sWild_0123456789
-    sBaz_ SNothing
-      = let
-          lambda :: t ~ NothingSym0 => Sing (Apply Baz_Sym0 NothingSym0)
-          lambda
-            = let
-                sP :: Sing Let0123456789PSym0
-                sP = SNothing
-              in sP
-        in lambda
-    sBaz_
-      (SJust (SBaz sWild_0123456789 sWild_0123456789 sWild_0123456789))
-      = let
-          lambda ::
-            forall wild_0123456789
-                   wild_0123456789
-                   wild_0123456789. t ~ Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789) =>
-            Sing wild_0123456789
-            -> Sing wild_0123456789
-               -> Sing wild_0123456789
-                  -> Sing (Apply Baz_Sym0 (Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789)))
-          lambda wild_0123456789 wild_0123456789 wild_0123456789
-            = let
-                sP ::
-                  Sing (Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789)
-                sP
-                  = applySing
-                      (singFun1 (Proxy :: Proxy JustSym0) SJust)
-                      (applySing
-                         (applySing
-                            (applySing
-                               (singFun3 (Proxy :: Proxy BazSym0) SBaz) wild_0123456789)
-                            wild_0123456789)
-                         wild_0123456789)
-              in sP
-        in lambda sWild_0123456789 sWild_0123456789 sWild_0123456789
-    sBar (SJust sWild_0123456789)
-      = let
-          lambda ::
-            forall wild_0123456789. t ~ Apply JustSym0 wild_0123456789 =>
-            Sing wild_0123456789
-            -> Sing (Apply BarSym0 (Apply JustSym0 wild_0123456789))
-          lambda wild_0123456789
-            = let
-                sX :: Sing (Let0123456789XSym1 wild_0123456789)
-                sX
-                  = applySing
-                      (singFun1 (Proxy :: Proxy JustSym0) SJust) wild_0123456789
-              in sX
-        in lambda sWild_0123456789
-    sBar SNothing
-      = let
-          lambda :: t ~ NothingSym0 => Sing (Apply BarSym0 NothingSym0)
-          lambda = SNothing
-        in lambda
-    sMaybePlus (SJust sN)
-      = let
-          lambda ::
-            forall n. t ~ Apply JustSym0 n =>
-            Sing n -> Sing (Apply MaybePlusSym0 (Apply JustSym0 n))
-          lambda n
-            = applySing
-                (singFun1 (Proxy :: Proxy JustSym0) SJust)
-                (applySing
-                   (applySing
-                      (singFun2 (Proxy :: Proxy PlusSym0) sPlus)
-                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-                   n)
-        in lambda sN
-    sMaybePlus SNothing
-      = let
-          lambda :: t ~ NothingSym0 => Sing (Apply MaybePlusSym0 NothingSym0)
-          lambda
-            = let
-                sP :: Sing Let0123456789PSym0
-                sP = SNothing
-              in sP
-        in lambda
-    data instance Sing (z :: Baz)
-      = forall (n :: Nat) (n :: Nat) (n :: Nat). z ~ Baz n n n =>
-        SBaz (Sing n) (Sing n) (Sing n)
-    type SBaz (z :: Baz) = Sing z
-    instance SingKind (KProxy :: KProxy Baz) where
-      type DemoteRep (KProxy :: KProxy Baz) = Baz
-      fromSing (SBaz b b b) = Baz (fromSing b) (fromSing b) (fromSing b)
-      toSing (Baz b b b)
-        = case
-              GHC.Tuple.(,,)
-                (toSing b :: SomeSing (KProxy :: KProxy Nat))
-                (toSing b :: SomeSing (KProxy :: KProxy Nat))
-                (toSing b :: SomeSing (KProxy :: KProxy Nat))
-          of {
-            GHC.Tuple.(,,) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing (SBaz c c c) }
-    instance (SingI n, SingI n, SingI n) =>
-             SingI (Baz (n :: Nat) (n :: Nat) (n :: Nat)) where
-      sing = SBaz sing sing sing
diff --git a/tests/compile-and-dump/Singletons/AsPattern.hs b/tests/compile-and-dump/Singletons/AsPattern.hs
--- a/tests/compile-and-dump/Singletons/AsPattern.hs
+++ b/tests/compile-and-dump/Singletons/AsPattern.hs
@@ -27,7 +27,7 @@
   tup p@(_, _) = p
 
   foo :: [Nat] -> [Nat]
-  foo p@[]    = p
-  foo p@[_]   = p
-  foo p@(_:_) = p
+  foo p@[]      = p
+  foo p@[_]     = p
+  foo p@(_:_:_) = p
  |])
diff --git a/tests/compile-and-dump/Singletons/BadBoundedDeriving.ghc710.template b/tests/compile-and-dump/Singletons/BadBoundedDeriving.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/BadBoundedDeriving.ghc710.template
@@ -0,0 +1,3 @@
+
+Singletons/BadBoundedDeriving.hs:0:0:
+    Can't derive Bounded instance for Foo_0 a_1.
diff --git a/tests/compile-and-dump/Singletons/BadBoundedDeriving.hs b/tests/compile-and-dump/Singletons/BadBoundedDeriving.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/BadBoundedDeriving.hs
@@ -0,0 +1,8 @@
+module Singletons.BadBoundedDeriving where
+
+import Data.Singletons.Prelude
+import Data.Singletons.TH
+
+$(singletons [d|
+  data Foo a = Foo | Bar a deriving (Bounded)
+  |])
diff --git a/tests/compile-and-dump/Singletons/BadEnumDeriving.ghc710.template b/tests/compile-and-dump/Singletons/BadEnumDeriving.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/BadEnumDeriving.ghc710.template
@@ -0,0 +1,3 @@
+
+Singletons/BadEnumDeriving.hs:0:0:
+    Can't derive Enum instance for Foo_0 a_1.
diff --git a/tests/compile-and-dump/Singletons/BadEnumDeriving.hs b/tests/compile-and-dump/Singletons/BadEnumDeriving.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/BadEnumDeriving.hs
@@ -0,0 +1,8 @@
+module Singletons.BadEnumDeriving where
+
+import Data.Singletons.TH
+
+$(singletons [d|
+  data Foo a = Foo a
+               deriving Enum
+  |])
diff --git a/tests/compile-and-dump/Singletons/BoundedDeriving.ghc710.template b/tests/compile-and-dump/Singletons/BoundedDeriving.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/BoundedDeriving.ghc710.template
@@ -0,0 +1,265 @@
+Singletons/BoundedDeriving.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data Foo1
+            = Foo1
+            deriving (Bounded)
+          data Foo2
+            = A | B | C | D | E
+            deriving (Bounded)
+          data Foo3 a
+            = Foo3 a
+            deriving (Bounded)
+          data Foo4 (a :: *) (b :: *)
+            = Foo41 | Foo42
+            deriving (Bounded)
+          data Pair
+            = Pair Bool Bool
+            deriving (Bounded) |]
+  ======>
+    data Foo1
+      = Foo1
+      deriving (Bounded)
+    data Foo2
+      = A | B | C | D | E
+      deriving (Bounded)
+    data Foo3 a
+      = Foo3 a
+      deriving (Bounded)
+    data Foo4 (a :: *) (b :: *)
+      = Foo41 | Foo42
+      deriving (Bounded)
+    data Pair
+      = Pair Bool Bool
+      deriving (Bounded)
+    type Foo1Sym0 = Foo1
+    type ASym0 = A
+    type BSym0 = B
+    type CSym0 = C
+    type DSym0 = D
+    type ESym0 = E
+    type Foo3Sym1 (t :: a) = Foo3 t
+    instance SuppressUnusedWarnings Foo3Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
+    data Foo3Sym0 (l :: TyFun a (Foo3 a))
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
+        Foo3Sym0KindInference
+    type instance Apply Foo3Sym0 l = Foo3Sym1 l
+    type Foo41Sym0 = Foo41
+    type Foo42Sym0 = Foo42
+    type PairSym2 (t :: Bool) (t :: Bool) = Pair t t
+    instance SuppressUnusedWarnings PairSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
+    data PairSym1 (l :: Bool) (l :: TyFun Bool Pair)
+      = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) =>
+        PairSym1KindInference
+    type instance Apply (PairSym1 l) l = PairSym2 l l
+    instance SuppressUnusedWarnings PairSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
+    data PairSym0 (l :: TyFun Bool (TyFun Bool Pair -> *))
+      = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) =>
+        PairSym0KindInference
+    type instance Apply PairSym0 l = PairSym1 l
+    type family MinBound_0123456789 :: Foo1 where
+      MinBound_0123456789 = Foo1Sym0
+    type MinBound_0123456789Sym0 = MinBound_0123456789
+    type family MaxBound_0123456789 :: Foo1 where
+      MaxBound_0123456789 = Foo1Sym0
+    type MaxBound_0123456789Sym0 = MaxBound_0123456789
+    instance PBounded (KProxy :: KProxy Foo1) where
+      type MinBound = MinBound_0123456789Sym0
+      type MaxBound = MaxBound_0123456789Sym0
+    type family MinBound_0123456789 :: Foo2 where
+      MinBound_0123456789 = ASym0
+    type MinBound_0123456789Sym0 = MinBound_0123456789
+    type family MaxBound_0123456789 :: Foo2 where
+      MaxBound_0123456789 = ESym0
+    type MaxBound_0123456789Sym0 = MaxBound_0123456789
+    instance PBounded (KProxy :: KProxy Foo2) where
+      type MinBound = MinBound_0123456789Sym0
+      type MaxBound = MaxBound_0123456789Sym0
+    type family MinBound_0123456789 :: Foo3 a where
+      MinBound_0123456789 = Apply Foo3Sym0 MinBoundSym0
+    type MinBound_0123456789Sym0 = MinBound_0123456789
+    type family MaxBound_0123456789 :: Foo3 a where
+      MaxBound_0123456789 = Apply Foo3Sym0 MaxBoundSym0
+    type MaxBound_0123456789Sym0 = MaxBound_0123456789
+    instance PBounded (KProxy :: KProxy (Foo3 a)) where
+      type MinBound = MinBound_0123456789Sym0
+      type MaxBound = MaxBound_0123456789Sym0
+    type family MinBound_0123456789 :: Foo4 a b where
+      MinBound_0123456789 = Foo41Sym0
+    type MinBound_0123456789Sym0 = MinBound_0123456789
+    type family MaxBound_0123456789 :: Foo4 a b where
+      MaxBound_0123456789 = Foo42Sym0
+    type MaxBound_0123456789Sym0 = MaxBound_0123456789
+    instance PBounded (KProxy :: KProxy (Foo4 a b)) where
+      type MinBound = MinBound_0123456789Sym0
+      type MaxBound = MaxBound_0123456789Sym0
+    type family MinBound_0123456789 :: Pair where
+      MinBound_0123456789 = Apply (Apply PairSym0 MinBoundSym0) MinBoundSym0
+    type MinBound_0123456789Sym0 = MinBound_0123456789
+    type family MaxBound_0123456789 :: Pair where
+      MaxBound_0123456789 = Apply (Apply PairSym0 MaxBoundSym0) MaxBoundSym0
+    type MaxBound_0123456789Sym0 = MaxBound_0123456789
+    instance PBounded (KProxy :: KProxy Pair) where
+      type MinBound = MinBound_0123456789Sym0
+      type MaxBound = MaxBound_0123456789Sym0
+    data instance Sing (z :: Foo1) = z ~ Foo1 => SFoo1
+    type SFoo1 = (Sing :: Foo1 -> *)
+    instance SingKind (KProxy :: KProxy Foo1) where
+      type DemoteRep (KProxy :: KProxy Foo1) = Foo1
+      fromSing SFoo1 = Foo1
+      toSing Foo1 = SomeSing SFoo1
+    data instance Sing (z :: Foo2)
+      = z ~ A => SA |
+        z ~ B => SB |
+        z ~ C => SC |
+        z ~ D => SD |
+        z ~ E => SE
+    type SFoo2 = (Sing :: Foo2 -> *)
+    instance SingKind (KProxy :: KProxy Foo2) where
+      type DemoteRep (KProxy :: KProxy Foo2) = Foo2
+      fromSing SA = A
+      fromSing SB = B
+      fromSing SC = C
+      fromSing SD = D
+      fromSing SE = E
+      toSing A = SomeSing SA
+      toSing B = SomeSing SB
+      toSing C = SomeSing SC
+      toSing D = SomeSing SD
+      toSing E = SomeSing SE
+    data instance Sing (z :: Foo3 a)
+      = forall (n :: a). z ~ Foo3 n => SFoo3 (Sing (n :: a))
+    type SFoo3 = (Sing :: Foo3 a -> *)
+    instance SingKind (KProxy :: KProxy a) =>
+             SingKind (KProxy :: KProxy (Foo3 a)) where
+      type DemoteRep (KProxy :: KProxy (Foo3 a)) = Foo3 (DemoteRep (KProxy :: KProxy a))
+      fromSing (SFoo3 b) = Foo3 (fromSing b)
+      toSing (Foo3 b)
+        = case toSing b :: SomeSing (KProxy :: KProxy a) of {
+            SomeSing c -> SomeSing (SFoo3 c) }
+    data instance Sing (z :: Foo4 a b)
+      = z ~ Foo41 => SFoo41 | z ~ Foo42 => SFoo42
+    type SFoo4 = (Sing :: Foo4 a b -> *)
+    instance (SingKind (KProxy :: KProxy a),
+              SingKind (KProxy :: KProxy b)) =>
+             SingKind (KProxy :: KProxy (Foo4 a b)) where
+      type DemoteRep (KProxy :: KProxy (Foo4 a b)) = Foo4 (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
+      fromSing SFoo41 = Foo41
+      fromSing SFoo42 = Foo42
+      toSing Foo41 = SomeSing SFoo41
+      toSing Foo42 = SomeSing SFoo42
+    data instance Sing (z :: Pair)
+      = forall (n :: Bool) (n :: Bool). z ~ Pair n n =>
+        SPair (Sing (n :: Bool)) (Sing (n :: Bool))
+    type SPair = (Sing :: Pair -> *)
+    instance SingKind (KProxy :: KProxy Pair) where
+      type DemoteRep (KProxy :: KProxy Pair) = Pair
+      fromSing (SPair b b) = Pair (fromSing b) (fromSing b)
+      toSing (Pair b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy Bool))
+                (toSing b :: SomeSing (KProxy :: KProxy Bool))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) }
+    instance SBounded (KProxy :: KProxy Foo1) where
+      sMinBound :: Sing (MinBoundSym0 :: Foo1)
+      sMaxBound :: Sing (MaxBoundSym0 :: Foo1)
+      sMinBound
+        = let
+            lambda :: Sing (MinBoundSym0 :: Foo1)
+            lambda = SFoo1
+          in lambda
+      sMaxBound
+        = let
+            lambda :: Sing (MaxBoundSym0 :: Foo1)
+            lambda = SFoo1
+          in lambda
+    instance SBounded (KProxy :: KProxy Foo2) where
+      sMinBound :: Sing (MinBoundSym0 :: Foo2)
+      sMaxBound :: Sing (MaxBoundSym0 :: Foo2)
+      sMinBound
+        = let
+            lambda :: Sing (MinBoundSym0 :: Foo2)
+            lambda = SA
+          in lambda
+      sMaxBound
+        = let
+            lambda :: Sing (MaxBoundSym0 :: Foo2)
+            lambda = SE
+          in lambda
+    instance SBounded (KProxy :: KProxy a) =>
+             SBounded (KProxy :: KProxy (Foo3 a)) where
+      sMinBound :: Sing (MinBoundSym0 :: Foo3 a)
+      sMaxBound :: Sing (MaxBoundSym0 :: Foo3 a)
+      sMinBound
+        = let
+            lambda :: Sing (MinBoundSym0 :: Foo3 a)
+            lambda
+              = applySing (singFun1 (Proxy :: Proxy Foo3Sym0) SFoo3) sMinBound
+          in lambda
+      sMaxBound
+        = let
+            lambda :: Sing (MaxBoundSym0 :: Foo3 a)
+            lambda
+              = applySing (singFun1 (Proxy :: Proxy Foo3Sym0) SFoo3) sMaxBound
+          in lambda
+    instance SBounded (KProxy :: KProxy (Foo4 a b)) where
+      sMinBound :: Sing (MinBoundSym0 :: Foo4 a b)
+      sMaxBound :: Sing (MaxBoundSym0 :: Foo4 a b)
+      sMinBound
+        = let
+            lambda :: Sing (MinBoundSym0 :: Foo4 a b)
+            lambda = SFoo41
+          in lambda
+      sMaxBound
+        = let
+            lambda :: Sing (MaxBoundSym0 :: Foo4 a b)
+            lambda = SFoo42
+          in lambda
+    instance SBounded (KProxy :: KProxy Bool) =>
+             SBounded (KProxy :: KProxy Pair) where
+      sMinBound :: Sing (MinBoundSym0 :: Pair)
+      sMaxBound :: Sing (MaxBoundSym0 :: Pair)
+      sMinBound
+        = let
+            lambda :: Sing (MinBoundSym0 :: Pair)
+            lambda
+              = applySing
+                  (applySing (singFun2 (Proxy :: Proxy PairSym0) SPair) sMinBound)
+                  sMinBound
+          in lambda
+      sMaxBound
+        = let
+            lambda :: Sing (MaxBoundSym0 :: Pair)
+            lambda
+              = applySing
+                  (applySing (singFun2 (Proxy :: Proxy PairSym0) SPair) sMaxBound)
+                  sMaxBound
+          in lambda
+    instance SingI Foo1 where
+      sing = SFoo1
+    instance SingI A where
+      sing = SA
+    instance SingI B where
+      sing = SB
+    instance SingI C where
+      sing = SC
+    instance SingI D where
+      sing = SD
+    instance SingI E where
+      sing = SE
+    instance SingI n => SingI (Foo3 (n :: a)) where
+      sing = SFoo3 sing
+    instance SingI Foo41 where
+      sing = SFoo41
+    instance SingI Foo42 where
+      sing = SFoo42
+    instance (SingI n, SingI n) =>
+             SingI (Pair (n :: Bool) (n :: Bool)) where
+      sing = SPair sing sing
diff --git a/tests/compile-and-dump/Singletons/BoundedDeriving.hs b/tests/compile-and-dump/Singletons/BoundedDeriving.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/BoundedDeriving.hs
@@ -0,0 +1,51 @@
+module Singletons.BoundedDeriving where
+
+import Data.Singletons.Prelude
+import Data.Singletons.TH
+
+$(singletons [d|
+  data Foo1 = Foo1 deriving (Bounded)
+  data Foo2 = A | B | C | D | E deriving (Bounded)
+  data Foo3 a = Foo3 a deriving (Bounded)
+  data Foo4 (a :: *) (b :: *) = Foo41 | Foo42 deriving Bounded
+
+  data Pair = Pair Bool Bool
+                  deriving Bounded
+
+  |])
+
+foo1a :: Proxy (MinBound :: Foo1)
+foo1a = Proxy
+
+foo1b :: Proxy 'Foo1
+foo1b = foo1a
+
+foo1c :: Proxy (MaxBound :: Foo1)
+foo1c = Proxy
+
+foo1d :: Proxy 'Foo1
+foo1d = foo1c
+
+foo2a :: Proxy (MinBound :: Foo2)
+foo2a = Proxy
+
+foo2b :: Proxy 'A
+foo2b = foo2a
+
+foo2c :: Proxy (MaxBound :: Foo2)
+foo2c = Proxy
+
+foo2d :: Proxy 'E
+foo2d = foo2c
+
+foo3a :: Proxy (MinBound :: Foo3 Bool)
+foo3a = Proxy
+
+foo3b :: Proxy ('Foo3 False)
+foo3b = foo3a
+
+foo3c :: Proxy (MaxBound :: Foo3 Bool)
+foo3c = Proxy
+
+foo3d :: Proxy ('Foo3 True)
+foo3d = foo3c
diff --git a/tests/compile-and-dump/Singletons/BoxUnBox.ghc710.template b/tests/compile-and-dump/Singletons/BoxUnBox.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/BoxUnBox.ghc710.template
@@ -0,0 +1,49 @@
+Singletons/BoxUnBox.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| unBox :: Box a -> a
+          unBox (FBox a) = a
+          
+          data Box a = FBox a |]
+  ======>
+    data Box a = FBox a
+    unBox :: forall a. Box a -> a
+    unBox (FBox a) = a
+    type FBoxSym1 (t :: a) = FBox t
+    instance SuppressUnusedWarnings FBoxSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FBoxSym0KindInference GHC.Tuple.())
+    data FBoxSym0 (l :: TyFun a (Box a))
+      = forall arg. KindOf (Apply FBoxSym0 arg) ~ KindOf (FBoxSym1 arg) =>
+        FBoxSym0KindInference
+    type instance Apply FBoxSym0 l = FBoxSym1 l
+    type UnBoxSym1 (t :: Box a) = UnBox t
+    instance SuppressUnusedWarnings UnBoxSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) UnBoxSym0KindInference GHC.Tuple.())
+    data UnBoxSym0 (l :: TyFun (Box a) a)
+      = forall arg. KindOf (Apply UnBoxSym0 arg) ~ KindOf (UnBoxSym1 arg) =>
+        UnBoxSym0KindInference
+    type instance Apply UnBoxSym0 l = UnBoxSym1 l
+    type family UnBox (a :: Box a) :: a where
+      UnBox (FBox a) = a
+    sUnBox ::
+      forall (t :: Box a). Sing t -> Sing (Apply UnBoxSym0 t :: a)
+    sUnBox (SFBox sA)
+      = let
+          lambda ::
+            forall a. t ~ Apply FBoxSym0 a =>
+            Sing a -> Sing (Apply UnBoxSym0 (Apply FBoxSym0 a) :: a)
+          lambda a = a
+        in lambda sA
+    data instance Sing (z :: Box a)
+      = forall (n :: a). z ~ FBox n => SFBox (Sing (n :: a))
+    type SBox = (Sing :: Box a -> *)
+    instance SingKind (KProxy :: KProxy a) =>
+             SingKind (KProxy :: KProxy (Box a)) where
+      type DemoteRep (KProxy :: KProxy (Box a)) = Box (DemoteRep (KProxy :: KProxy a))
+      fromSing (SFBox b) = FBox (fromSing b)
+      toSing (FBox b)
+        = case toSing b :: SomeSing (KProxy :: KProxy a) of {
+            SomeSing c -> SomeSing (SFBox c) }
+    instance SingI n => SingI (FBox (n :: a)) where
+      sing = SFBox sing
diff --git a/tests/compile-and-dump/Singletons/BoxUnBox.ghc78.template b/tests/compile-and-dump/Singletons/BoxUnBox.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/BoxUnBox.ghc78.template
+++ /dev/null
@@ -1,49 +0,0 @@
-Singletons/BoxUnBox.hs:0:0: Splicing declarations
-    singletons
-      [d| unBox :: Box a -> a
-          unBox (FBox a) = a
-          
-          data Box a = FBox a |]
-  ======>
-    Singletons/BoxUnBox.hs:(0,0)-(0,0)
-    data Box a = FBox a
-    unBox :: forall a. Box a -> a
-    unBox (FBox a) = a
-    type FBoxSym1 (t :: a) = FBox t
-    instance SuppressUnusedWarnings FBoxSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FBoxSym0KindInference GHC.Tuple.())
-    data FBoxSym0 (l :: TyFun a (Box a))
-      = forall arg. KindOf (Apply FBoxSym0 arg) ~ KindOf (FBoxSym1 arg) =>
-        FBoxSym0KindInference
-    type instance Apply FBoxSym0 l = FBoxSym1 l
-    type UnBoxSym1 (t :: Box a) = UnBox t
-    instance SuppressUnusedWarnings UnBoxSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) UnBoxSym0KindInference GHC.Tuple.())
-    data UnBoxSym0 (l :: TyFun (Box a) a)
-      = forall arg. KindOf (Apply UnBoxSym0 arg) ~ KindOf (UnBoxSym1 arg) =>
-        UnBoxSym0KindInference
-    type instance Apply UnBoxSym0 l = UnBoxSym1 l
-    type family UnBox (a :: Box a) :: a where
-      UnBox (FBox a) = a
-    sUnBox :: forall (t :: Box a). Sing t -> Sing (Apply UnBoxSym0 t)
-    sUnBox (SFBox sA)
-      = let
-          lambda ::
-            forall a. t ~ Apply FBoxSym0 a =>
-            Sing a -> Sing (Apply UnBoxSym0 (Apply FBoxSym0 a))
-          lambda a = a
-        in lambda sA
-    data instance Sing (z :: Box a)
-      = forall (n :: a). z ~ FBox n => SFBox (Sing n)
-    type SBox (z :: Box a) = Sing z
-    instance SingKind (KProxy :: KProxy a) =>
-             SingKind (KProxy :: KProxy (Box a)) where
-      type DemoteRep (KProxy :: KProxy (Box a)) = Box (DemoteRep (KProxy :: KProxy a))
-      fromSing (SFBox b) = FBox (fromSing b)
-      toSing (FBox b)
-        = case toSing b :: SomeSing (KProxy :: KProxy a) of {
-            SomeSing c -> SomeSing (SFBox c) }
-    instance SingI n => SingI (FBox (n :: a)) where
-      sing = SFBox sing
diff --git a/tests/compile-and-dump/Singletons/CaseExpressions.ghc710.template b/tests/compile-and-dump/Singletons/CaseExpressions.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/CaseExpressions.ghc710.template
@@ -0,0 +1,407 @@
+Singletons/CaseExpressions.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo1 :: a -> Maybe a -> a
+          foo1 d x
+            = case x of {
+                Just y -> y
+                Nothing -> d }
+          foo2 :: a -> Maybe a -> a
+          foo2 d _ = case (Just d) of { Just y -> y }
+          foo3 :: a -> b -> a
+          foo3 a b = case (a, b) of { (p, _) -> p }
+          foo4 :: forall a. a -> a
+          foo4 x
+            = case x of {
+                y -> let
+                       z :: a
+                       z = y
+                     in z }
+          foo5 :: a -> a
+          foo5 x = case x of { y -> (\ _ -> x) y } |]
+  ======>
+    foo1 :: forall a. a -> Maybe a -> a
+    foo1 d x
+      = case x of {
+          Just y -> y
+          Nothing -> d }
+    foo2 :: forall a. a -> Maybe a -> a
+    foo2 d _ = case Just d of { Just y -> y }
+    foo3 :: forall a b. a -> b -> a
+    foo3 a b = case (a, b) of { (p, _) -> p }
+    foo4 :: forall a. a -> a
+    foo4 x
+      = case x of {
+          y -> let
+                 z :: a
+                 z = y
+               in z }
+    foo5 :: forall a. a -> a
+    foo5 x = case x of { y -> \ _ -> x y }
+    type Let0123456789Scrutinee_0123456789Sym1 t =
+        Let0123456789Scrutinee_0123456789 t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 x where
+      Let0123456789Scrutinee_0123456789 x = x
+    type family Case_0123456789 x y arg_0123456789 t where
+      Case_0123456789 x y arg_0123456789 _z_0123456789 = x
+    type family Lambda_0123456789 x y t where
+      Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 x t where
+      Case_0123456789 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y
+    type Let0123456789Scrutinee_0123456789Sym1 t =
+        Let0123456789Scrutinee_0123456789 t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 x where
+      Let0123456789Scrutinee_0123456789 x = x
+    type Let0123456789ZSym2 t t = Let0123456789Z t t
+    instance SuppressUnusedWarnings Let0123456789ZSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())
+    data Let0123456789ZSym1 l l
+      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>
+        Let0123456789ZSym1KindInference
+    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l
+    instance SuppressUnusedWarnings Let0123456789ZSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
+    data Let0123456789ZSym0 l
+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
+        Let0123456789ZSym0KindInference
+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
+    type family Let0123456789Z x y :: a where
+      Let0123456789Z x y = y
+    type family Case_0123456789 x t where
+      Case_0123456789 x y = Let0123456789ZSym2 x y
+    type Let0123456789Scrutinee_0123456789Sym2 t t =
+        Let0123456789Scrutinee_0123456789 t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
+        Let0123456789Scrutinee_0123456789Sym1KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 a b where
+      Let0123456789Scrutinee_0123456789 a b = Apply (Apply Tuple2Sym0 a) b
+    type family Case_0123456789 a b t where
+      Case_0123456789 a b '(p, _z_0123456789) = p
+    type Let0123456789Scrutinee_0123456789Sym2 t t =
+        Let0123456789Scrutinee_0123456789 t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
+        Let0123456789Scrutinee_0123456789Sym1KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 d _z_0123456789 where
+      Let0123456789Scrutinee_0123456789 d _z_0123456789 = Apply JustSym0 d
+    type family Case_0123456789 d _z_0123456789 t where
+      Case_0123456789 d _z_0123456789 (Just y) = y
+    type Let0123456789Scrutinee_0123456789Sym2 t t =
+        Let0123456789Scrutinee_0123456789 t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
+        Let0123456789Scrutinee_0123456789Sym1KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 d x where
+      Let0123456789Scrutinee_0123456789 d x = x
+    type family Case_0123456789 d x t where
+      Case_0123456789 d x (Just y) = y
+      Case_0123456789 d x Nothing = d
+    type Foo5Sym1 (t :: a) = Foo5 t
+    instance SuppressUnusedWarnings Foo5Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
+    data Foo5Sym0 (l :: TyFun a a)
+      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
+        Foo5Sym0KindInference
+    type instance Apply Foo5Sym0 l = Foo5Sym1 l
+    type Foo4Sym1 (t :: a) = Foo4 t
+    instance SuppressUnusedWarnings Foo4Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
+    data Foo4Sym0 (l :: TyFun a a)
+      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
+        Foo4Sym0KindInference
+    type instance Apply Foo4Sym0 l = Foo4Sym1 l
+    type Foo3Sym2 (t :: a) (t :: b) = Foo3 t t
+    instance SuppressUnusedWarnings Foo3Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo3Sym1KindInference GHC.Tuple.())
+    data Foo3Sym1 (l :: a) (l :: TyFun b a)
+      = forall arg. KindOf (Apply (Foo3Sym1 l) arg) ~ KindOf (Foo3Sym2 l arg) =>
+        Foo3Sym1KindInference
+    type instance Apply (Foo3Sym1 l) l = Foo3Sym2 l l
+    instance SuppressUnusedWarnings Foo3Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
+    data Foo3Sym0 (l :: TyFun a (TyFun b a -> *))
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
+        Foo3Sym0KindInference
+    type instance Apply Foo3Sym0 l = Foo3Sym1 l
+    type Foo2Sym2 (t :: a) (t :: Maybe a) = Foo2 t t
+    instance SuppressUnusedWarnings Foo2Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
+    data Foo2Sym1 (l :: a) (l :: TyFun (Maybe a) a)
+      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
+        Foo2Sym1KindInference
+    type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
+    instance SuppressUnusedWarnings Foo2Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
+    data Foo2Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
+      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
+        Foo2Sym0KindInference
+    type instance Apply Foo2Sym0 l = Foo2Sym1 l
+    type Foo1Sym2 (t :: a) (t :: Maybe a) = Foo1 t t
+    instance SuppressUnusedWarnings Foo1Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
+    data Foo1Sym1 (l :: a) (l :: TyFun (Maybe a) a)
+      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
+        Foo1Sym1KindInference
+    type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
+    instance SuppressUnusedWarnings Foo1Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
+    data Foo1Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
+        Foo1Sym0KindInference
+    type instance Apply Foo1Sym0 l = Foo1Sym1 l
+    type family Foo5 (a :: a) :: a where
+      Foo5 x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)
+    type family Foo4 (a :: a) :: a where
+      Foo4 x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)
+    type family Foo3 (a :: a) (a :: b) :: a where
+      Foo3 a b = Case_0123456789 a b (Let0123456789Scrutinee_0123456789Sym2 a b)
+    type family Foo2 (a :: a) (a :: Maybe a) :: a where
+      Foo2 d _z_0123456789 = Case_0123456789 d _z_0123456789 (Let0123456789Scrutinee_0123456789Sym2 d _z_0123456789)
+    type family Foo1 (a :: a) (a :: Maybe a) :: a where
+      Foo1 d x = Case_0123456789 d x (Let0123456789Scrutinee_0123456789Sym2 d x)
+    sFoo5 :: forall (t :: a). Sing t -> Sing (Apply Foo5Sym0 t :: a)
+    sFoo4 :: forall (t :: a). Sing t -> Sing (Apply Foo4Sym0 t :: a)
+    sFoo3 ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a)
+    sFoo2 ::
+      forall (t :: a) (t :: Maybe a).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)
+    sFoo1 ::
+      forall (t :: a) (t :: Maybe a).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)
+    sFoo5 sX
+      = let
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 x :: a)
+          lambda x
+            = let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)
+                sScrutinee_0123456789 = x
+              in  case sScrutinee_0123456789 of {
+                    sY
+                      -> let
+                           lambda ::
+                             forall y. y ~ Let0123456789Scrutinee_0123456789Sym1 x =>
+                             Sing y -> Sing (Case_0123456789 x y)
+                           lambda y
+                             = applySing
+                                 (singFun1
+                                    (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
+                                    (\ sArg_0123456789
+                                       -> let
+                                            lambda ::
+                                              forall arg_0123456789.
+                                              Sing arg_0123456789
+                                              -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789)
+                                            lambda arg_0123456789
+                                              = case arg_0123456789 of {
+                                                  _s_z_0123456789
+                                                    -> let
+                                                         lambda ::
+                                                           forall _z_0123456789. _z_0123456789 ~ arg_0123456789 =>
+                                                           Sing _z_0123456789
+                                                           -> Sing (Case_0123456789 x y arg_0123456789 _z_0123456789)
+                                                         lambda _z_0123456789 = x
+                                                       in lambda _s_z_0123456789 } ::
+                                                  Sing (Case_0123456789 x y arg_0123456789 arg_0123456789)
+                                          in lambda sArg_0123456789))
+                                 y
+                         in lambda sY } ::
+                    Sing (Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x))
+        in lambda sX
+    sFoo4 sX
+      = let
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 x :: a)
+          lambda x
+            = let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)
+                sScrutinee_0123456789 = x
+              in  case sScrutinee_0123456789 of {
+                    sY
+                      -> let
+                           lambda ::
+                             forall y. y ~ Let0123456789Scrutinee_0123456789Sym1 x =>
+                             Sing y -> Sing (Case_0123456789 x y)
+                           lambda y
+                             = let
+                                 sZ :: Sing (Let0123456789ZSym2 x y :: a)
+                                 sZ = y
+                               in sZ
+                         in lambda sY } ::
+                    Sing (Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x))
+        in lambda sX
+    sFoo3 sA sB
+      = let
+          lambda ::
+            forall a b. (t ~ a, t ~ b) =>
+            Sing a -> Sing b -> Sing (Apply (Apply Foo3Sym0 a) b :: a)
+          lambda a b
+            = let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym2 a b)
+                sScrutinee_0123456789
+                  = applySing
+                      (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) a) b
+              in  case sScrutinee_0123456789 of {
+                    STuple2 sP _s_z_0123456789
+                      -> let
+                           lambda ::
+                             forall p
+                                    _z_0123456789. Apply (Apply Tuple2Sym0 p) _z_0123456789 ~ Let0123456789Scrutinee_0123456789Sym2 a b =>
+                             Sing p
+                             -> Sing _z_0123456789
+                                -> Sing (Case_0123456789 a b (Apply (Apply Tuple2Sym0 p) _z_0123456789))
+                           lambda p _z_0123456789 = p
+                         in lambda sP _s_z_0123456789 } ::
+                    Sing (Case_0123456789 a b (Let0123456789Scrutinee_0123456789Sym2 a b))
+        in lambda sA sB
+    sFoo2 sD _s_z_0123456789
+      = let
+          lambda ::
+            forall d _z_0123456789. (t ~ d, t ~ _z_0123456789) =>
+            Sing d
+            -> Sing _z_0123456789
+               -> Sing (Apply (Apply Foo2Sym0 d) _z_0123456789 :: a)
+          lambda d _z_0123456789
+            = let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym2 d _z_0123456789)
+                sScrutinee_0123456789
+                  = applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) d
+              in  case sScrutinee_0123456789 of {
+                    SJust sY
+                      -> let
+                           lambda ::
+                             forall y. Apply JustSym0 y ~ Let0123456789Scrutinee_0123456789Sym2 d _z_0123456789 =>
+                             Sing y -> Sing (Case_0123456789 d _z_0123456789 (Apply JustSym0 y))
+                           lambda y = y
+                         in lambda sY } ::
+                    Sing (Case_0123456789 d _z_0123456789 (Let0123456789Scrutinee_0123456789Sym2 d _z_0123456789))
+        in lambda sD _s_z_0123456789
+    sFoo1 sD sX
+      = let
+          lambda ::
+            forall d x. (t ~ d, t ~ x) =>
+            Sing d -> Sing x -> Sing (Apply (Apply Foo1Sym0 d) x :: a)
+          lambda d x
+            = let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym2 d x)
+                sScrutinee_0123456789 = x
+              in  case sScrutinee_0123456789 of {
+                    SJust sY
+                      -> let
+                           lambda ::
+                             forall y. Apply JustSym0 y ~ Let0123456789Scrutinee_0123456789Sym2 d x =>
+                             Sing y -> Sing (Case_0123456789 d x (Apply JustSym0 y))
+                           lambda y = y
+                         in lambda sY
+                    SNothing
+                      -> let
+                           lambda ::
+                             NothingSym0 ~ Let0123456789Scrutinee_0123456789Sym2 d x =>
+                             Sing (Case_0123456789 d x NothingSym0)
+                           lambda = d
+                         in lambda } ::
+                    Sing (Case_0123456789 d x (Let0123456789Scrutinee_0123456789Sym2 d x))
+        in lambda sD sX
diff --git a/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template b/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template
+++ /dev/null
@@ -1,379 +0,0 @@
-Singletons/CaseExpressions.hs:0:0: Splicing declarations
-    singletons
-      [d| foo1 :: a -> Maybe a -> a
-          foo1 d x
-            = case x of {
-                Just y -> y
-                Nothing -> d }
-          foo2 :: a -> Maybe a -> a
-          foo2 d _ = case (Just d) of { Just y -> y }
-          foo3 :: a -> b -> a
-          foo3 a b = case (a, b) of { (p, _) -> p }
-          foo4 :: forall a. a -> a
-          foo4 x
-            = case x of {
-                y -> let
-                       z :: a
-                       z = y
-                     in z }
-          foo5 :: a -> a
-          foo5 x = case x of { y -> (\ _ -> x) y } |]
-  ======>
-    Singletons/CaseExpressions.hs:(0,0)-(0,0)
-    foo1 :: forall a. a -> Maybe a -> a
-    foo1 d x
-      = case x of {
-          Just y -> y
-          Nothing -> d }
-    foo2 :: forall a. a -> Maybe a -> a
-    foo2 d _ = case Just d of { Just y -> y }
-    foo3 :: forall a b. a -> b -> a
-    foo3 a b = case (a, b) of { (p, _) -> p }
-    foo4 :: forall a. a -> a
-    foo4 x
-      = case x of {
-          y -> let
-                 z :: a
-                 z = y
-               in z }
-    foo5 :: forall a. a -> a
-    foo5 x = case x of { y -> \ _ -> x y }
-    type Let0123456789Scrutinee_0123456789Sym1 t =
-        Let0123456789Scrutinee_0123456789 t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 x = x
-    type family Case_0123456789 x y arg_0123456789 t where
-      Case_0123456789 x y arg_0123456789 z = x
-    type family Lambda_0123456789 x y t where
-      Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 x t where
-      Case_0123456789 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y
-    type Let0123456789Scrutinee_0123456789Sym1 t =
-        Let0123456789Scrutinee_0123456789 t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 x = x
-    type Let0123456789ZSym2 t t = Let0123456789Z t t
-    instance SuppressUnusedWarnings Let0123456789ZSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())
-    data Let0123456789ZSym1 l l
-      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>
-        Let0123456789ZSym1KindInference
-    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l
-    instance SuppressUnusedWarnings Let0123456789ZSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
-    data Let0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
-        Let0123456789ZSym0KindInference
-    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
-    type Let0123456789Z x y = (y :: a)
-    type family Case_0123456789 x t where
-      Case_0123456789 x y = Let0123456789ZSym2 x y
-    type Let0123456789Scrutinee_0123456789Sym2 t t =
-        Let0123456789Scrutinee_0123456789 t t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 a b =
-        Apply (Apply Tuple2Sym0 a) b
-    type family Case_0123456789 a b t where
-      Case_0123456789 a b '(p, z) = p
-    type Let0123456789Scrutinee_0123456789Sym1 t =
-        Let0123456789Scrutinee_0123456789 t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 d = Apply JustSym0 d
-    type family Case_0123456789 d t where
-      Case_0123456789 d (Just y) = y
-    type Let0123456789Scrutinee_0123456789Sym2 t t =
-        Let0123456789Scrutinee_0123456789 t t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 d x = x
-    type family Case_0123456789 d x t where
-      Case_0123456789 d x (Just y) = y
-      Case_0123456789 d x Nothing = d
-    type Foo5Sym1 (t :: a) = Foo5 t
-    instance SuppressUnusedWarnings Foo5Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
-    data Foo5Sym0 (l :: TyFun a a)
-      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
-        Foo5Sym0KindInference
-    type instance Apply Foo5Sym0 l = Foo5Sym1 l
-    type Foo4Sym1 (t :: a) = Foo4 t
-    instance SuppressUnusedWarnings Foo4Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
-    data Foo4Sym0 (l :: TyFun a a)
-      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
-        Foo4Sym0KindInference
-    type instance Apply Foo4Sym0 l = Foo4Sym1 l
-    type Foo3Sym2 (t :: a) (t :: b) = Foo3 t t
-    instance SuppressUnusedWarnings Foo3Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo3Sym1KindInference GHC.Tuple.())
-    data Foo3Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. KindOf (Apply (Foo3Sym1 l) arg) ~ KindOf (Foo3Sym2 l arg) =>
-        Foo3Sym1KindInference
-    type instance Apply (Foo3Sym1 l) l = Foo3Sym2 l l
-    instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
-    data Foo3Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
-        Foo3Sym0KindInference
-    type instance Apply Foo3Sym0 l = Foo3Sym1 l
-    type Foo2Sym2 (t :: a) (t :: Maybe a) = Foo2 t t
-    instance SuppressUnusedWarnings Foo2Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
-    data Foo2Sym1 (l :: a) (l :: TyFun (Maybe a) a)
-      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
-        Foo2Sym1KindInference
-    type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
-    instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
-    data Foo2Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
-      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
-        Foo2Sym0KindInference
-    type instance Apply Foo2Sym0 l = Foo2Sym1 l
-    type Foo1Sym2 (t :: a) (t :: Maybe a) = Foo1 t t
-    instance SuppressUnusedWarnings Foo1Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
-    data Foo1Sym1 (l :: a) (l :: TyFun (Maybe a) a)
-      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
-        Foo1Sym1KindInference
-    type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
-    instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
-    data Foo1Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
-      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
-        Foo1Sym0KindInference
-    type instance Apply Foo1Sym0 l = Foo1Sym1 l
-    type family Foo5 (a :: a) :: a where
-      Foo5 x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)
-    type family Foo4 (a :: a) :: a where
-      Foo4 x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)
-    type family Foo3 (a :: a) (a :: b) :: a where
-      Foo3 a b = Case_0123456789 a b (Let0123456789Scrutinee_0123456789Sym2 a b)
-    type family Foo2 (a :: a) (a :: Maybe a) :: a where
-      Foo2 d z = Case_0123456789 d (Let0123456789Scrutinee_0123456789Sym1 d)
-    type family Foo1 (a :: a) (a :: Maybe a) :: a where
-      Foo1 d x = Case_0123456789 d x (Let0123456789Scrutinee_0123456789Sym2 d x)
-    sFoo5 :: forall (t :: a). Sing t -> Sing (Apply Foo5Sym0 t)
-    sFoo4 :: forall (t :: a). Sing t -> Sing (Apply Foo4Sym0 t)
-    sFoo3 ::
-      forall (t :: a) (t :: b).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t)
-    sFoo2 ::
-      forall (t :: a) (t :: Maybe a).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t)
-    sFoo1 ::
-      forall (t :: a) (t :: Maybe a).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t)
-    sFoo5 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 x)
-          lambda x
-            = let
-                sScrutinee_0123456789 ::
-                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)
-                sScrutinee_0123456789 = x
-              in
-                case sScrutinee_0123456789 of {
-                  sY
-                    -> let
-                         lambda :: forall y. Sing y -> Sing (Case_0123456789 x y)
-                         lambda y
-                           = applySing
-                               (singFun1
-                                  (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
-                                  (\ sArg_0123456789
-                                     -> let
-                                          lambda ::
-                                            forall arg_0123456789.
-                                            Sing arg_0123456789
-                                            -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789)
-                                          lambda arg_0123456789
-                                            = case arg_0123456789 of {
-                                                _ -> let
-                                                       lambda ::
-                                                         forall wild.
-                                                         Sing (Case_0123456789 x y arg_0123456789 wild)
-                                                       lambda = x
-                                                     in lambda }
-                                        in lambda sArg_0123456789))
-                               y
-                       in lambda sY }
-        in lambda sX
-    sFoo4 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 x)
-          lambda x
-            = let
-                sScrutinee_0123456789 ::
-                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)
-                sScrutinee_0123456789 = x
-              in
-                case sScrutinee_0123456789 of {
-                  sY
-                    -> let
-                         lambda :: forall y. Sing y -> Sing (Case_0123456789 x y)
-                         lambda y
-                           = let
-                               sZ :: Sing (Let0123456789ZSym2 x y)
-                               sZ = y
-                             in sZ
-                       in lambda sY }
-        in lambda sX
-    sFoo3 sA sB
-      = let
-          lambda ::
-            forall a b. (t ~ a, t ~ b) =>
-            Sing a -> Sing b -> Sing (Apply (Apply Foo3Sym0 a) b)
-          lambda a b
-            = let
-                sScrutinee_0123456789 ::
-                  Sing (Let0123456789Scrutinee_0123456789Sym2 a b)
-                sScrutinee_0123456789
-                  = applySing
-                      (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) a) b
-              in
-                case sScrutinee_0123456789 of {
-                  STuple2 sP _
-                    -> let
-                         lambda ::
-                           forall p wild.
-                           Sing p
-                           -> Sing (Case_0123456789 a b (Apply (Apply Tuple2Sym0 p) wild))
-                         lambda p = p
-                       in lambda sP }
-        in lambda sA sB
-    sFoo2 sD _
-      = let
-          lambda ::
-            forall d wild. (t ~ d, t ~ wild) =>
-            Sing d -> Sing (Apply (Apply Foo2Sym0 d) wild)
-          lambda d
-            = let
-                sScrutinee_0123456789 ::
-                  Sing (Let0123456789Scrutinee_0123456789Sym1 d)
-                sScrutinee_0123456789
-                  = applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) d
-              in
-                case sScrutinee_0123456789 of {
-                  SJust sY
-                    -> let
-                         lambda ::
-                           forall y. Sing y -> Sing (Case_0123456789 d (Apply JustSym0 y))
-                         lambda y = y
-                       in lambda sY }
-        in lambda sD
-    sFoo1 sD sX
-      = let
-          lambda ::
-            forall d x. (t ~ d, t ~ x) =>
-            Sing d -> Sing x -> Sing (Apply (Apply Foo1Sym0 d) x)
-          lambda d x
-            = let
-                sScrutinee_0123456789 ::
-                  Sing (Let0123456789Scrutinee_0123456789Sym2 d x)
-                sScrutinee_0123456789 = x
-              in
-                case sScrutinee_0123456789 of {
-                  SJust sY
-                    -> let
-                         lambda ::
-                           forall y. Sing y -> Sing (Case_0123456789 d x (Apply JustSym0 y))
-                         lambda y = y
-                       in lambda sY
-                  SNothing
-                    -> let
-                         lambda :: Sing (Case_0123456789 d x NothingSym0)
-                         lambda = d
-                       in lambda }
-        in lambda sD sX
diff --git a/tests/compile-and-dump/Singletons/Classes.ghc710.template b/tests/compile-and-dump/Singletons/Classes.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Classes.ghc710.template
@@ -0,0 +1,652 @@
+Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| infix 4 <=>
+          
+          const :: a -> b -> a
+          const x _ = x
+          fooCompare :: Foo -> Foo -> Ordering
+          fooCompare A A = EQ
+          fooCompare A B = LT
+          fooCompare B B = GT
+          fooCompare B A = EQ
+          
+          class MyOrd a where
+            mycompare :: a -> a -> Ordering
+            (<=>) :: a -> a -> Ordering
+            (<=>) = mycompare
+            infix 4 <=>
+          data Foo = A | B
+          data Foo2 = F | G
+          
+          instance Eq Foo2 where
+            F == F = True
+            G == G = True
+            F == G = False
+            G == F = False
+          instance MyOrd Foo where
+            mycompare = fooCompare
+          instance MyOrd () where
+            mycompare _ = const EQ
+          instance MyOrd Nat where
+            Zero `mycompare` Zero = EQ
+            Zero `mycompare` (Succ _) = LT
+            (Succ _) `mycompare` Zero = GT
+            (Succ n) `mycompare` (Succ m) = m `mycompare` n |]
+  ======>
+    const :: forall a b. a -> b -> a
+    const x _ = x
+    class MyOrd a where
+      mycompare :: a -> a -> Ordering
+      (<=>) :: a -> a -> Ordering
+      (<=>) = mycompare
+    infix 4 <=>
+    instance MyOrd Nat where
+      mycompare Zero Zero = EQ
+      mycompare Zero (Succ _) = LT
+      mycompare (Succ _) Zero = GT
+      mycompare (Succ n) (Succ m) = (m `mycompare` n)
+    instance MyOrd () where
+      mycompare _ = const EQ
+    data Foo = A | B
+    fooCompare :: Foo -> Foo -> Ordering
+    fooCompare A A = EQ
+    fooCompare A B = LT
+    fooCompare B B = GT
+    fooCompare B A = EQ
+    instance MyOrd Foo where
+      mycompare = fooCompare
+    data Foo2 = F | G
+    instance Eq Foo2 where
+      (==) F F = True
+      (==) G G = True
+      (==) F G = False
+      (==) G F = False
+    type ASym0 = A
+    type BSym0 = B
+    type FSym0 = F
+    type GSym0 = G
+    type FooCompareSym2 (t :: Foo) (t :: Foo) = FooCompare t t
+    instance SuppressUnusedWarnings FooCompareSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooCompareSym1KindInference GHC.Tuple.())
+    data FooCompareSym1 (l :: Foo) (l :: TyFun Foo Ordering)
+      = forall arg. KindOf (Apply (FooCompareSym1 l) arg) ~ KindOf (FooCompareSym2 l arg) =>
+        FooCompareSym1KindInference
+    type instance Apply (FooCompareSym1 l) l = FooCompareSym2 l l
+    instance SuppressUnusedWarnings FooCompareSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooCompareSym0KindInference GHC.Tuple.())
+    data FooCompareSym0 (l :: TyFun Foo (TyFun Foo Ordering -> *))
+      = forall arg. KindOf (Apply FooCompareSym0 arg) ~ KindOf (FooCompareSym1 arg) =>
+        FooCompareSym0KindInference
+    type instance Apply FooCompareSym0 l = FooCompareSym1 l
+    type ConstSym2 (t :: a) (t :: b) = Const t t
+    instance SuppressUnusedWarnings ConstSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ConstSym1KindInference GHC.Tuple.())
+    data ConstSym1 (l :: a) (l :: TyFun b a)
+      = forall arg. KindOf (Apply (ConstSym1 l) arg) ~ KindOf (ConstSym2 l arg) =>
+        ConstSym1KindInference
+    type instance Apply (ConstSym1 l) l = ConstSym2 l l
+    instance SuppressUnusedWarnings ConstSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ConstSym0KindInference GHC.Tuple.())
+    data ConstSym0 (l :: TyFun a (TyFun b a -> *))
+      = forall arg. KindOf (Apply ConstSym0 arg) ~ KindOf (ConstSym1 arg) =>
+        ConstSym0KindInference
+    type instance Apply ConstSym0 l = ConstSym1 l
+    type family FooCompare (a :: Foo) (a :: Foo) :: Ordering where
+      FooCompare A A = EQSym0
+      FooCompare A B = LTSym0
+      FooCompare B B = GTSym0
+      FooCompare B A = EQSym0
+    type family Const (a :: a) (a :: b) :: a where
+      Const x _z_0123456789 = x
+    infix 4 :<=>
+    type MycompareSym2 (t :: a) (t :: a) = Mycompare t t
+    instance SuppressUnusedWarnings MycompareSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MycompareSym1KindInference GHC.Tuple.())
+    data MycompareSym1 (l :: a) (l :: TyFun a Ordering)
+      = forall arg. KindOf (Apply (MycompareSym1 l) arg) ~ KindOf (MycompareSym2 l arg) =>
+        MycompareSym1KindInference
+    type instance Apply (MycompareSym1 l) l = MycompareSym2 l l
+    instance SuppressUnusedWarnings MycompareSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MycompareSym0KindInference GHC.Tuple.())
+    data MycompareSym0 (l :: TyFun a (TyFun a Ordering -> *))
+      = forall arg. KindOf (Apply MycompareSym0 arg) ~ KindOf (MycompareSym1 arg) =>
+        MycompareSym0KindInference
+    type instance Apply MycompareSym0 l = MycompareSym1 l
+    type (:<=>$$$) (t :: a) (t :: a) = (:<=>) t t
+    instance SuppressUnusedWarnings (:<=>$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<=>$$###) GHC.Tuple.())
+    data (:<=>$$) (l :: a) (l :: TyFun a Ordering)
+      = forall arg. KindOf (Apply ((:<=>$$) l) arg) ~ KindOf ((:<=>$$$) l arg) =>
+        :<=>$$###
+    type instance Apply ((:<=>$$) l) l = (:<=>$$$) l l
+    instance SuppressUnusedWarnings (:<=>$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<=>$###) GHC.Tuple.())
+    data (:<=>$) (l :: TyFun a (TyFun a Ordering -> *))
+      = forall arg. KindOf (Apply (:<=>$) arg) ~ KindOf ((:<=>$$) arg) =>
+        :<=>$###
+    type instance Apply (:<=>$) l = (:<=>$$) l
+    type family TFHelper_0123456789 (a :: a) (a :: a) :: Ordering where
+      TFHelper_0123456789 a_0123456789 a_0123456789 = Apply (Apply MycompareSym0 a_0123456789) a_0123456789
+    type TFHelper_0123456789Sym2 (t :: a) (t :: a) =
+        TFHelper_0123456789 t t
+    instance SuppressUnusedWarnings TFHelper_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) TFHelper_0123456789Sym1KindInference GHC.Tuple.())
+    data TFHelper_0123456789Sym1 (l :: a) (l :: TyFun a Ordering)
+      = forall arg. KindOf (Apply (TFHelper_0123456789Sym1 l) arg) ~ KindOf (TFHelper_0123456789Sym2 l arg) =>
+        TFHelper_0123456789Sym1KindInference
+    type instance Apply (TFHelper_0123456789Sym1 l) l = TFHelper_0123456789Sym2 l l
+    instance SuppressUnusedWarnings TFHelper_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) TFHelper_0123456789Sym0KindInference GHC.Tuple.())
+    data TFHelper_0123456789Sym0 (l :: TyFun a (TyFun a Ordering -> *))
+      = forall arg. KindOf (Apply TFHelper_0123456789Sym0 arg) ~ KindOf (TFHelper_0123456789Sym1 arg) =>
+        TFHelper_0123456789Sym0KindInference
+    type instance Apply TFHelper_0123456789Sym0 l = TFHelper_0123456789Sym1 l
+    class kproxy ~ KProxy => PMyOrd (kproxy :: KProxy a) where
+      type family Mycompare (arg :: a) (arg :: a) :: Ordering
+      type family (:<=>) (arg :: a) (arg :: a) :: Ordering
+      (:<=>) (a :: a)
+             (a :: a) = Apply (Apply TFHelper_0123456789Sym0 a) a
+    type family Mycompare_0123456789 (a :: Nat)
+                                     (a :: Nat) :: Ordering where
+      Mycompare_0123456789 Zero Zero = EQSym0
+      Mycompare_0123456789 Zero (Succ _z_0123456789) = LTSym0
+      Mycompare_0123456789 (Succ _z_0123456789) Zero = GTSym0
+      Mycompare_0123456789 (Succ n) (Succ m) = Apply (Apply MycompareSym0 m) n
+    type Mycompare_0123456789Sym2 (t :: Nat) (t :: Nat) =
+        Mycompare_0123456789 t t
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym1 (l :: Nat) (l :: TyFun Nat Ordering)
+      = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) =>
+        Mycompare_0123456789Sym1KindInference
+    type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym0 (l :: TyFun Nat (TyFun Nat Ordering
+                                                   -> *))
+      = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) =>
+        Mycompare_0123456789Sym0KindInference
+    type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l
+    instance PMyOrd (KProxy :: KProxy Nat) where
+      type Mycompare (a :: Nat) (a :: Nat) = Apply (Apply Mycompare_0123456789Sym0 a) a
+    type family Mycompare_0123456789 (a :: ())
+                                     (a :: ()) :: Ordering where
+      Mycompare_0123456789 _z_0123456789 a_0123456789 = Apply (Apply ConstSym0 EQSym0) a_0123456789
+    type Mycompare_0123456789Sym2 (t :: ()) (t :: ()) =
+        Mycompare_0123456789 t t
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym1 (l :: ()) (l :: TyFun () Ordering)
+      = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) =>
+        Mycompare_0123456789Sym1KindInference
+    type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym0 (l :: TyFun () (TyFun () Ordering
+                                                  -> *))
+      = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) =>
+        Mycompare_0123456789Sym0KindInference
+    type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l
+    instance PMyOrd (KProxy :: KProxy ()) where
+      type Mycompare (a :: ()) (a :: ()) = Apply (Apply Mycompare_0123456789Sym0 a) a
+    type family Mycompare_0123456789 (a :: Foo)
+                                     (a :: Foo) :: Ordering where
+      Mycompare_0123456789 a_0123456789 a_0123456789 = Apply (Apply FooCompareSym0 a_0123456789) a_0123456789
+    type Mycompare_0123456789Sym2 (t :: Foo) (t :: Foo) =
+        Mycompare_0123456789 t t
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym1 (l :: Foo) (l :: TyFun Foo Ordering)
+      = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) =>
+        Mycompare_0123456789Sym1KindInference
+    type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym0 (l :: TyFun Foo (TyFun Foo Ordering
+                                                   -> *))
+      = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) =>
+        Mycompare_0123456789Sym0KindInference
+    type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l
+    instance PMyOrd (KProxy :: KProxy Foo) where
+      type Mycompare (a :: Foo) (a :: Foo) = Apply (Apply Mycompare_0123456789Sym0 a) a
+    type family TFHelper_0123456789 (a :: Foo2)
+                                    (a :: Foo2) :: Bool where
+      TFHelper_0123456789 F F = TrueSym0
+      TFHelper_0123456789 G G = TrueSym0
+      TFHelper_0123456789 F G = FalseSym0
+      TFHelper_0123456789 G F = FalseSym0
+    type TFHelper_0123456789Sym2 (t :: Foo2) (t :: Foo2) =
+        TFHelper_0123456789 t t
+    instance SuppressUnusedWarnings TFHelper_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) TFHelper_0123456789Sym1KindInference GHC.Tuple.())
+    data TFHelper_0123456789Sym1 (l :: Foo2) (l :: TyFun Foo2 Bool)
+      = forall arg. KindOf (Apply (TFHelper_0123456789Sym1 l) arg) ~ KindOf (TFHelper_0123456789Sym2 l arg) =>
+        TFHelper_0123456789Sym1KindInference
+    type instance Apply (TFHelper_0123456789Sym1 l) l = TFHelper_0123456789Sym2 l l
+    instance SuppressUnusedWarnings TFHelper_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) TFHelper_0123456789Sym0KindInference GHC.Tuple.())
+    data TFHelper_0123456789Sym0 (l :: TyFun Foo2 (TyFun Foo2 Bool
+                                                   -> *))
+      = forall arg. KindOf (Apply TFHelper_0123456789Sym0 arg) ~ KindOf (TFHelper_0123456789Sym1 arg) =>
+        TFHelper_0123456789Sym0KindInference
+    type instance Apply TFHelper_0123456789Sym0 l = TFHelper_0123456789Sym1 l
+    instance PEq (KProxy :: KProxy Foo2) where
+      type (:==) (a :: Foo2) (a :: Foo2) = Apply (Apply TFHelper_0123456789Sym0 a) a
+    infix 4 %:<=>
+    sFooCompare ::
+      forall (t :: Foo) (t :: Foo).
+      Sing t
+      -> Sing t -> Sing (Apply (Apply FooCompareSym0 t) t :: Ordering)
+    sConst ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply ConstSym0 t) t :: a)
+    sFooCompare SA SA
+      = let
+          lambda ::
+            (t ~ ASym0, t ~ ASym0) =>
+            Sing (Apply (Apply FooCompareSym0 ASym0) ASym0 :: Ordering)
+          lambda = SEQ
+        in lambda
+    sFooCompare SA SB
+      = let
+          lambda ::
+            (t ~ ASym0, t ~ BSym0) =>
+            Sing (Apply (Apply FooCompareSym0 ASym0) BSym0 :: Ordering)
+          lambda = SLT
+        in lambda
+    sFooCompare SB SB
+      = let
+          lambda ::
+            (t ~ BSym0, t ~ BSym0) =>
+            Sing (Apply (Apply FooCompareSym0 BSym0) BSym0 :: Ordering)
+          lambda = SGT
+        in lambda
+    sFooCompare SB SA
+      = let
+          lambda ::
+            (t ~ BSym0, t ~ ASym0) =>
+            Sing (Apply (Apply FooCompareSym0 BSym0) ASym0 :: Ordering)
+          lambda = SEQ
+        in lambda
+    sConst sX _s_z_0123456789
+      = let
+          lambda ::
+            forall x _z_0123456789. (t ~ x, t ~ _z_0123456789) =>
+            Sing x
+            -> Sing _z_0123456789
+               -> Sing (Apply (Apply ConstSym0 x) _z_0123456789 :: a)
+          lambda x _z_0123456789 = x
+        in lambda sX _s_z_0123456789
+    data instance Sing (z :: Foo) = z ~ A => SA | z ~ B => SB
+    type SFoo = (Sing :: Foo -> *)
+    instance SingKind (KProxy :: KProxy Foo) where
+      type DemoteRep (KProxy :: KProxy Foo) = Foo
+      fromSing SA = A
+      fromSing SB = B
+      toSing A = SomeSing SA
+      toSing B = SomeSing SB
+    data instance Sing (z :: Foo2) = z ~ F => SF | z ~ G => SG
+    type SFoo2 = (Sing :: Foo2 -> *)
+    instance SingKind (KProxy :: KProxy Foo2) where
+      type DemoteRep (KProxy :: KProxy Foo2) = Foo2
+      fromSing SF = F
+      fromSing SG = G
+      toSing F = SomeSing SF
+      toSing G = SomeSing SG
+    class kproxy ~ KProxy => SMyOrd (kproxy :: KProxy a) where
+      sMycompare ::
+        forall (t :: a) (t :: a).
+        Sing t
+        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)
+      (%:<=>) ::
+        forall (t :: a) (t :: a).
+        Sing t -> Sing t -> Sing (Apply (Apply (:<=>$) t) t :: Ordering)
+      default (%:<=>) ::
+                forall (t :: a)
+                       (t :: a). Apply (Apply (:<=>$) t) t ~ Apply (Apply TFHelper_0123456789Sym0 t) t =>
+                Sing t -> Sing t -> Sing (Apply (Apply (:<=>$) t) t :: Ordering)
+      (%:<=>) sA_0123456789 sA_0123456789
+        = let
+            lambda ::
+              forall a_0123456789 a_0123456789. (t ~ a_0123456789,
+                                                 t ~ a_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing (Apply (Apply (:<=>$) a_0123456789) a_0123456789 :: Ordering)
+            lambda a_0123456789 a_0123456789
+              = applySing
+                  (applySing
+                     (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) a_0123456789)
+                  a_0123456789
+          in lambda sA_0123456789 sA_0123456789
+    instance SMyOrd (KProxy :: KProxy Nat) where
+      sMycompare ::
+        forall (t :: Nat) (t :: Nat).
+        Sing t
+        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)
+      sMycompare SZero SZero
+        = let
+            lambda ::
+              (t ~ ZeroSym0, t ~ ZeroSym0) =>
+              Sing (Apply (Apply MycompareSym0 ZeroSym0) ZeroSym0 :: Ordering)
+            lambda = SEQ
+          in lambda
+      sMycompare SZero (SSucc _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789. (t ~ ZeroSym0,
+                                     t ~ Apply SuccSym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply MycompareSym0 ZeroSym0) (Apply SuccSym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 = SLT
+          in lambda _s_z_0123456789
+      sMycompare (SSucc _s_z_0123456789) SZero
+        = let
+            lambda ::
+              forall _z_0123456789. (t ~ Apply SuccSym0 _z_0123456789,
+                                     t ~ ZeroSym0) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply MycompareSym0 (Apply SuccSym0 _z_0123456789)) ZeroSym0 :: Ordering)
+            lambda _z_0123456789 = SGT
+          in lambda _s_z_0123456789
+      sMycompare (SSucc sN) (SSucc sM)
+        = let
+            lambda ::
+              forall n m. (t ~ Apply SuccSym0 n, t ~ Apply SuccSym0 m) =>
+              Sing n
+              -> Sing m
+                 -> Sing (Apply (Apply MycompareSym0 (Apply SuccSym0 n)) (Apply SuccSym0 m) :: Ordering)
+            lambda n m
+              = applySing
+                  (applySing (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) m)
+                  n
+          in lambda sN sM
+    instance SMyOrd (KProxy :: KProxy ()) where
+      sMycompare ::
+        forall (t :: ()) (t :: ()).
+        Sing t
+        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)
+      sMycompare _s_z_0123456789 sA_0123456789
+        = let
+            lambda ::
+              forall _z_0123456789 a_0123456789. (t ~ _z_0123456789,
+                                                  t ~ a_0123456789) =>
+              Sing _z_0123456789
+              -> Sing a_0123456789
+                 -> Sing (Apply (Apply MycompareSym0 _z_0123456789) a_0123456789 :: Ordering)
+            lambda _z_0123456789 a_0123456789
+              = applySing
+                  (applySing (singFun2 (Proxy :: Proxy ConstSym0) sConst) SEQ)
+                  a_0123456789
+          in lambda _s_z_0123456789 sA_0123456789
+    instance SMyOrd (KProxy :: KProxy Foo) where
+      sMycompare ::
+        forall (t :: Foo) (t :: Foo).
+        Sing t
+        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)
+      sMycompare sA_0123456789 sA_0123456789
+        = let
+            lambda ::
+              forall a_0123456789 a_0123456789. (t ~ a_0123456789,
+                                                 t ~ a_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing (Apply (Apply MycompareSym0 a_0123456789) a_0123456789 :: Ordering)
+            lambda a_0123456789 a_0123456789
+              = applySing
+                  (applySing
+                     (singFun2 (Proxy :: Proxy FooCompareSym0) sFooCompare)
+                     a_0123456789)
+                  a_0123456789
+          in lambda sA_0123456789 sA_0123456789
+    instance SEq (KProxy :: KProxy Foo2) where
+      (%:==) ::
+        forall (a :: Foo2) (b :: Foo2).
+        Sing a -> Sing b -> Sing ((:==) a b)
+      (%:==) SF SF
+        = let
+            lambda ::
+              (a ~ FSym0, b ~ FSym0) => Sing (Apply (Apply (:==$) FSym0) FSym0)
+            lambda = STrue
+          in lambda
+      (%:==) SG SG
+        = let
+            lambda ::
+              (a ~ GSym0, b ~ GSym0) => Sing (Apply (Apply (:==$) GSym0) GSym0)
+            lambda = STrue
+          in lambda
+      (%:==) SF SG
+        = let
+            lambda ::
+              (a ~ FSym0, b ~ GSym0) => Sing (Apply (Apply (:==$) FSym0) GSym0)
+            lambda = SFalse
+          in lambda
+      (%:==) SG SF
+        = let
+            lambda ::
+              (a ~ GSym0, b ~ FSym0) => Sing (Apply (Apply (:==$) GSym0) FSym0)
+            lambda = SFalse
+          in lambda
+    instance SingI A where
+      sing = SA
+    instance SingI B where
+      sing = SB
+    instance SingI F where
+      sing = SF
+    instance SingI G where
+      sing = SG
+Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations
+    promote
+      [d| instance Ord Foo2 where
+            F `compare` F = EQ
+            F `compare` _ = LT
+            _ `compare` _ = GT
+          instance MyOrd Foo2 where
+            F `mycompare` F = EQ
+            F `mycompare` _ = LT
+            _ `mycompare` _ = GT |]
+  ======>
+    instance MyOrd Foo2 where
+      mycompare F F = EQ
+      mycompare F _ = LT
+      mycompare _ _ = GT
+    instance Ord Foo2 where
+      compare F F = EQ
+      compare F _ = LT
+      compare _ _ = GT
+    type family Mycompare_0123456789 (a :: Foo2)
+                                     (a :: Foo2) :: Ordering where
+      Mycompare_0123456789 F F = EQSym0
+      Mycompare_0123456789 F _z_0123456789 = LTSym0
+      Mycompare_0123456789 _z_0123456789 _z_0123456789 = GTSym0
+    type Mycompare_0123456789Sym2 (t :: Foo2) (t :: Foo2) =
+        Mycompare_0123456789 t t
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym1 (l :: Foo2)
+                                  (l :: TyFun Foo2 Ordering)
+      = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) =>
+        Mycompare_0123456789Sym1KindInference
+    type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym0 (l :: TyFun Foo2 (TyFun Foo2 Ordering
+                                                    -> *))
+      = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) =>
+        Mycompare_0123456789Sym0KindInference
+    type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l
+    instance PMyOrd (KProxy :: KProxy Foo2) where
+      type Mycompare (a :: Foo2) (a :: Foo2) = Apply (Apply Mycompare_0123456789Sym0 a) a
+    type family Compare_0123456789 (a :: Foo2)
+                                   (a :: Foo2) :: Ordering where
+      Compare_0123456789 F F = EQSym0
+      Compare_0123456789 F _z_0123456789 = LTSym0
+      Compare_0123456789 _z_0123456789 _z_0123456789 = GTSym0
+    type Compare_0123456789Sym2 (t :: Foo2) (t :: Foo2) =
+        Compare_0123456789 t t
+    instance SuppressUnusedWarnings Compare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.())
+    data Compare_0123456789Sym1 (l :: Foo2) (l :: TyFun Foo2 Ordering)
+      = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) =>
+        Compare_0123456789Sym1KindInference
+    type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Compare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.())
+    data Compare_0123456789Sym0 (l :: TyFun Foo2 (TyFun Foo2 Ordering
+                                                  -> *))
+      = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) =>
+        Compare_0123456789Sym0KindInference
+    type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l
+    instance POrd (KProxy :: KProxy Foo2) where
+      type Compare (a :: Foo2) (a :: Foo2) = Apply (Apply Compare_0123456789Sym0 a) a
+Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data Nat' = Zero' | Succ' Nat'
+          
+          instance MyOrd Nat' where
+            Zero' `mycompare` Zero' = EQ
+            Zero' `mycompare` (Succ' _) = LT
+            (Succ' _) `mycompare` Zero' = GT
+            (Succ' n) `mycompare` (Succ' m) = m `mycompare` n |]
+  ======>
+    data Nat' = Zero' | Succ' Nat'
+    instance MyOrd Nat' where
+      mycompare Zero' Zero' = EQ
+      mycompare Zero' (Succ' _) = LT
+      mycompare (Succ' _) Zero' = GT
+      mycompare (Succ' n) (Succ' m) = (m `mycompare` n)
+    type Zero'Sym0 = Zero'
+    type Succ'Sym1 (t :: Nat') = Succ' t
+    instance SuppressUnusedWarnings Succ'Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Succ'Sym0KindInference GHC.Tuple.())
+    data Succ'Sym0 (l :: TyFun Nat' Nat')
+      = forall arg. KindOf (Apply Succ'Sym0 arg) ~ KindOf (Succ'Sym1 arg) =>
+        Succ'Sym0KindInference
+    type instance Apply Succ'Sym0 l = Succ'Sym1 l
+    type family Mycompare_0123456789 (a :: Nat')
+                                     (a :: Nat') :: Ordering where
+      Mycompare_0123456789 Zero' Zero' = EQSym0
+      Mycompare_0123456789 Zero' (Succ' _z_0123456789) = LTSym0
+      Mycompare_0123456789 (Succ' _z_0123456789) Zero' = GTSym0
+      Mycompare_0123456789 (Succ' n) (Succ' m) = Apply (Apply MycompareSym0 m) n
+    type Mycompare_0123456789Sym2 (t :: Nat') (t :: Nat') =
+        Mycompare_0123456789 t t
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym1 (l :: Nat')
+                                  (l :: TyFun Nat' Ordering)
+      = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) =>
+        Mycompare_0123456789Sym1KindInference
+    type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym0 (l :: TyFun Nat' (TyFun Nat' Ordering
+                                                    -> *))
+      = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) =>
+        Mycompare_0123456789Sym0KindInference
+    type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l
+    instance PMyOrd (KProxy :: KProxy Nat') where
+      type Mycompare (a :: Nat') (a :: Nat') = Apply (Apply Mycompare_0123456789Sym0 a) a
+    data instance Sing (z :: Nat')
+      = z ~ Zero' => SZero' |
+        forall (n :: Nat'). z ~ Succ' n => SSucc' (Sing (n :: Nat'))
+    type SNat' = (Sing :: Nat' -> *)
+    instance SingKind (KProxy :: KProxy Nat') where
+      type DemoteRep (KProxy :: KProxy Nat') = Nat'
+      fromSing SZero' = Zero'
+      fromSing (SSucc' b) = Succ' (fromSing b)
+      toSing Zero' = SomeSing SZero'
+      toSing (Succ' b)
+        = case toSing b :: SomeSing (KProxy :: KProxy Nat') of {
+            SomeSing c -> SomeSing (SSucc' c) }
+    instance SMyOrd (KProxy :: KProxy Nat') where
+      sMycompare ::
+        forall (t :: Nat') (t :: Nat').
+        Sing t
+        -> Sing t
+           -> Sing (Apply (Apply (MycompareSym0 :: TyFun Nat' (TyFun Nat' Ordering
+                                                               -> *)
+                                                   -> *) t :: TyFun Nat' Ordering
+                                                              -> *) t :: Ordering)
+      sMycompare SZero' SZero'
+        = let
+            lambda ::
+              (t ~ Zero'Sym0, t ~ Zero'Sym0) =>
+              Sing (Apply (Apply MycompareSym0 Zero'Sym0) Zero'Sym0 :: Ordering)
+            lambda = SEQ
+          in lambda
+      sMycompare SZero' (SSucc' _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789. (t ~ Zero'Sym0,
+                                     t ~ Apply Succ'Sym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply MycompareSym0 Zero'Sym0) (Apply Succ'Sym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 = SLT
+          in lambda _s_z_0123456789
+      sMycompare (SSucc' _s_z_0123456789) SZero'
+        = let
+            lambda ::
+              forall _z_0123456789. (t ~ Apply Succ'Sym0 _z_0123456789,
+                                     t ~ Zero'Sym0) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply MycompareSym0 (Apply Succ'Sym0 _z_0123456789)) Zero'Sym0 :: Ordering)
+            lambda _z_0123456789 = SGT
+          in lambda _s_z_0123456789
+      sMycompare (SSucc' sN) (SSucc' sM)
+        = let
+            lambda ::
+              forall n m. (t ~ Apply Succ'Sym0 n, t ~ Apply Succ'Sym0 m) =>
+              Sing n
+              -> Sing m
+                 -> Sing (Apply (Apply MycompareSym0 (Apply Succ'Sym0 n)) (Apply Succ'Sym0 m) :: Ordering)
+            lambda n m
+              = applySing
+                  (applySing (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) m)
+                  n
+          in lambda sN sM
+    instance SingI Zero' where
+      sing = SZero'
+    instance SingI n => SingI (Succ' (n :: Nat')) where
+      sing = SSucc' sing
diff --git a/tests/compile-and-dump/Singletons/Classes.hs b/tests/compile-and-dump/Singletons/Classes.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Classes.hs
@@ -0,0 +1,98 @@
+module Singletons.Classes where
+
+import Prelude hiding (const)
+import Singletons.Nat
+import Data.Singletons
+import Data.Singletons.TH
+import Language.Haskell.TH.Desugar
+import Data.Singletons.Prelude.Ord
+import Data.Singletons.Prelude.Eq
+
+$(singletons [d|
+  const :: a -> b -> a
+  const x _ = x
+
+  class MyOrd a where
+    mycompare :: a -> a -> Ordering
+    (<=>) :: a -> a -> Ordering
+    (<=>) = mycompare
+    infix 4 <=>
+
+  instance MyOrd Nat where
+    Zero `mycompare` Zero = EQ
+    Zero `mycompare` (Succ _) = LT
+    (Succ _) `mycompare` Zero = GT
+    (Succ n) `mycompare` (Succ m) = m `mycompare` n
+
+    -- test eta-expansion
+  instance MyOrd () where
+    mycompare _ = const EQ
+
+  data Foo = A | B
+
+  fooCompare :: Foo -> Foo -> Ordering
+  fooCompare A A = EQ
+  fooCompare A B = LT
+  fooCompare B B = GT
+  fooCompare B A = EQ
+
+  instance MyOrd Foo where
+    -- test that values in instance definitions are eta-expanded
+    mycompare = fooCompare
+
+  data Foo2 = F | G
+
+  instance Eq Foo2 where
+    F == F = True
+    G == G = True
+    F == G = False
+    G == F = False
+ |])
+
+$(promote [d|
+  -- instance with overlaping equations. Tests #56
+  instance MyOrd Foo2 where
+      F `mycompare` F = EQ
+      F `mycompare` _ = LT
+      _ `mycompare` _ = GT
+
+  instance Ord Foo2 where
+    F `compare` F = EQ
+    F `compare` _ = LT
+    _ `compare` _ = GT
+
+  |])
+
+-- check promotion across different splices (#55)
+$(singletons [d|
+  data Nat' = Zero' | Succ' Nat'
+  instance MyOrd Nat' where
+    Zero' `mycompare` Zero' = EQ
+    Zero' `mycompare` (Succ' _) = LT
+    (Succ' _) `mycompare` Zero' = GT
+    (Succ' n) `mycompare` (Succ' m) = m `mycompare` n
+ |])
+
+foo1a :: Proxy (Zero `Mycompare` (Succ Zero))
+foo1a = Proxy
+
+foo1b :: Proxy LT
+foo1b = foo1a
+
+foo2a :: Proxy (A `Mycompare` A)
+foo2a = Proxy
+
+foo2b :: Proxy EQ
+foo2b = foo2a
+
+foo3a :: Proxy ('() `Mycompare` '())
+foo3a = Proxy
+
+foo3b :: Proxy EQ
+foo3b = foo3a
+
+foo4a :: Proxy (Succ' Zero' :<=> Zero')
+foo4a = Proxy
+
+foo4b :: Proxy GT
+foo4b = foo4a
diff --git a/tests/compile-and-dump/Singletons/Classes2.ghc710.template b/tests/compile-and-dump/Singletons/Classes2.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Classes2.ghc710.template
@@ -0,0 +1,116 @@
+Singletons/Classes2.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data NatFoo = ZeroFoo | SuccFoo NatFoo
+          
+          instance MyOrd NatFoo where
+            ZeroFoo `mycompare` ZeroFoo = EQ
+            ZeroFoo `mycompare` (SuccFoo _) = LT
+            (SuccFoo _) `mycompare` ZeroFoo = GT
+            (SuccFoo n) `mycompare` (SuccFoo m) = m `mycompare` n |]
+  ======>
+    data NatFoo = ZeroFoo | SuccFoo NatFoo
+    instance MyOrd NatFoo where
+      mycompare ZeroFoo ZeroFoo = EQ
+      mycompare ZeroFoo (SuccFoo _) = LT
+      mycompare (SuccFoo _) ZeroFoo = GT
+      mycompare (SuccFoo n) (SuccFoo m) = (m `mycompare` n)
+    type ZeroFooSym0 = ZeroFoo
+    type SuccFooSym1 (t :: NatFoo) = SuccFoo t
+    instance SuppressUnusedWarnings SuccFooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SuccFooSym0KindInference GHC.Tuple.())
+    data SuccFooSym0 (l :: TyFun NatFoo NatFoo)
+      = forall arg. KindOf (Apply SuccFooSym0 arg) ~ KindOf (SuccFooSym1 arg) =>
+        SuccFooSym0KindInference
+    type instance Apply SuccFooSym0 l = SuccFooSym1 l
+    type family Mycompare_0123456789 (a :: NatFoo)
+                                     (a :: NatFoo) :: Ordering where
+      Mycompare_0123456789 ZeroFoo ZeroFoo = EQSym0
+      Mycompare_0123456789 ZeroFoo (SuccFoo _z_0123456789) = LTSym0
+      Mycompare_0123456789 (SuccFoo _z_0123456789) ZeroFoo = GTSym0
+      Mycompare_0123456789 (SuccFoo n) (SuccFoo m) = Apply (Apply MycompareSym0 m) n
+    type Mycompare_0123456789Sym2 (t :: NatFoo) (t :: NatFoo) =
+        Mycompare_0123456789 t t
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym1 (l :: NatFoo)
+                                  (l :: TyFun NatFoo Ordering)
+      = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) =>
+        Mycompare_0123456789Sym1KindInference
+    type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.())
+    data Mycompare_0123456789Sym0 (l :: TyFun NatFoo (TyFun NatFoo Ordering
+                                                      -> *))
+      = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) =>
+        Mycompare_0123456789Sym0KindInference
+    type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l
+    instance PMyOrd (KProxy :: KProxy NatFoo) where
+      type Mycompare (a :: NatFoo) (a :: NatFoo) = Apply (Apply Mycompare_0123456789Sym0 a) a
+    data instance Sing (z :: NatFoo)
+      = z ~ ZeroFoo => SZeroFoo |
+        forall (n :: NatFoo). z ~ SuccFoo n =>
+        SSuccFoo (Sing (n :: NatFoo))
+    type SNatFoo = (Sing :: NatFoo -> *)
+    instance SingKind (KProxy :: KProxy NatFoo) where
+      type DemoteRep (KProxy :: KProxy NatFoo) = NatFoo
+      fromSing SZeroFoo = ZeroFoo
+      fromSing (SSuccFoo b) = SuccFoo (fromSing b)
+      toSing ZeroFoo = SomeSing SZeroFoo
+      toSing (SuccFoo b)
+        = case toSing b :: SomeSing (KProxy :: KProxy NatFoo) of {
+            SomeSing c -> SomeSing (SSuccFoo c) }
+    instance SMyOrd (KProxy :: KProxy NatFoo) where
+      sMycompare ::
+        forall (t0 :: NatFoo) (t1 :: NatFoo).
+        Sing t0
+        -> Sing t1
+           -> Sing (Apply (Apply (MycompareSym0 :: TyFun NatFoo (TyFun NatFoo Ordering
+                                                                 -> *)
+                                                   -> *) t0 :: TyFun NatFoo Ordering
+                                                               -> *) t1 :: Ordering)
+      sMycompare SZeroFoo SZeroFoo
+        = let
+            lambda ::
+              (t0 ~ ZeroFooSym0, t1 ~ ZeroFooSym0) =>
+              Sing (Apply (Apply MycompareSym0 ZeroFooSym0) ZeroFooSym0 :: Ordering)
+            lambda = SEQ
+          in lambda
+      sMycompare SZeroFoo (SSuccFoo _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ ZeroFooSym0,
+                                     t1 ~ Apply SuccFooSym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply MycompareSym0 ZeroFooSym0) (Apply SuccFooSym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 = SLT
+          in lambda _s_z_0123456789
+      sMycompare (SSuccFoo _s_z_0123456789) SZeroFoo
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ Apply SuccFooSym0 _z_0123456789,
+                                     t1 ~ ZeroFooSym0) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply MycompareSym0 (Apply SuccFooSym0 _z_0123456789)) ZeroFooSym0 :: Ordering)
+            lambda _z_0123456789 = SGT
+          in lambda _s_z_0123456789
+      sMycompare (SSuccFoo sN) (SSuccFoo sM)
+        = let
+            lambda ::
+              forall n m. (t0 ~ Apply SuccFooSym0 n, t1 ~ Apply SuccFooSym0 m) =>
+              Sing n
+              -> Sing m
+                 -> Sing (Apply (Apply MycompareSym0 (Apply SuccFooSym0 n)) (Apply SuccFooSym0 m) :: Ordering)
+            lambda n m
+              = applySing
+                  (applySing (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) m)
+                  n
+          in lambda sN sM
+    instance SingI ZeroFoo where
+      sing = SZeroFoo
+    instance SingI n => SingI (SuccFoo (n :: NatFoo)) where
+      sing = SSuccFoo sing
diff --git a/tests/compile-and-dump/Singletons/Classes2.hs b/tests/compile-and-dump/Singletons/Classes2.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Classes2.hs
@@ -0,0 +1,22 @@
+module Singletons.Classes2 where
+
+import Prelude hiding (const)
+import Singletons.Nat
+import Singletons.Classes
+import Data.Singletons
+import Data.Singletons.TH
+import Data.Singletons.Prelude.Ord (EQSym0, LTSym0, GTSym0, Sing(..))
+import Language.Haskell.TH.Desugar
+
+
+$(singletons [d|
+  -- tests promotion of class instances when the class was declared
+  -- in a different source file than the instance.
+  data NatFoo = ZeroFoo | SuccFoo NatFoo
+
+  instance MyOrd NatFoo where
+    ZeroFoo `mycompare` ZeroFoo = EQ
+    ZeroFoo `mycompare` (SuccFoo _) = LT
+    (SuccFoo _) `mycompare` ZeroFoo = GT
+    (SuccFoo n) `mycompare` (SuccFoo m) = m `mycompare` n
+ |])
diff --git a/tests/compile-and-dump/Singletons/Contains.ghc710.template b/tests/compile-and-dump/Singletons/Contains.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Contains.ghc710.template
@@ -0,0 +1,56 @@
+Singletons/Contains.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| contains :: Eq a => a -> [a] -> Bool
+          contains _ [] = False
+          contains elt (h : t) = (elt == h) || (contains elt t) |]
+  ======>
+    contains :: forall a. Eq a => a -> [a] -> Bool
+    contains _ GHC.Types.[] = False
+    contains elt (h GHC.Types.: t) = ((elt == h) || (contains elt t))
+    type ContainsSym2 (t :: a) (t :: [a]) = Contains t t
+    instance SuppressUnusedWarnings ContainsSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ContainsSym1KindInference GHC.Tuple.())
+    data ContainsSym1 (l :: a) (l :: TyFun [a] Bool)
+      = forall arg. KindOf (Apply (ContainsSym1 l) arg) ~ KindOf (ContainsSym2 l arg) =>
+        ContainsSym1KindInference
+    type instance Apply (ContainsSym1 l) l = ContainsSym2 l l
+    instance SuppressUnusedWarnings ContainsSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ContainsSym0KindInference GHC.Tuple.())
+    data ContainsSym0 (l :: TyFun a (TyFun [a] Bool -> *))
+      = forall arg. KindOf (Apply ContainsSym0 arg) ~ KindOf (ContainsSym1 arg) =>
+        ContainsSym0KindInference
+    type instance Apply ContainsSym0 l = ContainsSym1 l
+    type family Contains (a :: a) (a :: [a]) :: Bool where
+      Contains _z_0123456789 '[] = FalseSym0
+      Contains elt ((:) h t) = Apply (Apply (:||$) (Apply (Apply (:==$) elt) h)) (Apply (Apply ContainsSym0 elt) t)
+    sContains ::
+      forall (t :: a) (t :: [a]). SEq (KProxy :: KProxy a) =>
+      Sing t -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool)
+    sContains _s_z_0123456789 SNil
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ _z_0123456789, t ~ '[]) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply ContainsSym0 _z_0123456789) '[] :: Bool)
+          lambda _z_0123456789 = SFalse
+        in lambda _s_z_0123456789
+    sContains sElt (SCons sH sT)
+      = let
+          lambda ::
+            forall elt h t. (t ~ elt, t ~ Apply (Apply (:$) h) t) =>
+            Sing elt
+            -> Sing h
+               -> Sing t
+                  -> Sing (Apply (Apply ContainsSym0 elt) (Apply (Apply (:$) h) t) :: Bool)
+          lambda elt h t
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:||$)) (%:||))
+                   (applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) elt) h))
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy ContainsSym0) sContains) elt)
+                   t)
+        in lambda sElt sH sT
diff --git a/tests/compile-and-dump/Singletons/Contains.ghc78.template b/tests/compile-and-dump/Singletons/Contains.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Contains.ghc78.template
+++ /dev/null
@@ -1,56 +0,0 @@
-Singletons/Contains.hs:0:0: Splicing declarations
-    singletons
-      [d| contains :: Eq a => a -> [a] -> Bool
-          contains _ [] = False
-          contains elt (h : t) = (elt == h) || (contains elt t) |]
-  ======>
-    Singletons/Contains.hs:(0,0)-(0,0)
-    contains :: forall a. Eq a => a -> [a] -> Bool
-    contains _ GHC.Types.[] = False
-    contains elt (h GHC.Types.: t) = ((elt == h) || (contains elt t))
-    type ContainsSym2 (t :: a) (t :: [a]) = Contains t t
-    instance SuppressUnusedWarnings ContainsSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ContainsSym1KindInference GHC.Tuple.())
-    data ContainsSym1 (l :: a) (l :: TyFun [a] Bool)
-      = forall arg. KindOf (Apply (ContainsSym1 l) arg) ~ KindOf (ContainsSym2 l arg) =>
-        ContainsSym1KindInference
-    type instance Apply (ContainsSym1 l) l = ContainsSym2 l l
-    instance SuppressUnusedWarnings ContainsSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ContainsSym0KindInference GHC.Tuple.())
-    data ContainsSym0 (l :: TyFun a (TyFun [a] Bool -> *))
-      = forall arg. KindOf (Apply ContainsSym0 arg) ~ KindOf (ContainsSym1 arg) =>
-        ContainsSym0KindInference
-    type instance Apply ContainsSym0 l = ContainsSym1 l
-    type family Contains (a :: a) (a :: [a]) :: Bool where
-      Contains z '[] = FalseSym0
-      Contains elt ((:) h t) = Apply (Apply (:||$) (Apply (Apply (:==$) elt) h)) (Apply (Apply ContainsSym0 elt) t)
-    sContains ::
-      forall (t :: a) (t :: [a]). SEq (KProxy :: KProxy a) =>
-      Sing t -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t)
-    sContains _ SNil
-      = let
-          lambda ::
-            forall wild. (t ~ wild, t ~ '[]) =>
-            Sing (Apply (Apply ContainsSym0 wild) '[])
-          lambda = SFalse
-        in lambda
-    sContains sElt (SCons sH sT)
-      = let
-          lambda ::
-            forall elt h t. (t ~ elt, t ~ Apply (Apply (:$) h) t) =>
-            Sing elt
-            -> Sing h
-               -> Sing t
-                  -> Sing (Apply (Apply ContainsSym0 elt) (Apply (Apply (:$) h) t))
-          lambda elt h t
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:||$)) (%:||))
-                   (applySing
-                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) elt) h))
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy ContainsSym0) sContains) elt)
-                   t)
-        in lambda sElt sH sT
diff --git a/tests/compile-and-dump/Singletons/DataValues.ghc710.template b/tests/compile-and-dump/Singletons/DataValues.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/DataValues.ghc710.template
@@ -0,0 +1,104 @@
+Singletons/DataValues.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| pr = Pair (Succ Zero) ([Zero])
+          complex = Pair (Pair (Just Zero) Zero) False
+          tuple = (False, Just Zero, True)
+          aList = [Zero, Succ Zero, Succ (Succ Zero)]
+          
+          data Pair a b
+            = Pair a b
+            deriving (Show) |]
+  ======>
+    data Pair a b
+      = Pair a b
+      deriving (Show)
+    pr = Pair (Succ Zero) [Zero]
+    complex = Pair (Pair (Just Zero) Zero) False
+    tuple = (False, Just Zero, True)
+    aList = [Zero, Succ Zero, Succ (Succ Zero)]
+    type PairSym2 (t :: a) (t :: b) = Pair t t
+    instance SuppressUnusedWarnings PairSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
+    data PairSym1 (l :: a) (l :: TyFun b (Pair a b))
+      = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) =>
+        PairSym1KindInference
+    type instance Apply (PairSym1 l) l = PairSym2 l l
+    instance SuppressUnusedWarnings PairSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
+    data PairSym0 (l :: TyFun a (TyFun b (Pair a b) -> *))
+      = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) =>
+        PairSym0KindInference
+    type instance Apply PairSym0 l = PairSym1 l
+    type AListSym0 = AList
+    type TupleSym0 = Tuple
+    type ComplexSym0 = Complex
+    type PrSym0 = Pr
+    type family AList where
+      AList = Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[]))
+    type family Tuple where
+      Tuple = Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0
+    type family Complex where
+      Complex = Apply (Apply PairSym0 (Apply (Apply PairSym0 (Apply JustSym0 ZeroSym0)) ZeroSym0)) FalseSym0
+    type family Pr where
+      Pr = Apply (Apply PairSym0 (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) ZeroSym0) '[])
+    sAList :: Sing AListSym0
+    sTuple :: Sing TupleSym0
+    sComplex :: Sing ComplexSym0
+    sPr :: Sing PrSym0
+    sAList
+      = applySing
+          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
+          (applySing
+             (applySing
+                (singFun2 (Proxy :: Proxy (:$)) SCons)
+                (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing
+                      (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
+                SNil))
+    sTuple
+      = applySing
+          (applySing
+             (applySing (singFun3 (Proxy :: Proxy Tuple3Sym0) STuple3) SFalse)
+             (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero))
+          STrue
+    sComplex
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy PairSym0) SPair)
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy PairSym0) SPair)
+                   (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero))
+                SZero))
+          SFalse
+    sPr
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy PairSym0) SPair)
+             (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) SNil)
+    data instance Sing (z :: Pair a b)
+      = forall (n :: a) (n :: b). z ~ Pair n n =>
+        SPair (Sing (n :: a)) (Sing (n :: b))
+    type SPair = (Sing :: Pair a b -> *)
+    instance (SingKind (KProxy :: KProxy a),
+              SingKind (KProxy :: KProxy b)) =>
+             SingKind (KProxy :: KProxy (Pair a b)) where
+      type DemoteRep (KProxy :: KProxy (Pair a b)) = Pair (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
+      fromSing (SPair b b) = Pair (fromSing b) (fromSing b)
+      toSing (Pair b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) }
+    instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where
+      sing = SPair sing sing
diff --git a/tests/compile-and-dump/Singletons/DataValues.ghc78.template b/tests/compile-and-dump/Singletons/DataValues.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/DataValues.ghc78.template
+++ /dev/null
@@ -1,104 +0,0 @@
-Singletons/DataValues.hs:0:0: Splicing declarations
-    singletons
-      [d| pr = Pair (Succ Zero) ([Zero])
-          complex = Pair (Pair (Just Zero) Zero) False
-          tuple = (False, Just Zero, True)
-          aList = [Zero, Succ Zero, Succ (Succ Zero)]
-          
-          data Pair a b
-            = Pair a b
-            deriving (Show) |]
-  ======>
-    Singletons/DataValues.hs:(0,0)-(0,0)
-    data Pair a b
-      = Pair a b
-      deriving (Show)
-    pr = Pair (Succ Zero) [Zero]
-    complex = Pair (Pair (Just Zero) Zero) False
-    tuple = (False, Just Zero, True)
-    aList = [Zero, Succ Zero, Succ (Succ Zero)]
-    type PairSym2 (t :: a) (t :: b) = Pair t t
-    instance SuppressUnusedWarnings PairSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
-    data PairSym1 (l :: a) (l :: TyFun b (Pair a b))
-      = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) =>
-        PairSym1KindInference
-    type instance Apply (PairSym1 l) l = PairSym2 l l
-    instance SuppressUnusedWarnings PairSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
-    data PairSym0 (l :: TyFun a (TyFun b (Pair a b) -> *))
-      = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) =>
-        PairSym0KindInference
-    type instance Apply PairSym0 l = PairSym1 l
-    type AListSym0 = AList
-    type TupleSym0 = Tuple
-    type ComplexSym0 = Complex
-    type PrSym0 = Pr
-    type AList =
-        Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[]))
-    type Tuple =
-        Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0
-    type Complex =
-        Apply (Apply PairSym0 (Apply (Apply PairSym0 (Apply JustSym0 ZeroSym0)) ZeroSym0)) FalseSym0
-    type Pr =
-        Apply (Apply PairSym0 (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) ZeroSym0) '[])
-    sAList :: Sing AListSym0
-    sTuple :: Sing TupleSym0
-    sComplex :: Sing ComplexSym0
-    sPr :: Sing PrSym0
-    sAList
-      = applySing
-          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
-          (applySing
-             (applySing
-                (singFun2 (Proxy :: Proxy (:$)) SCons)
-                (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing
-                      (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
-                SNil))
-    sTuple
-      = applySing
-          (applySing
-             (applySing (singFun3 (Proxy :: Proxy Tuple3Sym0) STuple3) SFalse)
-             (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero))
-          STrue
-    sComplex
-      = applySing
-          (applySing
-             (singFun2 (Proxy :: Proxy PairSym0) SPair)
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy PairSym0) SPair)
-                   (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero))
-                SZero))
-          SFalse
-    sPr
-      = applySing
-          (applySing
-             (singFun2 (Proxy :: Proxy PairSym0) SPair)
-             (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) SNil)
-    data instance Sing (z :: Pair a b)
-      = forall (n :: a) (n :: b). z ~ Pair n n => SPair (Sing n) (Sing n)
-    type SPair (z :: Pair a b) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b)) =>
-             SingKind (KProxy :: KProxy (Pair a b)) where
-      type DemoteRep (KProxy :: KProxy (Pair a b)) = Pair (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
-      fromSing (SPair b b) = Pair (fromSing b) (fromSing b)
-      toSing (Pair b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) }
-    instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where
-      sing = SPair sing sing
diff --git a/tests/compile-and-dump/Singletons/Empty.ghc710.template b/tests/compile-and-dump/Singletons/Empty.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Empty.ghc710.template
@@ -0,0 +1,14 @@
+Singletons/Empty.hs:(0,0)-(0,0): Splicing declarations
+    singletons [d| data Empty |]
+  ======>
+    data Empty
+    data instance Sing (z :: Empty)
+    type SEmpty = (Sing :: Empty -> *)
+    instance SingKind (KProxy :: KProxy Empty) where
+      type DemoteRep (KProxy :: KProxy Empty) = Empty
+      fromSing z
+        = case z of {
+            _ -> error "Empty case reached -- this should be impossible" }
+      toSing z
+        = case z of {
+            _ -> error "Empty case reached -- this should be impossible" }
diff --git a/tests/compile-and-dump/Singletons/Empty.ghc78.template b/tests/compile-and-dump/Singletons/Empty.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Empty.ghc78.template
+++ /dev/null
@@ -1,15 +0,0 @@
-Singletons/Empty.hs:0:0: Splicing declarations
-    singletons [d| data Empty |]
-  ======>
-    Singletons/Empty.hs:(0,0)-(0,0)
-    data Empty
-    data instance Sing (z :: Empty)
-    type SEmpty (z :: Empty) = Sing z
-    instance SingKind (KProxy :: KProxy Empty) where
-      type DemoteRep (KProxy :: KProxy Empty) = Empty
-      fromSing z
-        = case z of {
-            _ -> error "Empty case reached -- this should be impossible" }
-      toSing z
-        = case z of {
-            _ -> error "Empty case reached -- this should be impossible" }
diff --git a/tests/compile-and-dump/Singletons/EnumDeriving.ghc710.template b/tests/compile-and-dump/Singletons/EnumDeriving.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/EnumDeriving.ghc710.template
@@ -0,0 +1,287 @@
+Singletons/EnumDeriving.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data Foo
+            = Bar | Baz | Bum
+            deriving (Enum)
+          data Quux = Q1 | Q2 |]
+  ======>
+    data Foo
+      = Bar | Baz | Bum
+      deriving (Enum)
+    data Quux = Q1 | Q2
+    type BarSym0 = Bar
+    type BazSym0 = Baz
+    type BumSym0 = Bum
+    type Q1Sym0 = Q1
+    type Q2Sym0 = Q2
+    type family Case_0123456789 n t where
+      Case_0123456789 n True = BumSym0
+      Case_0123456789 n False = Apply ErrorSym0 "toEnum: bad argument"
+    type family Case_0123456789 n t where
+      Case_0123456789 n True = BazSym0
+      Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 2))
+    type family Case_0123456789 n t where
+      Case_0123456789 n True = BarSym0
+      Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1))
+    type family ToEnum_0123456789 (a :: GHC.TypeLits.Nat) :: Foo where
+      ToEnum_0123456789 n = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0))
+    type ToEnum_0123456789Sym1 (t :: GHC.TypeLits.Nat) =
+        ToEnum_0123456789 t
+    instance SuppressUnusedWarnings ToEnum_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) ToEnum_0123456789Sym0KindInference GHC.Tuple.())
+    data ToEnum_0123456789Sym0 (l :: TyFun GHC.TypeLits.Nat Foo)
+      = forall arg. KindOf (Apply ToEnum_0123456789Sym0 arg) ~ KindOf (ToEnum_0123456789Sym1 arg) =>
+        ToEnum_0123456789Sym0KindInference
+    type instance Apply ToEnum_0123456789Sym0 l = ToEnum_0123456789Sym1 l
+    type family FromEnum_0123456789 (a :: Foo) :: GHC.TypeLits.Nat where
+      FromEnum_0123456789 Bar = FromInteger 0
+      FromEnum_0123456789 Baz = FromInteger 1
+      FromEnum_0123456789 Bum = FromInteger 2
+    type FromEnum_0123456789Sym1 (t :: Foo) = FromEnum_0123456789 t
+    instance SuppressUnusedWarnings FromEnum_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) FromEnum_0123456789Sym0KindInference GHC.Tuple.())
+    data FromEnum_0123456789Sym0 (l :: TyFun Foo GHC.TypeLits.Nat)
+      = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) =>
+        FromEnum_0123456789Sym0KindInference
+    type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l
+    instance PEnum (KProxy :: KProxy Foo) where
+      type ToEnum (a :: GHC.TypeLits.Nat) = Apply ToEnum_0123456789Sym0 a
+      type FromEnum (a :: Foo) = Apply FromEnum_0123456789Sym0 a
+    data instance Sing (z :: Foo)
+      = z ~ Bar => SBar | z ~ Baz => SBaz | z ~ Bum => SBum
+    type SFoo = (Sing :: Foo -> *)
+    instance SingKind (KProxy :: KProxy Foo) where
+      type DemoteRep (KProxy :: KProxy Foo) = Foo
+      fromSing SBar = Bar
+      fromSing SBaz = Baz
+      fromSing SBum = Bum
+      toSing Bar = SomeSing SBar
+      toSing Baz = SomeSing SBaz
+      toSing Bum = SomeSing SBum
+    data instance Sing (z :: Quux) = z ~ Q1 => SQ1 | z ~ Q2 => SQ2
+    type SQuux = (Sing :: Quux -> *)
+    instance SingKind (KProxy :: KProxy Quux) where
+      type DemoteRep (KProxy :: KProxy Quux) = Quux
+      fromSing SQ1 = Q1
+      fromSing SQ2 = Q2
+      toSing Q1 = SomeSing SQ1
+      toSing Q2 = SomeSing SQ2
+    instance SEnum (KProxy :: KProxy Foo) where
+      sToEnum ::
+        forall (t0 :: GHC.TypeLits.Nat).
+        Sing t0
+        -> Sing (Apply (ToEnumSym0 :: TyFun GHC.TypeLits.Nat Foo
+                                      -> *) t0 :: Foo)
+      sFromEnum ::
+        forall (t0 :: Foo).
+        Sing t0
+        -> Sing (Apply (FromEnumSym0 :: TyFun Foo GHC.TypeLits.Nat
+                                        -> *) t0 :: GHC.TypeLits.Nat)
+      sToEnum sN
+        = let
+            lambda ::
+              forall n. t0 ~ n => Sing n -> Sing (Apply ToEnumSym0 n :: Foo)
+            lambda n
+              = case
+                    applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
+                      (sFromInteger (sing :: Sing 0))
+                of {
+                  STrue
+                    -> let
+                         lambda ::
+                           TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) =>
+                           Sing (Case_0123456789 n TrueSym0)
+                         lambda = SBar
+                       in lambda
+                  SFalse
+                    -> let
+                         lambda ::
+                           FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) =>
+                           Sing (Case_0123456789 n FalseSym0)
+                         lambda
+                           = case
+                                 applySing
+                                   (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
+                                   (sFromInteger (sing :: Sing 1))
+                             of {
+                               STrue
+                                 -> let
+                                      lambda ::
+                                        TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) =>
+                                        Sing (Case_0123456789 n TrueSym0)
+                                      lambda = SBaz
+                                    in lambda
+                               SFalse
+                                 -> let
+                                      lambda ::
+                                        FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) =>
+                                        Sing (Case_0123456789 n FalseSym0)
+                                      lambda
+                                        = case
+                                              applySing
+                                                (applySing
+                                                   (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
+                                                (sFromInteger (sing :: Sing 2))
+                                          of {
+                                            STrue
+                                              -> let
+                                                   lambda ::
+                                                     TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 2) =>
+                                                     Sing (Case_0123456789 n TrueSym0)
+                                                   lambda = SBum
+                                                 in lambda
+                                            SFalse
+                                              -> let
+                                                   lambda ::
+                                                     FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 2) =>
+                                                     Sing (Case_0123456789 n FalseSym0)
+                                                   lambda
+                                                     = sError (sing :: Sing "toEnum: bad argument")
+                                                 in lambda } ::
+                                            Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 2)))
+                                    in lambda } ::
+                               Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1)))
+                       in lambda } ::
+                  Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0)))
+          in lambda sN
+      sFromEnum SBar
+        = let
+            lambda ::
+              t0 ~ BarSym0 =>
+              Sing (Apply FromEnumSym0 BarSym0 :: GHC.TypeLits.Nat)
+            lambda = sFromInteger (sing :: Sing 0)
+          in lambda
+      sFromEnum SBaz
+        = let
+            lambda ::
+              t0 ~ BazSym0 =>
+              Sing (Apply FromEnumSym0 BazSym0 :: GHC.TypeLits.Nat)
+            lambda = sFromInteger (sing :: Sing 1)
+          in lambda
+      sFromEnum SBum
+        = let
+            lambda ::
+              t0 ~ BumSym0 =>
+              Sing (Apply FromEnumSym0 BumSym0 :: GHC.TypeLits.Nat)
+            lambda = sFromInteger (sing :: Sing 2)
+          in lambda
+    instance SingI Bar where
+      sing = SBar
+    instance SingI Baz where
+      sing = SBaz
+    instance SingI Bum where
+      sing = SBum
+    instance SingI Q1 where
+      sing = SQ1
+    instance SingI Q2 where
+      sing = SQ2
+Singletons/EnumDeriving.hs:0:0:: Splicing declarations
+    singEnumInstance ''Quux
+  ======>
+    type family Case_0123456789 n t where
+      Case_0123456789 n True = Q2Sym0
+      Case_0123456789 n False = Apply ErrorSym0 "toEnum: bad argument"
+    type family Case_0123456789 n t where
+      Case_0123456789 n True = Q1Sym0
+      Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1))
+    type family ToEnum_0123456789 (a :: GHC.TypeLits.Nat) :: Quux where
+      ToEnum_0123456789 n = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0))
+    type ToEnum_0123456789Sym1 (t :: GHC.TypeLits.Nat) =
+        ToEnum_0123456789 t
+    instance SuppressUnusedWarnings ToEnum_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) ToEnum_0123456789Sym0KindInference GHC.Tuple.())
+    data ToEnum_0123456789Sym0 (l :: TyFun GHC.TypeLits.Nat Quux)
+      = forall arg. KindOf (Apply ToEnum_0123456789Sym0 arg) ~ KindOf (ToEnum_0123456789Sym1 arg) =>
+        ToEnum_0123456789Sym0KindInference
+    type instance Apply ToEnum_0123456789Sym0 l = ToEnum_0123456789Sym1 l
+    type family FromEnum_0123456789 (a :: Quux) :: GHC.TypeLits.Nat where
+      FromEnum_0123456789 Q1 = FromInteger 0
+      FromEnum_0123456789 Q2 = FromInteger 1
+    type FromEnum_0123456789Sym1 (t :: Quux) = FromEnum_0123456789 t
+    instance SuppressUnusedWarnings FromEnum_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) FromEnum_0123456789Sym0KindInference GHC.Tuple.())
+    data FromEnum_0123456789Sym0 (l :: TyFun Quux GHC.TypeLits.Nat)
+      = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) =>
+        FromEnum_0123456789Sym0KindInference
+    type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l
+    instance PEnum (KProxy :: KProxy Quux) where
+      type ToEnum (a :: GHC.TypeLits.Nat) = Apply ToEnum_0123456789Sym0 a
+      type FromEnum (a :: Quux) = Apply FromEnum_0123456789Sym0 a
+    instance SEnum (KProxy :: KProxy Quux) where
+      sToEnum ::
+        forall (t0 :: GHC.TypeLits.Nat).
+        Sing t0
+        -> Sing (Apply (ToEnumSym0 :: TyFun GHC.TypeLits.Nat Quux
+                                      -> *) t0 :: Quux)
+      sFromEnum ::
+        forall (t0 :: Quux).
+        Sing t0
+        -> Sing (Apply (FromEnumSym0 :: TyFun Quux GHC.TypeLits.Nat
+                                        -> *) t0 :: GHC.TypeLits.Nat)
+      sToEnum sN
+        = let
+            lambda ::
+              forall n. t0 ~ n => Sing n -> Sing (Apply ToEnumSym0 n :: Quux)
+            lambda n
+              = case
+                    applySing
+                      (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
+                      (sFromInteger (sing :: Sing 0))
+                of {
+                  STrue
+                    -> let
+                         lambda ::
+                           TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) =>
+                           Sing (Case_0123456789 n TrueSym0)
+                         lambda = SQ1
+                       in lambda
+                  SFalse
+                    -> let
+                         lambda ::
+                           FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) =>
+                           Sing (Case_0123456789 n FalseSym0)
+                         lambda
+                           = case
+                                 applySing
+                                   (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n)
+                                   (sFromInteger (sing :: Sing 1))
+                             of {
+                               STrue
+                                 -> let
+                                      lambda ::
+                                        TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) =>
+                                        Sing (Case_0123456789 n TrueSym0)
+                                      lambda = SQ2
+                                    in lambda
+                               SFalse
+                                 -> let
+                                      lambda ::
+                                        FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) =>
+                                        Sing (Case_0123456789 n FalseSym0)
+                                      lambda = sError (sing :: Sing "toEnum: bad argument")
+                                    in lambda } ::
+                               Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1)))
+                       in lambda } ::
+                  Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0)))
+          in lambda sN
+      sFromEnum SQ1
+        = let
+            lambda ::
+              t0 ~ Q1Sym0 => Sing (Apply FromEnumSym0 Q1Sym0 :: GHC.TypeLits.Nat)
+            lambda = sFromInteger (sing :: Sing 0)
+          in lambda
+      sFromEnum SQ2
+        = let
+            lambda ::
+              t0 ~ Q2Sym0 => Sing (Apply FromEnumSym0 Q2Sym0 :: GHC.TypeLits.Nat)
+            lambda = sFromInteger (sing :: Sing 1)
+          in lambda
diff --git a/tests/compile-and-dump/Singletons/EnumDeriving.hs b/tests/compile-and-dump/Singletons/EnumDeriving.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/EnumDeriving.hs
@@ -0,0 +1,12 @@
+module Singletons.EnumDeriving where
+
+import Data.Singletons.Prelude
+import Data.Singletons.TH
+
+$(singletons [d|
+  data Foo = Bar | Baz | Bum
+    deriving Enum
+  data Quux = Q1 | Q2
+  |])
+
+$(singEnumInstance ''Quux)
diff --git a/tests/compile-and-dump/Singletons/EqInstances.ghc710.template b/tests/compile-and-dump/Singletons/EqInstances.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/EqInstances.ghc710.template
@@ -0,0 +1,23 @@
+Singletons/EqInstances.hs:0:0:: Splicing declarations
+    singEqInstances [''Foo, ''Empty]
+  ======>
+    instance SEq (KProxy :: KProxy Foo) where
+      (%:==) SFLeaf SFLeaf = STrue
+      (%:==) SFLeaf ((:%+:) _ _) = SFalse
+      (%:==) ((:%+:) _ _) SFLeaf = SFalse
+      (%:==) ((:%+:) a a) ((:%+:) b b) = (%:&&) ((%:==) a b) ((%:==) a b)
+    type family Equals_0123456789 (a :: Foo) (b :: Foo) :: Bool where
+      Equals_0123456789 FLeaf FLeaf = TrueSym0
+      Equals_0123456789 ((:+:) a a) ((:+:) b b) = (:&&) ((:==) a b) ((:==) a b)
+      Equals_0123456789 (a :: Foo) (b :: Foo) = FalseSym0
+    instance PEq (KProxy :: KProxy Foo) where
+      type (:==) (a :: Foo) (b :: Foo) = Equals_0123456789 a b
+    instance SEq (KProxy :: KProxy Empty) where
+      (%:==) a _
+        = case a of {
+            _ -> error "Empty case reached -- this should be impossible" }
+    type family Equals_0123456789 (a :: Empty)
+                                  (b :: Empty) :: Bool where
+      Equals_0123456789 (a :: Empty) (b :: Empty) = FalseSym0
+    instance PEq (KProxy :: KProxy Empty) where
+      type (:==) (a :: Empty) (b :: Empty) = Equals_0123456789 a b
diff --git a/tests/compile-and-dump/Singletons/EqInstances.ghc78.template b/tests/compile-and-dump/Singletons/EqInstances.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/EqInstances.ghc78.template
+++ /dev/null
@@ -1,24 +0,0 @@
-Singletons/EqInstances.hs:0:0: Splicing declarations
-    singEqInstances [''Foo, ''Empty]
-  ======>
-    Singletons/EqInstances.hs:0:0:
-    instance SEq (KProxy :: KProxy Foo) where
-      (%:==) SFLeaf SFLeaf = STrue
-      (%:==) SFLeaf ((:%+:) _ _) = SFalse
-      (%:==) ((:%+:) _ _) SFLeaf = SFalse
-      (%:==) ((:%+:) a a) ((:%+:) b b) = (%:&&) ((%:==) a b) ((%:==) a b)
-    type family Equals_0123456789 (a :: Foo) (b :: Foo) :: Bool where
-      Equals_0123456789 FLeaf FLeaf = TrueSym0
-      Equals_0123456789 ((:+:) a a) ((:+:) b b) = (:&&) ((:==) a b) ((:==) a b)
-      Equals_0123456789 (a :: Foo) (b :: Foo) = FalseSym0
-    instance PEq (KProxy :: KProxy Foo) where
-      type (:==) (a :: Foo) (b :: Foo) = Equals_0123456789 a b
-    instance SEq (KProxy :: KProxy Empty) where
-      (%:==) a _
-        = case a of {
-            _ -> error "Empty case reached -- this should be impossible" }
-    type family Equals_0123456789 (a :: Empty)
-                                  (b :: Empty) :: Bool where
-      Equals_0123456789 (a :: Empty) (b :: Empty) = FalseSym0
-    instance PEq (KProxy :: KProxy Empty) where
-      type (:==) (a :: Empty) (b :: Empty) = Equals_0123456789 a b
diff --git a/tests/compile-and-dump/Singletons/Error.ghc710.template b/tests/compile-and-dump/Singletons/Error.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Error.ghc710.template
@@ -0,0 +1,36 @@
+Singletons/Error.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| head :: [a] -> a
+          head (a : _) = a
+          head [] = error "Data.Singletons.List.head: empty list" |]
+  ======>
+    head :: forall a. [a] -> a
+    head (a GHC.Types.: _) = a
+    head GHC.Types.[] = error "Data.Singletons.List.head: empty list"
+    type HeadSym1 (t :: [a]) = Head t
+    instance SuppressUnusedWarnings HeadSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) HeadSym0KindInference GHC.Tuple.())
+    data HeadSym0 (l :: TyFun [a] a)
+      = forall arg. KindOf (Apply HeadSym0 arg) ~ KindOf (HeadSym1 arg) =>
+        HeadSym0KindInference
+    type instance Apply HeadSym0 l = HeadSym1 l
+    type family Head (a :: [a]) :: a where
+      Head ((:) a _z_0123456789) = a
+      Head '[] = Apply ErrorSym0 "Data.Singletons.List.head: empty list"
+    sHead :: forall (t :: [a]). Sing t -> Sing (Apply HeadSym0 t :: a)
+    sHead (SCons sA _s_z_0123456789)
+      = let
+          lambda ::
+            forall a _z_0123456789. t ~ Apply (Apply (:$) a) _z_0123456789 =>
+            Sing a
+            -> Sing _z_0123456789
+               -> Sing (Apply HeadSym0 (Apply (Apply (:$) a) _z_0123456789) :: a)
+          lambda a _z_0123456789 = a
+        in lambda sA _s_z_0123456789
+    sHead SNil
+      = let
+          lambda :: t ~ '[] => Sing (Apply HeadSym0 '[] :: a)
+          lambda
+            = sError (sing :: Sing "Data.Singletons.List.head: empty list")
+        in lambda
diff --git a/tests/compile-and-dump/Singletons/Error.ghc78.template b/tests/compile-and-dump/Singletons/Error.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Error.ghc78.template
+++ /dev/null
@@ -1,37 +0,0 @@
-Singletons/Error.hs:0:0: Splicing declarations
-    singletons
-      [d| head :: [a] -> a
-          head (a : _) = a
-          head [] = error "Data.Singletons.List.head: empty list" |]
-  ======>
-    Singletons/Error.hs:(0,0)-(0,0)
-    head :: forall a. [a] -> a
-    head (a GHC.Types.: _) = a
-    head GHC.Types.[] = error "Data.Singletons.List.head: empty list"
-    type HeadSym1 (t :: [a]) = Head t
-    instance SuppressUnusedWarnings HeadSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) HeadSym0KindInference GHC.Tuple.())
-    data HeadSym0 (l :: TyFun [a] a)
-      = forall arg. KindOf (Apply HeadSym0 arg) ~ KindOf (HeadSym1 arg) =>
-        HeadSym0KindInference
-    type instance Apply HeadSym0 l = HeadSym1 l
-    type family Head (a :: [a]) :: a where
-      Head ((:) a z) = a
-      Head '[] = Apply ErrorSym0 "Data.Singletons.List.head: empty list"
-    sHead :: forall (t :: [a]). Sing t -> Sing (Apply HeadSym0 t)
-    sHead (SCons sA _)
-      = let
-          lambda ::
-            forall a wild. t ~ Apply (Apply (:$) a) wild =>
-            Sing a -> Sing (Apply HeadSym0 (Apply (Apply (:$) a) wild))
-          lambda a = a
-        in lambda sA
-    sHead SNil
-      = let
-          lambda :: t ~ '[] => Sing (Apply HeadSym0 '[])
-          lambda
-            = applySing
-                (singFun1 (Proxy :: Proxy ErrorSym0) sError)
-                (sing :: Sing "Data.Singletons.List.head: empty list")
-        in lambda
diff --git a/tests/compile-and-dump/Singletons/Fixity.ghc710.template b/tests/compile-and-dump/Singletons/Fixity.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Fixity.ghc710.template
@@ -0,0 +1,72 @@
+Singletons/Fixity.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| infix 4 ====
+          infix 4 <=>
+          
+          (====) :: a -> a -> a
+          a ==== _ = a
+          
+          class MyOrd a where
+            (<=>) :: a -> a -> Ordering
+            infix 4 <=> |]
+  ======>
+    class MyOrd a where
+      (<=>) :: a -> a -> Ordering
+    infix 4 <=>
+    (====) :: forall a. a -> a -> a
+    (====) a _ = a
+    infix 4 ====
+    type (:====$$$) (t :: a) (t :: a) = (:====) t t
+    instance SuppressUnusedWarnings (:====$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:====$$###) GHC.Tuple.())
+    data (:====$$) (l :: a) (l :: TyFun a a)
+      = forall arg. KindOf (Apply ((:====$$) l) arg) ~ KindOf ((:====$$$) l arg) =>
+        :====$$###
+    type instance Apply ((:====$$) l) l = (:====$$$) l l
+    instance SuppressUnusedWarnings (:====$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:====$###) GHC.Tuple.())
+    data (:====$) (l :: TyFun a (TyFun a a -> *))
+      = forall arg. KindOf (Apply (:====$) arg) ~ KindOf ((:====$$) arg) =>
+        :====$###
+    type instance Apply (:====$) l = (:====$$) l
+    type family (:====) (a :: a) (a :: a) :: a where
+      (:====) a _z_0123456789 = a
+    infix 4 :====
+    infix 4 :<=>
+    type (:<=>$$$) (t :: a) (t :: a) = (:<=>) t t
+    instance SuppressUnusedWarnings (:<=>$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<=>$$###) GHC.Tuple.())
+    data (:<=>$$) (l :: a) (l :: TyFun a Ordering)
+      = forall arg. KindOf (Apply ((:<=>$$) l) arg) ~ KindOf ((:<=>$$$) l arg) =>
+        :<=>$$###
+    type instance Apply ((:<=>$$) l) l = (:<=>$$$) l l
+    instance SuppressUnusedWarnings (:<=>$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<=>$###) GHC.Tuple.())
+    data (:<=>$) (l :: TyFun a (TyFun a Ordering -> *))
+      = forall arg. KindOf (Apply (:<=>$) arg) ~ KindOf ((:<=>$$) arg) =>
+        :<=>$###
+    type instance Apply (:<=>$) l = (:<=>$$) l
+    class kproxy ~ KProxy => PMyOrd (kproxy :: KProxy a) where
+      type family (:<=>) (arg :: a) (arg :: a) :: Ordering
+    infix 4 %:====
+    infix 4 %:<=>
+    (%:====) ::
+      forall (t :: a) (t :: a).
+      Sing t -> Sing t -> Sing (Apply (Apply (:====$) t) t :: a)
+    (%:====) sA _s_z_0123456789
+      = let
+          lambda ::
+            forall a _z_0123456789. (t ~ a, t ~ _z_0123456789) =>
+            Sing a
+            -> Sing _z_0123456789
+               -> Sing (Apply (Apply (:====$) a) _z_0123456789 :: a)
+          lambda a _z_0123456789 = a
+        in lambda sA _s_z_0123456789
+    class kproxy ~ KProxy => SMyOrd (kproxy :: KProxy a) where
+      (%:<=>) ::
+        forall (t :: a) (t :: a).
+        Sing t -> Sing t -> Sing (Apply (Apply (:<=>$) t) t :: Ordering)
diff --git a/tests/compile-and-dump/Singletons/Fixity.hs b/tests/compile-and-dump/Singletons/Fixity.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Fixity.hs
@@ -0,0 +1,16 @@
+module Singletons.Fixity where
+
+import Data.Singletons
+import Data.Singletons.TH
+import Data.Singletons.Prelude
+import Language.Haskell.TH.Desugar
+
+$(singletons [d|
+  class MyOrd a where
+    (<=>) :: a -> a -> Ordering
+    infix 4 <=>
+
+  (====) :: a -> a -> a
+  a ==== _ = a
+  infix 4 ====
+ |])
diff --git a/tests/compile-and-dump/Singletons/FunDeps.ghc710.template b/tests/compile-and-dump/Singletons/FunDeps.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/FunDeps.ghc710.template
@@ -0,0 +1,98 @@
+Singletons/FunDeps.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| t1 = meth True
+          
+          class FD a b | a -> b where
+            meth :: a -> a
+            l2r :: a -> b
+          
+          instance FD Bool Nat where
+            meth = not
+            l2r False = 0
+            l2r True = 1 |]
+  ======>
+    class FD a b | a -> b where
+      meth :: a -> a
+      l2r :: a -> b
+    instance FD Bool Nat where
+      meth = not
+      l2r False = 0
+      l2r True = 1
+    t1 = meth True
+    type T1Sym0 = T1
+    type family T1 where
+      T1 = Apply MethSym0 TrueSym0
+    type MethSym1 (t :: a) = Meth t
+    instance SuppressUnusedWarnings MethSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MethSym0KindInference GHC.Tuple.())
+    data MethSym0 (l :: TyFun a a)
+      = forall arg. KindOf (Apply MethSym0 arg) ~ KindOf (MethSym1 arg) =>
+        MethSym0KindInference
+    type instance Apply MethSym0 l = MethSym1 l
+    type L2rSym1 (t :: a) = L2r t
+    instance SuppressUnusedWarnings L2rSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) L2rSym0KindInference GHC.Tuple.())
+    data L2rSym0 (l :: TyFun a b)
+      = forall arg. KindOf (Apply L2rSym0 arg) ~ KindOf (L2rSym1 arg) =>
+        L2rSym0KindInference
+    type instance Apply L2rSym0 l = L2rSym1 l
+    class (kproxy ~ KProxy,
+           kproxy ~ KProxy) => PFD (kproxy :: KProxy a)
+                                   (kproxy :: KProxy b) | a -> b where
+      type family Meth (arg :: a) :: a
+      type family L2r (arg :: a) :: b
+    type family Meth_0123456789 (a :: Bool) :: Bool where
+      Meth_0123456789 a_0123456789 = Apply NotSym0 a_0123456789
+    type Meth_0123456789Sym1 (t :: Bool) = Meth_0123456789 t
+    instance SuppressUnusedWarnings Meth_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Meth_0123456789Sym0KindInference GHC.Tuple.())
+    data Meth_0123456789Sym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply Meth_0123456789Sym0 arg) ~ KindOf (Meth_0123456789Sym1 arg) =>
+        Meth_0123456789Sym0KindInference
+    type instance Apply Meth_0123456789Sym0 l = Meth_0123456789Sym1 l
+    type family L2r_0123456789 (a :: Bool) :: Nat where
+      L2r_0123456789 False = FromInteger 0
+      L2r_0123456789 True = FromInteger 1
+    type L2r_0123456789Sym1 (t :: Bool) = L2r_0123456789 t
+    instance SuppressUnusedWarnings L2r_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) L2r_0123456789Sym0KindInference GHC.Tuple.())
+    data L2r_0123456789Sym0 (l :: TyFun Bool Nat)
+      = forall arg. KindOf (Apply L2r_0123456789Sym0 arg) ~ KindOf (L2r_0123456789Sym1 arg) =>
+        L2r_0123456789Sym0KindInference
+    type instance Apply L2r_0123456789Sym0 l = L2r_0123456789Sym1 l
+    instance PFD (KProxy :: KProxy Bool) (KProxy :: KProxy Nat) where
+      type Meth (a :: Bool) = Apply Meth_0123456789Sym0 a
+      type L2r (a :: Bool) = Apply L2r_0123456789Sym0 a
+    sT1 :: Sing T1Sym0
+    sT1 = applySing (singFun1 (Proxy :: Proxy MethSym0) sMeth) STrue
+    class (kproxy ~ KProxy,
+           kproxy ~ KProxy) => SFD (kproxy :: KProxy a)
+                                   (kproxy :: KProxy b) | a -> b where
+      sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a)
+      sL2r :: forall (t :: a). Sing t -> Sing (Apply L2rSym0 t :: b)
+    instance SFD (KProxy :: KProxy Bool) (KProxy :: KProxy Nat) where
+      sMeth ::
+        forall (t :: Bool). Sing t -> Sing (Apply MethSym0 t :: Bool)
+      sL2r :: forall (t :: Bool). Sing t -> Sing (Apply L2rSym0 t :: Nat)
+      sMeth sA_0123456789
+        = let
+            lambda ::
+              forall a_0123456789. t ~ a_0123456789 =>
+              Sing a_0123456789 -> Sing (Apply MethSym0 a_0123456789 :: Bool)
+            lambda a_0123456789
+              = applySing (singFun1 (Proxy :: Proxy NotSym0) sNot) a_0123456789
+          in lambda sA_0123456789
+      sL2r SFalse
+        = let
+            lambda :: t ~ FalseSym0 => Sing (Apply L2rSym0 FalseSym0 :: Nat)
+            lambda = sFromInteger (sing :: Sing 0)
+          in lambda
+      sL2r STrue
+        = let
+            lambda :: t ~ TrueSym0 => Sing (Apply L2rSym0 TrueSym0 :: Nat)
+            lambda = sFromInteger (sing :: Sing 1)
+          in lambda
diff --git a/tests/compile-and-dump/Singletons/FunDeps.hs b/tests/compile-and-dump/Singletons/FunDeps.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/FunDeps.hs
@@ -0,0 +1,21 @@
+{-# LANGUAGE FunctionalDependencies #-}
+
+module Singletons.FunDeps where
+
+import Data.Singletons.TH
+import Data.Singletons.Prelude
+import Data.Singletons.TypeLits
+
+$( singletons [d|
+  class FD a b | a -> b where
+    meth :: a -> a
+    l2r  :: a -> b
+
+  instance FD Bool Nat where
+    meth = not
+    l2r False = 0
+    l2r True  = 1
+
+  t1 = meth True
+--  t2 = l2r False  -- This fails because no FDs in type families
+  |])
diff --git a/tests/compile-and-dump/Singletons/HigherOrder.ghc710.template b/tests/compile-and-dump/Singletons/HigherOrder.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/HigherOrder.ghc710.template
@@ -0,0 +1,625 @@
+Singletons/HigherOrder.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| map :: (a -> b) -> [a] -> [b]
+          map _ [] = []
+          map f (h : t) = (f h) : (map f t)
+          liftMaybe :: (a -> b) -> Maybe a -> Maybe b
+          liftMaybe f (Just x) = Just (f x)
+          liftMaybe _ Nothing = Nothing
+          zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+          zipWith f (x : xs) (y : ys) = f x y : zipWith f xs ys
+          zipWith _ [] [] = []
+          zipWith _ (_ : _) [] = []
+          zipWith _ [] (_ : _) = []
+          foo :: ((a -> b) -> a -> b) -> (a -> b) -> a -> b
+          foo f g a = f g a
+          splunge :: [Nat] -> [Bool] -> [Nat]
+          splunge ns bs
+            = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs
+          etad :: [Nat] -> [Bool] -> [Nat]
+          etad = zipWith (\ n b -> if b then Succ (Succ n) else n)
+          
+          data Either a b = Left a | Right b |]
+  ======>
+    data Either a b = Left a | Right b
+    map :: forall a b. (a -> b) -> [a] -> [b]
+    map _ GHC.Types.[] = []
+    map f (h GHC.Types.: t) = ((f h) GHC.Types.: (map f t))
+    liftMaybe :: forall a b. (a -> b) -> Maybe a -> Maybe b
+    liftMaybe f (Just x) = Just (f x)
+    liftMaybe _ Nothing = Nothing
+    zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
+    zipWith f (x GHC.Types.: xs) (y GHC.Types.: ys)
+      = ((f x y) GHC.Types.: (zipWith f xs ys))
+    zipWith _ GHC.Types.[] GHC.Types.[] = []
+    zipWith _ (_ GHC.Types.: _) GHC.Types.[] = []
+    zipWith _ GHC.Types.[] (_ GHC.Types.: _) = []
+    foo :: forall a b. ((a -> b) -> a -> b) -> (a -> b) -> a -> b
+    foo f g a = f g a
+    splunge :: [Nat] -> [Bool] -> [Nat]
+    splunge ns bs
+      = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs
+    etad :: [Nat] -> [Bool] -> [Nat]
+    etad = zipWith (\ n b -> if b then Succ (Succ n) else n)
+    type LeftSym1 (t :: a) = Left t
+    instance SuppressUnusedWarnings LeftSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LeftSym0KindInference GHC.Tuple.())
+    data LeftSym0 (l :: TyFun a (Either a b))
+      = forall arg. KindOf (Apply LeftSym0 arg) ~ KindOf (LeftSym1 arg) =>
+        LeftSym0KindInference
+    type instance Apply LeftSym0 l = LeftSym1 l
+    type RightSym1 (t :: b) = Right t
+    instance SuppressUnusedWarnings RightSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) RightSym0KindInference GHC.Tuple.())
+    data RightSym0 (l :: TyFun b (Either a b))
+      = forall arg. KindOf (Apply RightSym0 arg) ~ KindOf (RightSym1 arg) =>
+        RightSym0KindInference
+    type instance Apply RightSym0 l = RightSym1 l
+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
+        Let0123456789Scrutinee_0123456789 t t t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>
+        Let0123456789Scrutinee_0123456789Sym3KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>
+        Let0123456789Scrutinee_0123456789Sym2KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
+        Let0123456789Scrutinee_0123456789Sym1KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 ns bs n b where
+      Let0123456789Scrutinee_0123456789 ns bs n b = b
+    type family Case_0123456789 ns bs n b t where
+      Case_0123456789 ns bs n b True = Apply SuccSym0 (Apply SuccSym0 n)
+      Case_0123456789 ns bs n b False = n
+    type family Lambda_0123456789 ns bs t t where
+      Lambda_0123456789 ns bs n b = Case_0123456789 ns bs n b (Let0123456789Scrutinee_0123456789Sym4 ns bs n b)
+    type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
+        Lambda_0123456789Sym3KindInference
+    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
+        Let0123456789Scrutinee_0123456789 t t t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>
+        Let0123456789Scrutinee_0123456789Sym3KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>
+        Let0123456789Scrutinee_0123456789Sym2KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
+        Let0123456789Scrutinee_0123456789Sym1KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 n
+                                                  b
+                                                  a_0123456789
+                                                  a_0123456789 where
+      Let0123456789Scrutinee_0123456789 n b a_0123456789 a_0123456789 = b
+    type family Case_0123456789 n b a_0123456789 a_0123456789 t where
+      Case_0123456789 n b a_0123456789 a_0123456789 True = Apply SuccSym0 (Apply SuccSym0 n)
+      Case_0123456789 n b a_0123456789 a_0123456789 False = n
+    type family Lambda_0123456789 a_0123456789 a_0123456789 t t where
+      Lambda_0123456789 a_0123456789 a_0123456789 n b = Case_0123456789 n b a_0123456789 a_0123456789 (Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)
+    type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
+        Lambda_0123456789Sym3KindInference
+    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type FooSym3 (t :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
+                 (t :: TyFun a b -> *)
+                 (t :: a) =
+        Foo t t t
+    instance SuppressUnusedWarnings FooSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym2KindInference GHC.Tuple.())
+    data FooSym2 (l :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
+                 (l :: TyFun a b -> *)
+                 (l :: TyFun a b)
+      = forall arg. KindOf (Apply (FooSym2 l l) arg) ~ KindOf (FooSym3 l l arg) =>
+        FooSym2KindInference
+    type instance Apply (FooSym2 l l) l = FooSym3 l l l
+    instance SuppressUnusedWarnings FooSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym1KindInference GHC.Tuple.())
+    data FooSym1 (l :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
+                 (l :: TyFun (TyFun a b -> *) (TyFun a b -> *))
+      = forall arg. KindOf (Apply (FooSym1 l) arg) ~ KindOf (FooSym2 l arg) =>
+        FooSym1KindInference
+    type instance Apply (FooSym1 l) l = FooSym2 l l
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun (TyFun (TyFun a b -> *) (TyFun a b -> *)
+                              -> *) (TyFun (TyFun a b -> *) (TyFun a b -> *) -> *))
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type ZipWithSym3 (t :: TyFun a (TyFun b c -> *) -> *)
+                     (t :: [a])
+                     (t :: [b]) =
+        ZipWith t t t
+    instance SuppressUnusedWarnings ZipWithSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ZipWithSym2KindInference GHC.Tuple.())
+    data ZipWithSym2 (l :: TyFun a (TyFun b c -> *) -> *)
+                     (l :: [a])
+                     (l :: TyFun [b] [c])
+      = forall arg. KindOf (Apply (ZipWithSym2 l l) arg) ~ KindOf (ZipWithSym3 l l arg) =>
+        ZipWithSym2KindInference
+    type instance Apply (ZipWithSym2 l l) l = ZipWithSym3 l l l
+    instance SuppressUnusedWarnings ZipWithSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ZipWithSym1KindInference GHC.Tuple.())
+    data ZipWithSym1 (l :: TyFun a (TyFun b c -> *) -> *)
+                     (l :: TyFun [a] (TyFun [b] [c] -> *))
+      = forall arg. KindOf (Apply (ZipWithSym1 l) arg) ~ KindOf (ZipWithSym2 l arg) =>
+        ZipWithSym1KindInference
+    type instance Apply (ZipWithSym1 l) l = ZipWithSym2 l l
+    instance SuppressUnusedWarnings ZipWithSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ZipWithSym0KindInference GHC.Tuple.())
+    data ZipWithSym0 (l :: TyFun (TyFun a (TyFun b c -> *)
+                                  -> *) (TyFun [a] (TyFun [b] [c] -> *) -> *))
+      = forall arg. KindOf (Apply ZipWithSym0 arg) ~ KindOf (ZipWithSym1 arg) =>
+        ZipWithSym0KindInference
+    type instance Apply ZipWithSym0 l = ZipWithSym1 l
+    type SplungeSym2 (t :: [Nat]) (t :: [Bool]) = Splunge t t
+    instance SuppressUnusedWarnings SplungeSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SplungeSym1KindInference GHC.Tuple.())
+    data SplungeSym1 (l :: [Nat]) (l :: TyFun [Bool] [Nat])
+      = forall arg. KindOf (Apply (SplungeSym1 l) arg) ~ KindOf (SplungeSym2 l arg) =>
+        SplungeSym1KindInference
+    type instance Apply (SplungeSym1 l) l = SplungeSym2 l l
+    instance SuppressUnusedWarnings SplungeSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SplungeSym0KindInference GHC.Tuple.())
+    data SplungeSym0 (l :: TyFun [Nat] (TyFun [Bool] [Nat] -> *))
+      = forall arg. KindOf (Apply SplungeSym0 arg) ~ KindOf (SplungeSym1 arg) =>
+        SplungeSym0KindInference
+    type instance Apply SplungeSym0 l = SplungeSym1 l
+    type EtadSym2 (t :: [Nat]) (t :: [Bool]) = Etad t t
+    instance SuppressUnusedWarnings EtadSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) EtadSym1KindInference GHC.Tuple.())
+    data EtadSym1 (l :: [Nat]) (l :: TyFun [Bool] [Nat])
+      = forall arg. KindOf (Apply (EtadSym1 l) arg) ~ KindOf (EtadSym2 l arg) =>
+        EtadSym1KindInference
+    type instance Apply (EtadSym1 l) l = EtadSym2 l l
+    instance SuppressUnusedWarnings EtadSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) EtadSym0KindInference GHC.Tuple.())
+    data EtadSym0 (l :: TyFun [Nat] (TyFun [Bool] [Nat] -> *))
+      = forall arg. KindOf (Apply EtadSym0 arg) ~ KindOf (EtadSym1 arg) =>
+        EtadSym0KindInference
+    type instance Apply EtadSym0 l = EtadSym1 l
+    type LiftMaybeSym2 (t :: TyFun a b -> *) (t :: Maybe a) =
+        LiftMaybe t t
+    instance SuppressUnusedWarnings LiftMaybeSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LiftMaybeSym1KindInference GHC.Tuple.())
+    data LiftMaybeSym1 (l :: TyFun a b -> *)
+                       (l :: TyFun (Maybe a) (Maybe b))
+      = forall arg. KindOf (Apply (LiftMaybeSym1 l) arg) ~ KindOf (LiftMaybeSym2 l arg) =>
+        LiftMaybeSym1KindInference
+    type instance Apply (LiftMaybeSym1 l) l = LiftMaybeSym2 l l
+    instance SuppressUnusedWarnings LiftMaybeSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) LiftMaybeSym0KindInference GHC.Tuple.())
+    data LiftMaybeSym0 (l :: TyFun (TyFun a b
+                                    -> *) (TyFun (Maybe a) (Maybe b) -> *))
+      = forall arg. KindOf (Apply LiftMaybeSym0 arg) ~ KindOf (LiftMaybeSym1 arg) =>
+        LiftMaybeSym0KindInference
+    type instance Apply LiftMaybeSym0 l = LiftMaybeSym1 l
+    type MapSym2 (t :: TyFun a b -> *) (t :: [a]) = Map t t
+    instance SuppressUnusedWarnings MapSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MapSym1KindInference GHC.Tuple.())
+    data MapSym1 (l :: TyFun a b -> *) (l :: TyFun [a] [b])
+      = forall arg. KindOf (Apply (MapSym1 l) arg) ~ KindOf (MapSym2 l arg) =>
+        MapSym1KindInference
+    type instance Apply (MapSym1 l) l = MapSym2 l l
+    instance SuppressUnusedWarnings MapSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MapSym0KindInference GHC.Tuple.())
+    data MapSym0 (l :: TyFun (TyFun a b -> *) (TyFun [a] [b] -> *))
+      = forall arg. KindOf (Apply MapSym0 arg) ~ KindOf (MapSym1 arg) =>
+        MapSym0KindInference
+    type instance Apply MapSym0 l = MapSym1 l
+    type family Foo (a :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
+                    (a :: TyFun a b -> *)
+                    (a :: a) :: b where
+      Foo f g a = Apply (Apply f g) a
+    type family ZipWith (a :: TyFun a (TyFun b c -> *) -> *)
+                        (a :: [a])
+                        (a :: [b]) :: [c] where
+      ZipWith f ((:) x xs) ((:) y ys) = Apply (Apply (:$) (Apply (Apply f x) y)) (Apply (Apply (Apply ZipWithSym0 f) xs) ys)
+      ZipWith _z_0123456789 '[] '[] = '[]
+      ZipWith _z_0123456789 ((:) _z_0123456789 _z_0123456789) '[] = '[]
+      ZipWith _z_0123456789 '[] ((:) _z_0123456789 _z_0123456789) = '[]
+    type family Splunge (a :: [Nat]) (a :: [Bool]) :: [Nat] where
+      Splunge ns bs = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789Sym0 ns) bs)) ns) bs
+    type family Etad (a :: [Nat]) (a :: [Bool]) :: [Nat] where
+      Etad a_0123456789 a_0123456789 = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789)) a_0123456789) a_0123456789
+    type family LiftMaybe (a :: TyFun a b -> *)
+                          (a :: Maybe a) :: Maybe b where
+      LiftMaybe f (Just x) = Apply JustSym0 (Apply f x)
+      LiftMaybe _z_0123456789 Nothing = NothingSym0
+    type family Map (a :: TyFun a b -> *) (a :: [a]) :: [b] where
+      Map _z_0123456789 '[] = '[]
+      Map f ((:) h t) = Apply (Apply (:$) (Apply f h)) (Apply (Apply MapSym0 f) t)
+    sFoo ::
+      forall (t :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
+             (t :: TyFun a b -> *)
+             (t :: a).
+      Sing t
+      -> Sing t
+         -> Sing t -> Sing (Apply (Apply (Apply FooSym0 t) t) t :: b)
+    sZipWith ::
+      forall (t :: TyFun a (TyFun b c -> *) -> *) (t :: [a]) (t :: [b]).
+      Sing t
+      -> Sing t
+         -> Sing t -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c])
+    sSplunge ::
+      forall (t :: [Nat]) (t :: [Bool]).
+      Sing t -> Sing t -> Sing (Apply (Apply SplungeSym0 t) t :: [Nat])
+    sEtad ::
+      forall (t :: [Nat]) (t :: [Bool]).
+      Sing t -> Sing t -> Sing (Apply (Apply EtadSym0 t) t :: [Nat])
+    sLiftMaybe ::
+      forall (t :: TyFun a b -> *) (t :: Maybe a).
+      Sing t
+      -> Sing t -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b)
+    sMap ::
+      forall (t :: TyFun a b -> *) (t :: [a]).
+      Sing t -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b])
+    sFoo sF sG sA
+      = let
+          lambda ::
+            forall f g a. (t ~ f, t ~ g, t ~ a) =>
+            Sing f
+            -> Sing g
+               -> Sing a -> Sing (Apply (Apply (Apply FooSym0 f) g) a :: b)
+          lambda f g a = applySing (applySing f g) a
+        in lambda sF sG sA
+    sZipWith sF (SCons sX sXs) (SCons sY sYs)
+      = let
+          lambda ::
+            forall f x xs y ys. (t ~ f,
+                                 t ~ Apply (Apply (:$) x) xs,
+                                 t ~ Apply (Apply (:$) y) ys) =>
+            Sing f
+            -> Sing x
+               -> Sing xs
+                  -> Sing y
+                     -> Sing ys
+                        -> Sing (Apply (Apply (Apply ZipWithSym0 f) (Apply (Apply (:$) x) xs)) (Apply (Apply (:$) y) ys) :: [c])
+          lambda f x xs y ys
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing (applySing f x) y))
+                (applySing
+                   (applySing
+                      (applySing (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith) f) xs)
+                   ys)
+        in lambda sF sX sXs sY sYs
+    sZipWith _s_z_0123456789 SNil SNil
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ _z_0123456789, t ~ '[], t ~ '[]) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply (Apply ZipWithSym0 _z_0123456789) '[]) '[] :: [c])
+          lambda _z_0123456789 = SNil
+        in lambda _s_z_0123456789
+    sZipWith
+      _s_z_0123456789
+      (SCons _s_z_0123456789 _s_z_0123456789)
+      SNil
+      = let
+          lambda ::
+            forall _z_0123456789
+                   _z_0123456789
+                   _z_0123456789. (t ~ _z_0123456789,
+                                   t ~ Apply (Apply (:$) _z_0123456789) _z_0123456789,
+                                   t ~ '[]) =>
+            Sing _z_0123456789
+            -> Sing _z_0123456789
+               -> Sing _z_0123456789
+                  -> Sing (Apply (Apply (Apply ZipWithSym0 _z_0123456789) (Apply (Apply (:$) _z_0123456789) _z_0123456789)) '[] :: [c])
+          lambda _z_0123456789 _z_0123456789 _z_0123456789 = SNil
+        in lambda _s_z_0123456789 _s_z_0123456789 _s_z_0123456789
+    sZipWith
+      _s_z_0123456789
+      SNil
+      (SCons _s_z_0123456789 _s_z_0123456789)
+      = let
+          lambda ::
+            forall _z_0123456789
+                   _z_0123456789
+                   _z_0123456789. (t ~ _z_0123456789,
+                                   t ~ '[],
+                                   t ~ Apply (Apply (:$) _z_0123456789) _z_0123456789) =>
+            Sing _z_0123456789
+            -> Sing _z_0123456789
+               -> Sing _z_0123456789
+                  -> Sing (Apply (Apply (Apply ZipWithSym0 _z_0123456789) '[]) (Apply (Apply (:$) _z_0123456789) _z_0123456789) :: [c])
+          lambda _z_0123456789 _z_0123456789 _z_0123456789 = SNil
+        in lambda _s_z_0123456789 _s_z_0123456789 _s_z_0123456789
+    sSplunge sNs sBs
+      = let
+          lambda ::
+            forall ns bs. (t ~ ns, t ~ bs) =>
+            Sing ns
+            -> Sing bs -> Sing (Apply (Apply SplungeSym0 ns) bs :: [Nat])
+          lambda ns bs
+            = applySing
+                (applySing
+                   (applySing
+                      (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith)
+                      (singFun2
+                         (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 ns) bs))
+                         (\ sN sB
+                            -> let
+                                 lambda ::
+                                   forall n b.
+                                   Sing n
+                                   -> Sing b
+                                      -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 ns) bs) n) b)
+                                 lambda n b
+                                   = let
+                                       sScrutinee_0123456789 ::
+                                         Sing (Let0123456789Scrutinee_0123456789Sym4 ns bs n b)
+                                       sScrutinee_0123456789 = b
+                                     in  case sScrutinee_0123456789 of {
+                                           STrue
+                                             -> let
+                                                  lambda ::
+                                                    TrueSym0 ~ Let0123456789Scrutinee_0123456789Sym4 ns bs n b =>
+                                                    Sing (Case_0123456789 ns bs n b TrueSym0)
+                                                  lambda
+                                                    = applySing
+                                                        (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                                                        (applySing
+                                                           (singFun1
+                                                              (Proxy :: Proxy SuccSym0) SSucc)
+                                                           n)
+                                                in lambda
+                                           SFalse
+                                             -> let
+                                                  lambda ::
+                                                    FalseSym0 ~ Let0123456789Scrutinee_0123456789Sym4 ns bs n b =>
+                                                    Sing (Case_0123456789 ns bs n b FalseSym0)
+                                                  lambda = n
+                                                in lambda } ::
+                                           Sing (Case_0123456789 ns bs n b (Let0123456789Scrutinee_0123456789Sym4 ns bs n b))
+                               in lambda sN sB)))
+                   ns)
+                bs
+        in lambda sNs sBs
+    sEtad sA_0123456789 sA_0123456789
+      = let
+          lambda ::
+            forall a_0123456789 a_0123456789. (t ~ a_0123456789,
+                                               t ~ a_0123456789) =>
+            Sing a_0123456789
+            -> Sing a_0123456789
+               -> Sing (Apply (Apply EtadSym0 a_0123456789) a_0123456789 :: [Nat])
+          lambda a_0123456789 a_0123456789
+            = applySing
+                (applySing
+                   (applySing
+                      (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith)
+                      (singFun2
+                         (Proxy ::
+                            Proxy (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789))
+                         (\ sN sB
+                            -> let
+                                 lambda ::
+                                   forall n b.
+                                   Sing n
+                                   -> Sing b
+                                      -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) n) b)
+                                 lambda n b
+                                   = let
+                                       sScrutinee_0123456789 ::
+                                         Sing (Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)
+                                       sScrutinee_0123456789 = b
+                                     in  case sScrutinee_0123456789 of {
+                                           STrue
+                                             -> let
+                                                  lambda ::
+                                                    TrueSym0 ~ Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789 =>
+                                                    Sing (Case_0123456789 n b a_0123456789 a_0123456789 TrueSym0)
+                                                  lambda
+                                                    = applySing
+                                                        (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                                                        (applySing
+                                                           (singFun1
+                                                              (Proxy :: Proxy SuccSym0) SSucc)
+                                                           n)
+                                                in lambda
+                                           SFalse
+                                             -> let
+                                                  lambda ::
+                                                    FalseSym0 ~ Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789 =>
+                                                    Sing (Case_0123456789 n b a_0123456789 a_0123456789 FalseSym0)
+                                                  lambda = n
+                                                in lambda } ::
+                                           Sing (Case_0123456789 n b a_0123456789 a_0123456789 (Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789))
+                               in lambda sN sB)))
+                   a_0123456789)
+                a_0123456789
+        in lambda sA_0123456789 sA_0123456789
+    sLiftMaybe sF (SJust sX)
+      = let
+          lambda ::
+            forall f x. (t ~ f, t ~ Apply JustSym0 x) =>
+            Sing f
+            -> Sing x
+               -> Sing (Apply (Apply LiftMaybeSym0 f) (Apply JustSym0 x) :: Maybe b)
+          lambda f x
+            = applySing
+                (singFun1 (Proxy :: Proxy JustSym0) SJust) (applySing f x)
+        in lambda sF sX
+    sLiftMaybe _s_z_0123456789 SNothing
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ _z_0123456789, t ~ NothingSym0) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply LiftMaybeSym0 _z_0123456789) NothingSym0 :: Maybe b)
+          lambda _z_0123456789 = SNothing
+        in lambda _s_z_0123456789
+    sMap _s_z_0123456789 SNil
+      = let
+          lambda ::
+            forall _z_0123456789. (t ~ _z_0123456789, t ~ '[]) =>
+            Sing _z_0123456789
+            -> Sing (Apply (Apply MapSym0 _z_0123456789) '[] :: [b])
+          lambda _z_0123456789 = SNil
+        in lambda _s_z_0123456789
+    sMap sF (SCons sH sT)
+      = let
+          lambda ::
+            forall f h t. (t ~ f, t ~ Apply (Apply (:$) h) t) =>
+            Sing f
+            -> Sing h
+               -> Sing t
+                  -> Sing (Apply (Apply MapSym0 f) (Apply (Apply (:$) h) t) :: [b])
+          lambda f h t
+            = applySing
+                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) (applySing f h))
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy MapSym0) sMap) f) t)
+        in lambda sF sH sT
+    data instance Sing (z :: Either a b)
+      = forall (n :: a). z ~ Left n => SLeft (Sing (n :: a)) |
+        forall (n :: b). z ~ Right n => SRight (Sing (n :: b))
+    type SEither = (Sing :: Either a b -> *)
+    instance (SingKind (KProxy :: KProxy a),
+              SingKind (KProxy :: KProxy b)) =>
+             SingKind (KProxy :: KProxy (Either a b)) where
+      type DemoteRep (KProxy :: KProxy (Either a b)) = Either (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
+      fromSing (SLeft b) = Left (fromSing b)
+      fromSing (SRight b) = Right (fromSing b)
+      toSing (Left b)
+        = case toSing b :: SomeSing (KProxy :: KProxy a) of {
+            SomeSing c -> SomeSing (SLeft c) }
+      toSing (Right b)
+        = case toSing b :: SomeSing (KProxy :: KProxy b) of {
+            SomeSing c -> SomeSing (SRight c) }
+    instance SingI n => SingI (Left (n :: a)) where
+      sing = SLeft sing
+    instance SingI n => SingI (Right (n :: b)) where
+      sing = SRight sing
diff --git a/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template b/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template
+++ /dev/null
@@ -1,594 +0,0 @@
-Singletons/HigherOrder.hs:0:0: Splicing declarations
-    singletons
-      [d| map :: (a -> b) -> [a] -> [b]
-          map _ [] = []
-          map f (h : t) = (f h) : (map f t)
-          liftMaybe :: (a -> b) -> Maybe a -> Maybe b
-          liftMaybe f (Just x) = Just (f x)
-          liftMaybe _ Nothing = Nothing
-          zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
-          zipWith f (x : xs) (y : ys) = f x y : zipWith f xs ys
-          zipWith _ [] [] = []
-          zipWith _ (_ : _) [] = []
-          zipWith _ [] (_ : _) = []
-          foo :: ((a -> b) -> a -> b) -> (a -> b) -> a -> b
-          foo f g a = f g a
-          splunge :: [Nat] -> [Bool] -> [Nat]
-          splunge ns bs
-            = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs
-          etad :: [Nat] -> [Bool] -> [Nat]
-          etad = zipWith (\ n b -> if b then Succ (Succ n) else n)
-          
-          data Either a b = Left a | Right b |]
-  ======>
-    Singletons/HigherOrder.hs:(0,0)-(0,0)
-    data Either a b = Left a | Right b
-    map :: forall a b. (a -> b) -> [a] -> [b]
-    map _ GHC.Types.[] = []
-    map f (h GHC.Types.: t) = ((f h) GHC.Types.: (map f t))
-    liftMaybe :: forall a b. (a -> b) -> Maybe a -> Maybe b
-    liftMaybe f (Just x) = Just (f x)
-    liftMaybe _ Nothing = Nothing
-    zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
-    zipWith f (x GHC.Types.: xs) (y GHC.Types.: ys)
-      = ((f x y) GHC.Types.: (zipWith f xs ys))
-    zipWith _ GHC.Types.[] GHC.Types.[] = []
-    zipWith _ (_ GHC.Types.: _) GHC.Types.[] = []
-    zipWith _ GHC.Types.[] (_ GHC.Types.: _) = []
-    foo :: forall a b. ((a -> b) -> a -> b) -> (a -> b) -> a -> b
-    foo f g a = f g a
-    splunge :: [Nat] -> [Bool] -> [Nat]
-    splunge ns bs
-      = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs
-    etad :: [Nat] -> [Bool] -> [Nat]
-    etad = zipWith (\ n b -> if b then Succ (Succ n) else n)
-    type LeftSym1 (t :: a) = Left t
-    instance SuppressUnusedWarnings LeftSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LeftSym0KindInference GHC.Tuple.())
-    data LeftSym0 (l :: TyFun a (Either a b))
-      = forall arg. KindOf (Apply LeftSym0 arg) ~ KindOf (LeftSym1 arg) =>
-        LeftSym0KindInference
-    type instance Apply LeftSym0 l = LeftSym1 l
-    type RightSym1 (t :: b) = Right t
-    instance SuppressUnusedWarnings RightSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) RightSym0KindInference GHC.Tuple.())
-    data RightSym0 (l :: TyFun b (Either a b))
-      = forall arg. KindOf (Apply RightSym0 arg) ~ KindOf (RightSym1 arg) =>
-        RightSym0KindInference
-    type instance Apply RightSym0 l = RightSym1 l
-    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
-        Let0123456789Scrutinee_0123456789 t t t t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>
-        Let0123456789Scrutinee_0123456789Sym3KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>
-        Let0123456789Scrutinee_0123456789Sym2KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 ns bs n b = b
-    type family Case_0123456789 ns bs n b t where
-      Case_0123456789 ns bs n b True = Apply SuccSym0 (Apply SuccSym0 n)
-      Case_0123456789 ns bs n b False = n
-    type family Lambda_0123456789 ns bs t t where
-      Lambda_0123456789 ns bs n b = Case_0123456789 ns bs n b (Let0123456789Scrutinee_0123456789Sym4 ns bs n b)
-    type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
-        Lambda_0123456789Sym3KindInference
-    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
-        Let0123456789Scrutinee_0123456789 t t t t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>
-        Let0123456789Scrutinee_0123456789Sym3KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>
-        Let0123456789Scrutinee_0123456789Sym2KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 n
-                                            b
-                                            a_0123456789
-                                            a_0123456789 =
-        b
-    type family Case_0123456789 n b a_0123456789 a_0123456789 t where
-      Case_0123456789 n b a_0123456789 a_0123456789 True = Apply SuccSym0 (Apply SuccSym0 n)
-      Case_0123456789 n b a_0123456789 a_0123456789 False = n
-    type family Lambda_0123456789 a_0123456789 a_0123456789 t t where
-      Lambda_0123456789 a_0123456789 a_0123456789 n b = Case_0123456789 n b a_0123456789 a_0123456789 (Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)
-    type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
-        Lambda_0123456789Sym3KindInference
-    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type FooSym3 (t :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
-                 (t :: TyFun a b -> *)
-                 (t :: a) =
-        Foo t t t
-    instance SuppressUnusedWarnings FooSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym2KindInference GHC.Tuple.())
-    data FooSym2 (l :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
-                 (l :: TyFun a b -> *)
-                 (l :: TyFun a b)
-      = forall arg. KindOf (Apply (FooSym2 l l) arg) ~ KindOf (FooSym3 l l arg) =>
-        FooSym2KindInference
-    type instance Apply (FooSym2 l l) l = FooSym3 l l l
-    instance SuppressUnusedWarnings FooSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym1KindInference GHC.Tuple.())
-    data FooSym1 (l :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
-                 (l :: TyFun (TyFun a b -> *) (TyFun a b -> *))
-      = forall arg. KindOf (Apply (FooSym1 l) arg) ~ KindOf (FooSym2 l arg) =>
-        FooSym1KindInference
-    type instance Apply (FooSym1 l) l = FooSym2 l l
-    instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
-    data FooSym0 (l :: TyFun (TyFun (TyFun a b -> *) (TyFun a b -> *)
-                              -> *) (TyFun (TyFun a b -> *) (TyFun a b -> *) -> *))
-      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
-        FooSym0KindInference
-    type instance Apply FooSym0 l = FooSym1 l
-    type ZipWithSym3 (t :: TyFun a (TyFun b c -> *) -> *)
-                     (t :: [a])
-                     (t :: [b]) =
-        ZipWith t t t
-    instance SuppressUnusedWarnings ZipWithSym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ZipWithSym2KindInference GHC.Tuple.())
-    data ZipWithSym2 (l :: TyFun a (TyFun b c -> *) -> *)
-                     (l :: [a])
-                     (l :: TyFun [b] [c])
-      = forall arg. KindOf (Apply (ZipWithSym2 l l) arg) ~ KindOf (ZipWithSym3 l l arg) =>
-        ZipWithSym2KindInference
-    type instance Apply (ZipWithSym2 l l) l = ZipWithSym3 l l l
-    instance SuppressUnusedWarnings ZipWithSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ZipWithSym1KindInference GHC.Tuple.())
-    data ZipWithSym1 (l :: TyFun a (TyFun b c -> *) -> *)
-                     (l :: TyFun [a] (TyFun [b] [c] -> *))
-      = forall arg. KindOf (Apply (ZipWithSym1 l) arg) ~ KindOf (ZipWithSym2 l arg) =>
-        ZipWithSym1KindInference
-    type instance Apply (ZipWithSym1 l) l = ZipWithSym2 l l
-    instance SuppressUnusedWarnings ZipWithSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ZipWithSym0KindInference GHC.Tuple.())
-    data ZipWithSym0 (l :: TyFun (TyFun a (TyFun b c -> *)
-                                  -> *) (TyFun [a] (TyFun [b] [c] -> *) -> *))
-      = forall arg. KindOf (Apply ZipWithSym0 arg) ~ KindOf (ZipWithSym1 arg) =>
-        ZipWithSym0KindInference
-    type instance Apply ZipWithSym0 l = ZipWithSym1 l
-    type SplungeSym2 (t :: [Nat]) (t :: [Bool]) = Splunge t t
-    instance SuppressUnusedWarnings SplungeSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) SplungeSym1KindInference GHC.Tuple.())
-    data SplungeSym1 (l :: [Nat]) (l :: TyFun [Bool] [Nat])
-      = forall arg. KindOf (Apply (SplungeSym1 l) arg) ~ KindOf (SplungeSym2 l arg) =>
-        SplungeSym1KindInference
-    type instance Apply (SplungeSym1 l) l = SplungeSym2 l l
-    instance SuppressUnusedWarnings SplungeSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) SplungeSym0KindInference GHC.Tuple.())
-    data SplungeSym0 (l :: TyFun [Nat] (TyFun [Bool] [Nat] -> *))
-      = forall arg. KindOf (Apply SplungeSym0 arg) ~ KindOf (SplungeSym1 arg) =>
-        SplungeSym0KindInference
-    type instance Apply SplungeSym0 l = SplungeSym1 l
-    type EtadSym2 (t :: [Nat]) (t :: [Bool]) = Etad t t
-    instance SuppressUnusedWarnings EtadSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) EtadSym1KindInference GHC.Tuple.())
-    data EtadSym1 (l :: [Nat]) (l :: TyFun [Bool] [Nat])
-      = forall arg. KindOf (Apply (EtadSym1 l) arg) ~ KindOf (EtadSym2 l arg) =>
-        EtadSym1KindInference
-    type instance Apply (EtadSym1 l) l = EtadSym2 l l
-    instance SuppressUnusedWarnings EtadSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) EtadSym0KindInference GHC.Tuple.())
-    data EtadSym0 (l :: TyFun [Nat] (TyFun [Bool] [Nat] -> *))
-      = forall arg. KindOf (Apply EtadSym0 arg) ~ KindOf (EtadSym1 arg) =>
-        EtadSym0KindInference
-    type instance Apply EtadSym0 l = EtadSym1 l
-    type LiftMaybeSym2 (t :: TyFun a b -> *) (t :: Maybe a) =
-        LiftMaybe t t
-    instance SuppressUnusedWarnings LiftMaybeSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LiftMaybeSym1KindInference GHC.Tuple.())
-    data LiftMaybeSym1 (l :: TyFun a b -> *)
-                       (l :: TyFun (Maybe a) (Maybe b))
-      = forall arg. KindOf (Apply (LiftMaybeSym1 l) arg) ~ KindOf (LiftMaybeSym2 l arg) =>
-        LiftMaybeSym1KindInference
-    type instance Apply (LiftMaybeSym1 l) l = LiftMaybeSym2 l l
-    instance SuppressUnusedWarnings LiftMaybeSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) LiftMaybeSym0KindInference GHC.Tuple.())
-    data LiftMaybeSym0 (l :: TyFun (TyFun a b
-                                    -> *) (TyFun (Maybe a) (Maybe b) -> *))
-      = forall arg. KindOf (Apply LiftMaybeSym0 arg) ~ KindOf (LiftMaybeSym1 arg) =>
-        LiftMaybeSym0KindInference
-    type instance Apply LiftMaybeSym0 l = LiftMaybeSym1 l
-    type MapSym2 (t :: TyFun a b -> *) (t :: [a]) = Map t t
-    instance SuppressUnusedWarnings MapSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) MapSym1KindInference GHC.Tuple.())
-    data MapSym1 (l :: TyFun a b -> *) (l :: TyFun [a] [b])
-      = forall arg. KindOf (Apply (MapSym1 l) arg) ~ KindOf (MapSym2 l arg) =>
-        MapSym1KindInference
-    type instance Apply (MapSym1 l) l = MapSym2 l l
-    instance SuppressUnusedWarnings MapSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) MapSym0KindInference GHC.Tuple.())
-    data MapSym0 (l :: TyFun (TyFun a b -> *) (TyFun [a] [b] -> *))
-      = forall arg. KindOf (Apply MapSym0 arg) ~ KindOf (MapSym1 arg) =>
-        MapSym0KindInference
-    type instance Apply MapSym0 l = MapSym1 l
-    type family Foo (a :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
-                    (a :: TyFun a b -> *)
-                    (a :: a) :: b where
-      Foo f g a = Apply (Apply f g) a
-    type family ZipWith (a :: TyFun a (TyFun b c -> *) -> *)
-                        (a :: [a])
-                        (a :: [b]) :: [c] where
-      ZipWith f ((:) x xs) ((:) y ys) = Apply (Apply (:$) (Apply (Apply f x) y)) (Apply (Apply (Apply ZipWithSym0 f) xs) ys)
-      ZipWith z '[] '[] = '[]
-      ZipWith z ((:) z z) '[] = '[]
-      ZipWith z '[] ((:) z z) = '[]
-    type family Splunge (a :: [Nat]) (a :: [Bool]) :: [Nat] where
-      Splunge ns bs = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789Sym0 ns) bs)) ns) bs
-    type family Etad (a :: [Nat]) (a :: [Bool]) :: [Nat] where
-      Etad a_0123456789 a_0123456789 = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789)) a_0123456789) a_0123456789
-    type family LiftMaybe (a :: TyFun a b -> *)
-                          (a :: Maybe a) :: Maybe b where
-      LiftMaybe f (Just x) = Apply JustSym0 (Apply f x)
-      LiftMaybe z Nothing = NothingSym0
-    type family Map (a :: TyFun a b -> *) (a :: [a]) :: [b] where
-      Map z '[] = '[]
-      Map f ((:) h t) = Apply (Apply (:$) (Apply f h)) (Apply (Apply MapSym0 f) t)
-    sFoo ::
-      forall (t :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *)
-             (t :: TyFun a b -> *)
-             (t :: a).
-      Sing t
-      -> Sing t -> Sing t -> Sing (Apply (Apply (Apply FooSym0 t) t) t)
-    sZipWith ::
-      forall (t :: TyFun a (TyFun b c -> *) -> *) (t :: [a]) (t :: [b]).
-      Sing t
-      -> Sing t
-         -> Sing t -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t)
-    sSplunge ::
-      forall (t :: [Nat]) (t :: [Bool]).
-      Sing t -> Sing t -> Sing (Apply (Apply SplungeSym0 t) t)
-    sEtad ::
-      forall (t :: [Nat]) (t :: [Bool]).
-      Sing t -> Sing t -> Sing (Apply (Apply EtadSym0 t) t)
-    sLiftMaybe ::
-      forall (t :: TyFun a b -> *) (t :: Maybe a).
-      Sing t -> Sing t -> Sing (Apply (Apply LiftMaybeSym0 t) t)
-    sMap ::
-      forall (t :: TyFun a b -> *) (t :: [a]).
-      Sing t -> Sing t -> Sing (Apply (Apply MapSym0 t) t)
-    sFoo sF sG sA
-      = let
-          lambda ::
-            forall f g a. (t ~ f, t ~ g, t ~ a) =>
-            Sing f
-            -> Sing g -> Sing a -> Sing (Apply (Apply (Apply FooSym0 f) g) a)
-          lambda f g a = applySing (applySing f g) a
-        in lambda sF sG sA
-    sZipWith sF (SCons sX sXs) (SCons sY sYs)
-      = let
-          lambda ::
-            forall f x xs y ys. (t ~ f,
-                                 t ~ Apply (Apply (:$) x) xs,
-                                 t ~ Apply (Apply (:$) y) ys) =>
-            Sing f
-            -> Sing x
-               -> Sing xs
-                  -> Sing y
-                     -> Sing ys
-                        -> Sing (Apply (Apply (Apply ZipWithSym0 f) (Apply (Apply (:$) x) xs)) (Apply (Apply (:$) y) ys))
-          lambda f x xs y ys
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing (applySing f x) y))
-                (applySing
-                   (applySing
-                      (applySing (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith) f) xs)
-                   ys)
-        in lambda sF sX sXs sY sYs
-    sZipWith _ SNil SNil
-      = let
-          lambda ::
-            forall wild. (t ~ wild, t ~ '[], t ~ '[]) =>
-            Sing (Apply (Apply (Apply ZipWithSym0 wild) '[]) '[])
-          lambda = SNil
-        in lambda
-    sZipWith _ (SCons _ _) SNil
-      = let
-          lambda ::
-            forall wild wild wild. (t ~ wild,
-                                    t ~ Apply (Apply (:$) wild) wild,
-                                    t ~ '[]) =>
-            Sing (Apply (Apply (Apply ZipWithSym0 wild) (Apply (Apply (:$) wild) wild)) '[])
-          lambda = SNil
-        in lambda
-    sZipWith _ SNil (SCons _ _)
-      = let
-          lambda ::
-            forall wild wild wild. (t ~ wild,
-                                    t ~ '[],
-                                    t ~ Apply (Apply (:$) wild) wild) =>
-            Sing (Apply (Apply (Apply ZipWithSym0 wild) '[]) (Apply (Apply (:$) wild) wild))
-          lambda = SNil
-        in lambda
-    sSplunge sNs sBs
-      = let
-          lambda ::
-            forall ns bs. (t ~ ns, t ~ bs) =>
-            Sing ns -> Sing bs -> Sing (Apply (Apply SplungeSym0 ns) bs)
-          lambda ns bs
-            = applySing
-                (applySing
-                   (applySing
-                      (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith)
-                      (singFun2
-                         (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 ns) bs))
-                         (\ sN sB
-                            -> let
-                                 lambda ::
-                                   forall n b.
-                                   Sing n
-                                   -> Sing b
-                                      -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 ns) bs) n) b)
-                                 lambda n b
-                                   = let
-                                       sScrutinee_0123456789 ::
-                                         Sing (Let0123456789Scrutinee_0123456789Sym4 ns bs n b)
-                                       sScrutinee_0123456789 = b
-                                     in
-                                       case sScrutinee_0123456789 of {
-                                         STrue
-                                           -> let
-                                                lambda :: Sing (Case_0123456789 ns bs n b TrueSym0)
-                                                lambda
-                                                  = applySing
-                                                      (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                                                      (applySing
-                                                         (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                                                         n)
-                                              in lambda
-                                         SFalse
-                                           -> let
-                                                lambda :: Sing (Case_0123456789 ns bs n b FalseSym0)
-                                                lambda = n
-                                              in lambda }
-                               in lambda sN sB)))
-                   ns)
-                bs
-        in lambda sNs sBs
-    sEtad sA_0123456789 sA_0123456789
-      = let
-          lambda ::
-            forall a_0123456789 a_0123456789. (t ~ a_0123456789,
-                                               t ~ a_0123456789) =>
-            Sing a_0123456789
-            -> Sing a_0123456789
-               -> Sing (Apply (Apply EtadSym0 a_0123456789) a_0123456789)
-          lambda a_0123456789 a_0123456789
-            = applySing
-                (applySing
-                   (applySing
-                      (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith)
-                      (singFun2
-                         (Proxy ::
-                            Proxy (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789))
-                         (\ sN sB
-                            -> let
-                                 lambda ::
-                                   forall n b.
-                                   Sing n
-                                   -> Sing b
-                                      -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) n) b)
-                                 lambda n b
-                                   = let
-                                       sScrutinee_0123456789 ::
-                                         Sing (Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)
-                                       sScrutinee_0123456789 = b
-                                     in
-                                       case sScrutinee_0123456789 of {
-                                         STrue
-                                           -> let
-                                                lambda ::
-                                                  Sing (Case_0123456789 n b a_0123456789 a_0123456789 TrueSym0)
-                                                lambda
-                                                  = applySing
-                                                      (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                                                      (applySing
-                                                         (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                                                         n)
-                                              in lambda
-                                         SFalse
-                                           -> let
-                                                lambda ::
-                                                  Sing (Case_0123456789 n b a_0123456789 a_0123456789 FalseSym0)
-                                                lambda = n
-                                              in lambda }
-                               in lambda sN sB)))
-                   a_0123456789)
-                a_0123456789
-        in lambda sA_0123456789 sA_0123456789
-    sLiftMaybe sF (SJust sX)
-      = let
-          lambda ::
-            forall f x. (t ~ f, t ~ Apply JustSym0 x) =>
-            Sing f
-            -> Sing x
-               -> Sing (Apply (Apply LiftMaybeSym0 f) (Apply JustSym0 x))
-          lambda f x
-            = applySing
-                (singFun1 (Proxy :: Proxy JustSym0) SJust) (applySing f x)
-        in lambda sF sX
-    sLiftMaybe _ SNothing
-      = let
-          lambda ::
-            forall wild. (t ~ wild, t ~ NothingSym0) =>
-            Sing (Apply (Apply LiftMaybeSym0 wild) NothingSym0)
-          lambda = SNothing
-        in lambda
-    sMap _ SNil
-      = let
-          lambda ::
-            forall wild. (t ~ wild, t ~ '[]) =>
-            Sing (Apply (Apply MapSym0 wild) '[])
-          lambda = SNil
-        in lambda
-    sMap sF (SCons sH sT)
-      = let
-          lambda ::
-            forall f h t. (t ~ f, t ~ Apply (Apply (:$) h) t) =>
-            Sing f
-            -> Sing h
-               -> Sing t
-                  -> Sing (Apply (Apply MapSym0 f) (Apply (Apply (:$) h) t))
-          lambda f h t
-            = applySing
-                (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) (applySing f h))
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy MapSym0) sMap) f) t)
-        in lambda sF sH sT
-    data instance Sing (z :: Either a b)
-      = forall (n :: a). z ~ Left n => SLeft (Sing n) |
-        forall (n :: b). z ~ Right n => SRight (Sing n)
-    type SEither (z :: Either a b) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b)) =>
-             SingKind (KProxy :: KProxy (Either a b)) where
-      type DemoteRep (KProxy :: KProxy (Either a b)) = Either (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
-      fromSing (SLeft b) = Left (fromSing b)
-      fromSing (SRight b) = Right (fromSing b)
-      toSing (Left b)
-        = case toSing b :: SomeSing (KProxy :: KProxy a) of {
-            SomeSing c -> SomeSing (SLeft c) }
-      toSing (Right b)
-        = case toSing b :: SomeSing (KProxy :: KProxy b) of {
-            SomeSing c -> SomeSing (SRight c) }
-    instance SingI n => SingI (Left (n :: a)) where
-      sing = SLeft sing
-    instance SingI n => SingI (Right (n :: b)) where
-      sing = SRight sing
diff --git a/tests/compile-and-dump/Singletons/LambdaCase.ghc710.template b/tests/compile-and-dump/Singletons/LambdaCase.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/LambdaCase.ghc710.template
@@ -0,0 +1,287 @@
+Singletons/LambdaCase.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo1 :: a -> Maybe a -> a
+          foo1 d x
+            = (\case {
+                 Just y -> y
+                 Nothing -> d })
+                x
+          foo2 :: a -> Maybe a -> a
+          foo2 d _
+            = (\case {
+                 Just y -> y
+                 Nothing -> d })
+                (Just d)
+          foo3 :: a -> b -> a
+          foo3 a b = (\case { (p, _) -> p }) (a, b) |]
+  ======>
+    foo1 :: forall a. a -> Maybe a -> a
+    foo1 d x
+      = \case {
+          Just y -> y
+          Nothing -> d }
+          x
+    foo2 :: forall a. a -> Maybe a -> a
+    foo2 d _
+      = \case {
+          Just y -> y
+          Nothing -> d }
+          (Just d)
+    foo3 :: forall a b. a -> b -> a
+    foo3 a b = \case { (p, _) -> p } (a, b)
+    type family Case_0123456789 a b x_0123456789 t where
+      Case_0123456789 a b x_0123456789 '(p, _z_0123456789) = p
+    type family Lambda_0123456789 a b t where
+      Lambda_0123456789 a b x_0123456789 = Case_0123456789 a b x_0123456789 x_0123456789
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 d x_0123456789 _z_0123456789 t where
+      Case_0123456789 d x_0123456789 _z_0123456789 (Just y) = y
+      Case_0123456789 d x_0123456789 _z_0123456789 Nothing = d
+    type family Lambda_0123456789 d _z_0123456789 t where
+      Lambda_0123456789 d _z_0123456789 x_0123456789 = Case_0123456789 d x_0123456789 _z_0123456789 x_0123456789
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 d x x_0123456789 t where
+      Case_0123456789 d x x_0123456789 (Just y) = y
+      Case_0123456789 d x x_0123456789 Nothing = d
+    type family Lambda_0123456789 d x t where
+      Lambda_0123456789 d x x_0123456789 = Case_0123456789 d x x_0123456789 x_0123456789
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type Foo3Sym2 (t :: a) (t :: b) = Foo3 t t
+    instance SuppressUnusedWarnings Foo3Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo3Sym1KindInference GHC.Tuple.())
+    data Foo3Sym1 (l :: a) (l :: TyFun b a)
+      = forall arg. KindOf (Apply (Foo3Sym1 l) arg) ~ KindOf (Foo3Sym2 l arg) =>
+        Foo3Sym1KindInference
+    type instance Apply (Foo3Sym1 l) l = Foo3Sym2 l l
+    instance SuppressUnusedWarnings Foo3Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
+    data Foo3Sym0 (l :: TyFun a (TyFun b a -> *))
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
+        Foo3Sym0KindInference
+    type instance Apply Foo3Sym0 l = Foo3Sym1 l
+    type Foo2Sym2 (t :: a) (t :: Maybe a) = Foo2 t t
+    instance SuppressUnusedWarnings Foo2Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
+    data Foo2Sym1 (l :: a) (l :: TyFun (Maybe a) a)
+      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
+        Foo2Sym1KindInference
+    type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
+    instance SuppressUnusedWarnings Foo2Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
+    data Foo2Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
+      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
+        Foo2Sym0KindInference
+    type instance Apply Foo2Sym0 l = Foo2Sym1 l
+    type Foo1Sym2 (t :: a) (t :: Maybe a) = Foo1 t t
+    instance SuppressUnusedWarnings Foo1Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
+    data Foo1Sym1 (l :: a) (l :: TyFun (Maybe a) a)
+      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
+        Foo1Sym1KindInference
+    type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
+    instance SuppressUnusedWarnings Foo1Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
+    data Foo1Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
+        Foo1Sym0KindInference
+    type instance Apply Foo1Sym0 l = Foo1Sym1 l
+    type family Foo3 (a :: a) (a :: b) :: a where
+      Foo3 a b = Apply (Apply (Apply Lambda_0123456789Sym0 a) b) (Apply (Apply Tuple2Sym0 a) b)
+    type family Foo2 (a :: a) (a :: Maybe a) :: a where
+      Foo2 d _z_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 d) _z_0123456789) (Apply JustSym0 d)
+    type family Foo1 (a :: a) (a :: Maybe a) :: a where
+      Foo1 d x = Apply (Apply (Apply Lambda_0123456789Sym0 d) x) x
+    sFoo3 ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a)
+    sFoo2 ::
+      forall (t :: a) (t :: Maybe a).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)
+    sFoo1 ::
+      forall (t :: a) (t :: Maybe a).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)
+    sFoo3 sA sB
+      = let
+          lambda ::
+            forall a b. (t ~ a, t ~ b) =>
+            Sing a -> Sing b -> Sing (Apply (Apply Foo3Sym0 a) b :: a)
+          lambda a b
+            = applySing
+                (singFun1
+                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 a) b))
+                   (\ sX_0123456789
+                      -> let
+                           lambda ::
+                             forall x_0123456789.
+                             Sing x_0123456789
+                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x_0123456789)
+                           lambda x_0123456789
+                             = case x_0123456789 of {
+                                 STuple2 sP _s_z_0123456789
+                                   -> let
+                                        lambda ::
+                                          forall p
+                                                 _z_0123456789. Apply (Apply Tuple2Sym0 p) _z_0123456789 ~ x_0123456789 =>
+                                          Sing p
+                                          -> Sing _z_0123456789
+                                             -> Sing (Case_0123456789 a b x_0123456789 (Apply (Apply Tuple2Sym0 p) _z_0123456789))
+                                        lambda p _z_0123456789 = p
+                                      in lambda sP _s_z_0123456789 } ::
+                                 Sing (Case_0123456789 a b x_0123456789 x_0123456789)
+                         in lambda sX_0123456789))
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) a) b)
+        in lambda sA sB
+    sFoo2 sD _s_z_0123456789
+      = let
+          lambda ::
+            forall d _z_0123456789. (t ~ d, t ~ _z_0123456789) =>
+            Sing d
+            -> Sing _z_0123456789
+               -> Sing (Apply (Apply Foo2Sym0 d) _z_0123456789 :: a)
+          lambda d _z_0123456789
+            = applySing
+                (singFun1
+                   (Proxy ::
+                      Proxy (Apply (Apply Lambda_0123456789Sym0 d) _z_0123456789))
+                   (\ sX_0123456789
+                      -> let
+                           lambda ::
+                             forall x_0123456789.
+                             Sing x_0123456789
+                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 d) _z_0123456789) x_0123456789)
+                           lambda x_0123456789
+                             = case x_0123456789 of {
+                                 SJust sY
+                                   -> let
+                                        lambda ::
+                                          forall y. Apply JustSym0 y ~ x_0123456789 =>
+                                          Sing y
+                                          -> Sing (Case_0123456789 d x_0123456789 _z_0123456789 (Apply JustSym0 y))
+                                        lambda y = y
+                                      in lambda sY
+                                 SNothing
+                                   -> let
+                                        lambda ::
+                                          NothingSym0 ~ x_0123456789 =>
+                                          Sing (Case_0123456789 d x_0123456789 _z_0123456789 NothingSym0)
+                                        lambda = d
+                                      in lambda } ::
+                                 Sing (Case_0123456789 d x_0123456789 _z_0123456789 x_0123456789)
+                         in lambda sX_0123456789))
+                (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) d)
+        in lambda sD _s_z_0123456789
+    sFoo1 sD sX
+      = let
+          lambda ::
+            forall d x. (t ~ d, t ~ x) =>
+            Sing d -> Sing x -> Sing (Apply (Apply Foo1Sym0 d) x :: a)
+          lambda d x
+            = applySing
+                (singFun1
+                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 d) x))
+                   (\ sX_0123456789
+                      -> let
+                           lambda ::
+                             forall x_0123456789.
+                             Sing x_0123456789
+                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 d) x) x_0123456789)
+                           lambda x_0123456789
+                             = case x_0123456789 of {
+                                 SJust sY
+                                   -> let
+                                        lambda ::
+                                          forall y. Apply JustSym0 y ~ x_0123456789 =>
+                                          Sing y
+                                          -> Sing (Case_0123456789 d x x_0123456789 (Apply JustSym0 y))
+                                        lambda y = y
+                                      in lambda sY
+                                 SNothing
+                                   -> let
+                                        lambda ::
+                                          NothingSym0 ~ x_0123456789 =>
+                                          Sing (Case_0123456789 d x x_0123456789 NothingSym0)
+                                        lambda = d
+                                      in lambda } ::
+                                 Sing (Case_0123456789 d x x_0123456789 x_0123456789)
+                         in lambda sX_0123456789))
+                x
+        in lambda sD sX
diff --git a/tests/compile-and-dump/Singletons/LambdaCase.ghc78.template b/tests/compile-and-dump/Singletons/LambdaCase.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/LambdaCase.ghc78.template
+++ /dev/null
@@ -1,269 +0,0 @@
-Singletons/LambdaCase.hs:0:0: Splicing declarations
-    singletons
-      [d| foo1 :: a -> Maybe a -> a
-          foo1 d x
-            = (\case {
-                 Just y -> y
-                 Nothing -> d })
-                x
-          foo2 :: a -> Maybe a -> a
-          foo2 d _
-            = (\case {
-                 Just y -> y
-                 Nothing -> d })
-                (Just d)
-          foo3 :: a -> b -> a
-          foo3 a b = (\case { (p, _) -> p }) (a, b) |]
-  ======>
-    Singletons/LambdaCase.hs:(0,0)-(0,0)
-    foo1 :: forall a. a -> Maybe a -> a
-    foo1 d x
-      = \case {
-          Just y -> y
-          Nothing -> d }
-          x
-    foo2 :: forall a. a -> Maybe a -> a
-    foo2 d _
-      = \case {
-          Just y -> y
-          Nothing -> d }
-          (Just d)
-    foo3 :: forall a b. a -> b -> a
-    foo3 a b = \case { (p, _) -> p } (a, b)
-    type family Case_0123456789 a b x_0123456789 t where
-      Case_0123456789 a b x_0123456789 '(p, z) = p
-    type family Lambda_0123456789 a b t where
-      Lambda_0123456789 a b x_0123456789 = Case_0123456789 a b x_0123456789 x_0123456789
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 d x_0123456789 t where
-      Case_0123456789 d x_0123456789 (Just y) = y
-      Case_0123456789 d x_0123456789 Nothing = d
-    type family Lambda_0123456789 d t where
-      Lambda_0123456789 d x_0123456789 = Case_0123456789 d x_0123456789 x_0123456789
-    type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 d x x_0123456789 t where
-      Case_0123456789 d x x_0123456789 (Just y) = y
-      Case_0123456789 d x x_0123456789 Nothing = d
-    type family Lambda_0123456789 d x t where
-      Lambda_0123456789 d x x_0123456789 = Case_0123456789 d x x_0123456789 x_0123456789
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type Foo3Sym2 (t :: a) (t :: b) = Foo3 t t
-    instance SuppressUnusedWarnings Foo3Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo3Sym1KindInference GHC.Tuple.())
-    data Foo3Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. KindOf (Apply (Foo3Sym1 l) arg) ~ KindOf (Foo3Sym2 l arg) =>
-        Foo3Sym1KindInference
-    type instance Apply (Foo3Sym1 l) l = Foo3Sym2 l l
-    instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
-    data Foo3Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
-        Foo3Sym0KindInference
-    type instance Apply Foo3Sym0 l = Foo3Sym1 l
-    type Foo2Sym2 (t :: a) (t :: Maybe a) = Foo2 t t
-    instance SuppressUnusedWarnings Foo2Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
-    data Foo2Sym1 (l :: a) (l :: TyFun (Maybe a) a)
-      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
-        Foo2Sym1KindInference
-    type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
-    instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
-    data Foo2Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
-      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
-        Foo2Sym0KindInference
-    type instance Apply Foo2Sym0 l = Foo2Sym1 l
-    type Foo1Sym2 (t :: a) (t :: Maybe a) = Foo1 t t
-    instance SuppressUnusedWarnings Foo1Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
-    data Foo1Sym1 (l :: a) (l :: TyFun (Maybe a) a)
-      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
-        Foo1Sym1KindInference
-    type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
-    instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
-    data Foo1Sym0 (l :: TyFun a (TyFun (Maybe a) a -> *))
-      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
-        Foo1Sym0KindInference
-    type instance Apply Foo1Sym0 l = Foo1Sym1 l
-    type family Foo3 (a :: a) (a :: b) :: a where
-      Foo3 a b = Apply (Apply (Apply Lambda_0123456789Sym0 a) b) (Apply (Apply Tuple2Sym0 a) b)
-    type family Foo2 (a :: a) (a :: Maybe a) :: a where
-      Foo2 d z = Apply (Apply Lambda_0123456789Sym0 d) (Apply JustSym0 d)
-    type family Foo1 (a :: a) (a :: Maybe a) :: a where
-      Foo1 d x = Apply (Apply (Apply Lambda_0123456789Sym0 d) x) x
-    sFoo3 ::
-      forall (t :: a) (t :: b).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t)
-    sFoo2 ::
-      forall (t :: a) (t :: Maybe a).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t)
-    sFoo1 ::
-      forall (t :: a) (t :: Maybe a).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t)
-    sFoo3 sA sB
-      = let
-          lambda ::
-            forall a b. (t ~ a, t ~ b) =>
-            Sing a -> Sing b -> Sing (Apply (Apply Foo3Sym0 a) b)
-          lambda a b
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 a) b))
-                   (\ sX_0123456789
-                      -> let
-                           lambda ::
-                             forall x_0123456789.
-                             Sing x_0123456789
-                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x_0123456789)
-                           lambda x_0123456789
-                             = case x_0123456789 of {
-                                 STuple2 sP _
-                                   -> let
-                                        lambda ::
-                                          forall p wild.
-                                          Sing p
-                                          -> Sing (Case_0123456789 a b x_0123456789 (Apply (Apply Tuple2Sym0 p) wild))
-                                        lambda p = p
-                                      in lambda sP }
-                         in lambda sX_0123456789))
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) a) b)
-        in lambda sA sB
-    sFoo2 sD _
-      = let
-          lambda ::
-            forall d wild. (t ~ d, t ~ wild) =>
-            Sing d -> Sing (Apply (Apply Foo2Sym0 d) wild)
-          lambda d
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply Lambda_0123456789Sym0 d))
-                   (\ sX_0123456789
-                      -> let
-                           lambda ::
-                             forall x_0123456789.
-                             Sing x_0123456789
-                             -> Sing (Apply (Apply Lambda_0123456789Sym0 d) x_0123456789)
-                           lambda x_0123456789
-                             = case x_0123456789 of {
-                                 SJust sY
-                                   -> let
-                                        lambda ::
-                                          forall y.
-                                          Sing y
-                                          -> Sing (Case_0123456789 d x_0123456789 (Apply JustSym0 y))
-                                        lambda y = y
-                                      in lambda sY
-                                 SNothing
-                                   -> let
-                                        lambda :: Sing (Case_0123456789 d x_0123456789 NothingSym0)
-                                        lambda = d
-                                      in lambda }
-                         in lambda sX_0123456789))
-                (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) d)
-        in lambda sD
-    sFoo1 sD sX
-      = let
-          lambda ::
-            forall d x. (t ~ d, t ~ x) =>
-            Sing d -> Sing x -> Sing (Apply (Apply Foo1Sym0 d) x)
-          lambda d x
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 d) x))
-                   (\ sX_0123456789
-                      -> let
-                           lambda ::
-                             forall x_0123456789.
-                             Sing x_0123456789
-                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 d) x) x_0123456789)
-                           lambda x_0123456789
-                             = case x_0123456789 of {
-                                 SJust sY
-                                   -> let
-                                        lambda ::
-                                          forall y.
-                                          Sing y
-                                          -> Sing (Case_0123456789 d x x_0123456789 (Apply JustSym0 y))
-                                        lambda y = y
-                                      in lambda sY
-                                 SNothing
-                                   -> let
-                                        lambda ::
-                                          Sing (Case_0123456789 d x x_0123456789 NothingSym0)
-                                        lambda = d
-                                      in lambda }
-                         in lambda sX_0123456789))
-                x
-        in lambda sD sX
diff --git a/tests/compile-and-dump/Singletons/Lambdas.ghc710.template b/tests/compile-and-dump/Singletons/Lambdas.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Lambdas.ghc710.template
@@ -0,0 +1,816 @@
+Singletons/Lambdas.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo0 :: a -> b -> a
+          foo0 = (\ x y -> x)
+          foo1 :: a -> b -> a
+          foo1 x = (\ _ -> x)
+          foo2 :: a -> b -> a
+          foo2 x y = (\ _ -> x) y
+          foo3 :: a -> a
+          foo3 x = (\ y -> y) x
+          foo4 :: a -> b -> c -> a
+          foo4 x y z = (\ _ _ -> x) y z
+          foo5 :: a -> b -> b
+          foo5 x y = (\ x -> x) y
+          foo6 :: a -> b -> a
+          foo6 a b = (\ x -> \ _ -> x) a b
+          foo7 :: a -> b -> b
+          foo7 x y = (\ (_, b) -> b) (x, y)
+          foo8 :: Foo a b -> a
+          foo8 x = (\ (Foo a _) -> a) x
+          
+          data Foo a b = Foo a b |]
+  ======>
+    foo0 :: forall a b. a -> b -> a
+    foo0 = \ x y -> x
+    foo1 :: forall a b. a -> b -> a
+    foo1 x = \ _ -> x
+    foo2 :: forall a b. a -> b -> a
+    foo2 x y = \ _ -> x y
+    foo3 :: forall a. a -> a
+    foo3 x = \ y -> y x
+    foo4 :: forall a b c. a -> b -> c -> a
+    foo4 x y z = \ _ _ -> x y z
+    foo5 :: forall a b. a -> b -> b
+    foo5 x y = \ x -> x y
+    foo6 :: forall a b. a -> b -> a
+    foo6 a b = \ x -> \ _ -> x a b
+    foo7 :: forall a b. a -> b -> b
+    foo7 x y = \ (_, b) -> b (x, y)
+    data Foo a b = Foo a b
+    foo8 :: forall a b. Foo a b -> a
+    foo8 x = \ (Foo a _) -> a x
+    type FooSym2 (t :: a) (t :: b) = Foo t t
+    instance SuppressUnusedWarnings FooSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym1KindInference GHC.Tuple.())
+    data FooSym1 (l :: a) (l :: TyFun b (Foo a b))
+      = forall arg. KindOf (Apply (FooSym1 l) arg) ~ KindOf (FooSym2 l arg) =>
+        FooSym1KindInference
+    type instance Apply (FooSym1 l) l = FooSym2 l l
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun a (TyFun b (Foo a b) -> *))
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type family Case_0123456789 x arg_0123456789 t where
+      Case_0123456789 x arg_0123456789 (Foo a _z_0123456789) = a
+    type family Lambda_0123456789 x t where
+      Lambda_0123456789 x arg_0123456789 = Case_0123456789 x arg_0123456789 arg_0123456789
+    type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 x y arg_0123456789 t where
+      Case_0123456789 x y arg_0123456789 '(_z_0123456789, b) = b
+    type family Lambda_0123456789 x y t where
+      Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 a b x arg_0123456789 t where
+      Case_0123456789 a b x arg_0123456789 _z_0123456789 = x
+    type family Lambda_0123456789 a b x t where
+      Lambda_0123456789 a b x arg_0123456789 = Case_0123456789 a b x arg_0123456789 arg_0123456789
+    type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
+        Lambda_0123456789Sym3KindInference
+    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Lambda_0123456789 a b t where
+      Lambda_0123456789 a b x = Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Lambda_0123456789 x y t where
+      Lambda_0123456789 x y x = x
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 x
+                                y
+                                z
+                                arg_0123456789
+                                arg_0123456789
+                                t where
+      Case_0123456789 x y z arg_0123456789 arg_0123456789 '(_z_0123456789,
+                                                            _z_0123456789) = x
+    type family Lambda_0123456789 x y z t t where
+      Lambda_0123456789 x y z arg_0123456789 arg_0123456789 = Case_0123456789 x y z arg_0123456789 arg_0123456789 (Apply (Apply Tuple2Sym0 arg_0123456789) arg_0123456789)
+    type Lambda_0123456789Sym5 t t t t t = Lambda_0123456789 t t t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym4 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym4KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym4 l l l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg) ~ KindOf (Lambda_0123456789Sym5 l l l l arg) =>
+        Lambda_0123456789Sym4KindInference
+    type instance Apply (Lambda_0123456789Sym4 l l l l) l = Lambda_0123456789Sym5 l l l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
+        Lambda_0123456789Sym3KindInference
+    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Lambda_0123456789 x t where
+      Lambda_0123456789 x y = y
+    type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 x y arg_0123456789 t where
+      Case_0123456789 x y arg_0123456789 _z_0123456789 = x
+    type family Lambda_0123456789 x y t where
+      Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 x arg_0123456789 a_0123456789 t where
+      Case_0123456789 x arg_0123456789 a_0123456789 _z_0123456789 = x
+    type family Lambda_0123456789 x a_0123456789 t where
+      Lambda_0123456789 x a_0123456789 arg_0123456789 = Case_0123456789 x arg_0123456789 a_0123456789 arg_0123456789
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Lambda_0123456789 a_0123456789 a_0123456789 t t where
+      Lambda_0123456789 a_0123456789 a_0123456789 x y = x
+    type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
+        Lambda_0123456789Sym3KindInference
+    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type Foo8Sym1 (t :: Foo a b) = Foo8 t
+    instance SuppressUnusedWarnings Foo8Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo8Sym0KindInference GHC.Tuple.())
+    data Foo8Sym0 (l :: TyFun (Foo a b) a)
+      = forall arg. KindOf (Apply Foo8Sym0 arg) ~ KindOf (Foo8Sym1 arg) =>
+        Foo8Sym0KindInference
+    type instance Apply Foo8Sym0 l = Foo8Sym1 l
+    type Foo7Sym2 (t :: a) (t :: b) = Foo7 t t
+    instance SuppressUnusedWarnings Foo7Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo7Sym1KindInference GHC.Tuple.())
+    data Foo7Sym1 (l :: a) (l :: TyFun b b)
+      = forall arg. KindOf (Apply (Foo7Sym1 l) arg) ~ KindOf (Foo7Sym2 l arg) =>
+        Foo7Sym1KindInference
+    type instance Apply (Foo7Sym1 l) l = Foo7Sym2 l l
+    instance SuppressUnusedWarnings Foo7Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo7Sym0KindInference GHC.Tuple.())
+    data Foo7Sym0 (l :: TyFun a (TyFun b b -> *))
+      = forall arg. KindOf (Apply Foo7Sym0 arg) ~ KindOf (Foo7Sym1 arg) =>
+        Foo7Sym0KindInference
+    type instance Apply Foo7Sym0 l = Foo7Sym1 l
+    type Foo6Sym2 (t :: a) (t :: b) = Foo6 t t
+    instance SuppressUnusedWarnings Foo6Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo6Sym1KindInference GHC.Tuple.())
+    data Foo6Sym1 (l :: a) (l :: TyFun b a)
+      = forall arg. KindOf (Apply (Foo6Sym1 l) arg) ~ KindOf (Foo6Sym2 l arg) =>
+        Foo6Sym1KindInference
+    type instance Apply (Foo6Sym1 l) l = Foo6Sym2 l l
+    instance SuppressUnusedWarnings Foo6Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo6Sym0KindInference GHC.Tuple.())
+    data Foo6Sym0 (l :: TyFun a (TyFun b a -> *))
+      = forall arg. KindOf (Apply Foo6Sym0 arg) ~ KindOf (Foo6Sym1 arg) =>
+        Foo6Sym0KindInference
+    type instance Apply Foo6Sym0 l = Foo6Sym1 l
+    type Foo5Sym2 (t :: a) (t :: b) = Foo5 t t
+    instance SuppressUnusedWarnings Foo5Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo5Sym1KindInference GHC.Tuple.())
+    data Foo5Sym1 (l :: a) (l :: TyFun b b)
+      = forall arg. KindOf (Apply (Foo5Sym1 l) arg) ~ KindOf (Foo5Sym2 l arg) =>
+        Foo5Sym1KindInference
+    type instance Apply (Foo5Sym1 l) l = Foo5Sym2 l l
+    instance SuppressUnusedWarnings Foo5Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
+    data Foo5Sym0 (l :: TyFun a (TyFun b b -> *))
+      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
+        Foo5Sym0KindInference
+    type instance Apply Foo5Sym0 l = Foo5Sym1 l
+    type Foo4Sym3 (t :: a) (t :: b) (t :: c) = Foo4 t t t
+    instance SuppressUnusedWarnings Foo4Sym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo4Sym2KindInference GHC.Tuple.())
+    data Foo4Sym2 (l :: a) (l :: b) (l :: TyFun c a)
+      = forall arg. KindOf (Apply (Foo4Sym2 l l) arg) ~ KindOf (Foo4Sym3 l l arg) =>
+        Foo4Sym2KindInference
+    type instance Apply (Foo4Sym2 l l) l = Foo4Sym3 l l l
+    instance SuppressUnusedWarnings Foo4Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo4Sym1KindInference GHC.Tuple.())
+    data Foo4Sym1 (l :: a) (l :: TyFun b (TyFun c a -> *))
+      = forall arg. KindOf (Apply (Foo4Sym1 l) arg) ~ KindOf (Foo4Sym2 l arg) =>
+        Foo4Sym1KindInference
+    type instance Apply (Foo4Sym1 l) l = Foo4Sym2 l l
+    instance SuppressUnusedWarnings Foo4Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
+    data Foo4Sym0 (l :: TyFun a (TyFun b (TyFun c a -> *) -> *))
+      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
+        Foo4Sym0KindInference
+    type instance Apply Foo4Sym0 l = Foo4Sym1 l
+    type Foo3Sym1 (t :: a) = Foo3 t
+    instance SuppressUnusedWarnings Foo3Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
+    data Foo3Sym0 (l :: TyFun a a)
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
+        Foo3Sym0KindInference
+    type instance Apply Foo3Sym0 l = Foo3Sym1 l
+    type Foo2Sym2 (t :: a) (t :: b) = Foo2 t t
+    instance SuppressUnusedWarnings Foo2Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
+    data Foo2Sym1 (l :: a) (l :: TyFun b a)
+      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
+        Foo2Sym1KindInference
+    type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
+    instance SuppressUnusedWarnings Foo2Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
+    data Foo2Sym0 (l :: TyFun a (TyFun b a -> *))
+      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
+        Foo2Sym0KindInference
+    type instance Apply Foo2Sym0 l = Foo2Sym1 l
+    type Foo1Sym2 (t :: a) (t :: b) = Foo1 t t
+    instance SuppressUnusedWarnings Foo1Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
+    data Foo1Sym1 (l :: a) (l :: TyFun b a)
+      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
+        Foo1Sym1KindInference
+    type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
+    instance SuppressUnusedWarnings Foo1Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
+    data Foo1Sym0 (l :: TyFun a (TyFun b a -> *))
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
+        Foo1Sym0KindInference
+    type instance Apply Foo1Sym0 l = Foo1Sym1 l
+    type Foo0Sym2 (t :: a) (t :: b) = Foo0 t t
+    instance SuppressUnusedWarnings Foo0Sym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo0Sym1KindInference GHC.Tuple.())
+    data Foo0Sym1 (l :: a) (l :: TyFun b a)
+      = forall arg. KindOf (Apply (Foo0Sym1 l) arg) ~ KindOf (Foo0Sym2 l arg) =>
+        Foo0Sym1KindInference
+    type instance Apply (Foo0Sym1 l) l = Foo0Sym2 l l
+    instance SuppressUnusedWarnings Foo0Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo0Sym0KindInference GHC.Tuple.())
+    data Foo0Sym0 (l :: TyFun a (TyFun b a -> *))
+      = forall arg. KindOf (Apply Foo0Sym0 arg) ~ KindOf (Foo0Sym1 arg) =>
+        Foo0Sym0KindInference
+    type instance Apply Foo0Sym0 l = Foo0Sym1 l
+    type family Foo8 (a :: Foo a b) :: a where
+      Foo8 x = Apply (Apply Lambda_0123456789Sym0 x) x
+    type family Foo7 (a :: a) (a :: b) :: b where
+      Foo7 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) (Apply (Apply Tuple2Sym0 x) y)
+    type family Foo6 (a :: a) (a :: b) :: a where
+      Foo6 a b = Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) a) b
+    type family Foo5 (a :: a) (a :: b) :: b where
+      Foo5 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y
+    type family Foo4 (a :: a) (a :: b) (a :: c) :: a where
+      Foo4 x y z = Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z) y) z
+    type family Foo3 (a :: a) :: a where
+      Foo3 x = Apply (Apply Lambda_0123456789Sym0 x) x
+    type family Foo2 (a :: a) (a :: b) :: a where
+      Foo2 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y
+    type family Foo1 (a :: a) (a :: b) :: a where
+      Foo1 x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789
+    type family Foo0 (a :: a) (a :: b) :: a where
+      Foo0 a_0123456789 a_0123456789 = Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789
+    sFoo8 ::
+      forall (t :: Foo a b). Sing t -> Sing (Apply Foo8Sym0 t :: a)
+    sFoo7 ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: b)
+    sFoo6 ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t :: a)
+    sFoo5 ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t :: b)
+    sFoo4 ::
+      forall (t :: a) (t :: b) (t :: c).
+      Sing t
+      -> Sing t
+         -> Sing t -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a)
+    sFoo3 :: forall (t :: a). Sing t -> Sing (Apply Foo3Sym0 t :: a)
+    sFoo2 ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)
+    sFoo1 ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)
+    sFoo0 ::
+      forall (t :: a) (t :: b).
+      Sing t -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t :: a)
+    sFoo8 sX
+      = let
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 x :: a)
+          lambda x
+            = applySing
+                (singFun1
+                   (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x))
+                   (\ sArg_0123456789
+                      -> let
+                           lambda ::
+                             forall arg_0123456789.
+                             Sing arg_0123456789
+                             -> Sing (Apply (Apply Lambda_0123456789Sym0 x) arg_0123456789)
+                           lambda arg_0123456789
+                             = case arg_0123456789 of {
+                                 SFoo sA _s_z_0123456789
+                                   -> let
+                                        lambda ::
+                                          forall a
+                                                 _z_0123456789. Apply (Apply FooSym0 a) _z_0123456789 ~ arg_0123456789 =>
+                                          Sing a
+                                          -> Sing _z_0123456789
+                                             -> Sing (Case_0123456789 x arg_0123456789 (Apply (Apply FooSym0 a) _z_0123456789))
+                                        lambda a _z_0123456789 = a
+                                      in lambda sA _s_z_0123456789 } ::
+                                 Sing (Case_0123456789 x arg_0123456789 arg_0123456789)
+                         in lambda sArg_0123456789))
+                x
+        in lambda sX
+    sFoo7 sX sY
+      = let
+          lambda ::
+            forall x y. (t ~ x, t ~ y) =>
+            Sing x -> Sing y -> Sing (Apply (Apply Foo7Sym0 x) y :: b)
+          lambda x y
+            = applySing
+                (singFun1
+                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
+                   (\ sArg_0123456789
+                      -> let
+                           lambda ::
+                             forall arg_0123456789.
+                             Sing arg_0123456789
+                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789)
+                           lambda arg_0123456789
+                             = case arg_0123456789 of {
+                                 STuple2 _s_z_0123456789 sB
+                                   -> let
+                                        lambda ::
+                                          forall _z_0123456789
+                                                 b. Apply (Apply Tuple2Sym0 _z_0123456789) b ~ arg_0123456789 =>
+                                          Sing _z_0123456789
+                                          -> Sing b
+                                             -> Sing (Case_0123456789 x y arg_0123456789 (Apply (Apply Tuple2Sym0 _z_0123456789) b))
+                                        lambda _z_0123456789 b = b
+                                      in lambda _s_z_0123456789 sB } ::
+                                 Sing (Case_0123456789 x y arg_0123456789 arg_0123456789)
+                         in lambda sArg_0123456789))
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) x) y)
+        in lambda sX sY
+    sFoo6 sA sB
+      = let
+          lambda ::
+            forall a b. (t ~ a, t ~ b) =>
+            Sing a -> Sing b -> Sing (Apply (Apply Foo6Sym0 a) b :: a)
+          lambda a b
+            = applySing
+                (applySing
+                   (singFun1
+                      (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 a) b))
+                      (\ sX
+                         -> let
+                              lambda ::
+                                forall x.
+                                Sing x -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x)
+                              lambda x
+                                = singFun1
+                                    (Proxy ::
+                                       Proxy (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x))
+                                    (\ sArg_0123456789
+                                       -> let
+                                            lambda ::
+                                              forall arg_0123456789.
+                                              Sing arg_0123456789
+                                              -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x) arg_0123456789)
+                                            lambda arg_0123456789
+                                              = case arg_0123456789 of {
+                                                  _s_z_0123456789
+                                                    -> let
+                                                         lambda ::
+                                                           forall _z_0123456789. _z_0123456789 ~ arg_0123456789 =>
+                                                           Sing _z_0123456789
+                                                           -> Sing (Case_0123456789 a b x arg_0123456789 _z_0123456789)
+                                                         lambda _z_0123456789 = x
+                                                       in lambda _s_z_0123456789 } ::
+                                                  Sing (Case_0123456789 a b x arg_0123456789 arg_0123456789)
+                                          in lambda sArg_0123456789)
+                            in lambda sX))
+                   a)
+                b
+        in lambda sA sB
+    sFoo5 sX sY
+      = let
+          lambda ::
+            forall x y. (t ~ x, t ~ y) =>
+            Sing x -> Sing y -> Sing (Apply (Apply Foo5Sym0 x) y :: b)
+          lambda x y
+            = applySing
+                (singFun1
+                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
+                   (\ sX
+                      -> let
+                           lambda ::
+                             forall x.
+                             Sing x -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) x)
+                           lambda x = x
+                         in lambda sX))
+                y
+        in lambda sX sY
+    sFoo4 sX sY sZ
+      = let
+          lambda ::
+            forall x y z. (t ~ x, t ~ y, t ~ z) =>
+            Sing x
+            -> Sing y
+               -> Sing z -> Sing (Apply (Apply (Apply Foo4Sym0 x) y) z :: a)
+          lambda x y z
+            = applySing
+                (applySing
+                   (singFun2
+                      (Proxy ::
+                         Proxy (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z))
+                      (\ sArg_0123456789 sArg_0123456789
+                         -> let
+                              lambda ::
+                                forall arg_0123456789 arg_0123456789.
+                                Sing arg_0123456789
+                                -> Sing arg_0123456789
+                                   -> Sing (Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z) arg_0123456789) arg_0123456789)
+                              lambda arg_0123456789 arg_0123456789
+                                = case
+                                      applySing
+                                        (applySing
+                                           (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2)
+                                           arg_0123456789)
+                                        arg_0123456789
+                                  of {
+                                    STuple2 _s_z_0123456789 _s_z_0123456789
+                                      -> let
+                                           lambda ::
+                                             forall _z_0123456789
+                                                    _z_0123456789. Apply (Apply Tuple2Sym0 _z_0123456789) _z_0123456789 ~ Apply (Apply Tuple2Sym0 arg_0123456789) arg_0123456789 =>
+                                             Sing _z_0123456789
+                                             -> Sing _z_0123456789
+                                                -> Sing (Case_0123456789 x y z arg_0123456789 arg_0123456789 (Apply (Apply Tuple2Sym0 _z_0123456789) _z_0123456789))
+                                           lambda _z_0123456789 _z_0123456789 = x
+                                         in lambda _s_z_0123456789 _s_z_0123456789 } ::
+                                    Sing (Case_0123456789 x y z arg_0123456789 arg_0123456789 (Apply (Apply Tuple2Sym0 arg_0123456789) arg_0123456789))
+                            in lambda sArg_0123456789 sArg_0123456789))
+                   y)
+                z
+        in lambda sX sY sZ
+    sFoo3 sX
+      = let
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 x :: a)
+          lambda x
+            = applySing
+                (singFun1
+                   (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x))
+                   (\ sY
+                      -> let
+                           lambda ::
+                             forall y. Sing y -> Sing (Apply (Apply Lambda_0123456789Sym0 x) y)
+                           lambda y = y
+                         in lambda sY))
+                x
+        in lambda sX
+    sFoo2 sX sY
+      = let
+          lambda ::
+            forall x y. (t ~ x, t ~ y) =>
+            Sing x -> Sing y -> Sing (Apply (Apply Foo2Sym0 x) y :: a)
+          lambda x y
+            = applySing
+                (singFun1
+                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
+                   (\ sArg_0123456789
+                      -> let
+                           lambda ::
+                             forall arg_0123456789.
+                             Sing arg_0123456789
+                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789)
+                           lambda arg_0123456789
+                             = case arg_0123456789 of {
+                                 _s_z_0123456789
+                                   -> let
+                                        lambda ::
+                                          forall _z_0123456789. _z_0123456789 ~ arg_0123456789 =>
+                                          Sing _z_0123456789
+                                          -> Sing (Case_0123456789 x y arg_0123456789 _z_0123456789)
+                                        lambda _z_0123456789 = x
+                                      in lambda _s_z_0123456789 } ::
+                                 Sing (Case_0123456789 x y arg_0123456789 arg_0123456789)
+                         in lambda sArg_0123456789))
+                y
+        in lambda sX sY
+    sFoo1 sX sA_0123456789
+      = let
+          lambda ::
+            forall x a_0123456789. (t ~ x, t ~ a_0123456789) =>
+            Sing x
+            -> Sing a_0123456789
+               -> Sing (Apply (Apply Foo1Sym0 x) a_0123456789 :: a)
+          lambda x a_0123456789
+            = applySing
+                (singFun1
+                   (Proxy ::
+                      Proxy (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789))
+                   (\ sArg_0123456789
+                      -> let
+                           lambda ::
+                             forall arg_0123456789.
+                             Sing arg_0123456789
+                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) arg_0123456789)
+                           lambda arg_0123456789
+                             = case arg_0123456789 of {
+                                 _s_z_0123456789
+                                   -> let
+                                        lambda ::
+                                          forall _z_0123456789. _z_0123456789 ~ arg_0123456789 =>
+                                          Sing _z_0123456789
+                                          -> Sing (Case_0123456789 x arg_0123456789 a_0123456789 _z_0123456789)
+                                        lambda _z_0123456789 = x
+                                      in lambda _s_z_0123456789 } ::
+                                 Sing (Case_0123456789 x arg_0123456789 a_0123456789 arg_0123456789)
+                         in lambda sArg_0123456789))
+                a_0123456789
+        in lambda sX sA_0123456789
+    sFoo0 sA_0123456789 sA_0123456789
+      = let
+          lambda ::
+            forall a_0123456789 a_0123456789. (t ~ a_0123456789,
+                                               t ~ a_0123456789) =>
+            Sing a_0123456789
+            -> Sing a_0123456789
+               -> Sing (Apply (Apply Foo0Sym0 a_0123456789) a_0123456789 :: a)
+          lambda a_0123456789 a_0123456789
+            = applySing
+                (applySing
+                   (singFun2
+                      (Proxy ::
+                         Proxy (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789))
+                      (\ sX sY
+                         -> let
+                              lambda ::
+                                forall x y.
+                                Sing x
+                                -> Sing y
+                                   -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) x) y)
+                              lambda x y = x
+                            in lambda sX sY))
+                   a_0123456789)
+                a_0123456789
+        in lambda sA_0123456789 sA_0123456789
+    data instance Sing (z :: Foo a b)
+      = forall (n :: a) (n :: b). z ~ Foo n n =>
+        SFoo (Sing (n :: a)) (Sing (n :: b))
+    type SFoo = (Sing :: Foo a b -> *)
+    instance (SingKind (KProxy :: KProxy a),
+              SingKind (KProxy :: KProxy b)) =>
+             SingKind (KProxy :: KProxy (Foo a b)) where
+      type DemoteRep (KProxy :: KProxy (Foo a b)) = Foo (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
+      fromSing (SFoo b b) = Foo (fromSing b) (fromSing b)
+      toSing (Foo b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SFoo c c) }
+    instance (SingI n, SingI n) => SingI (Foo (n :: a) (n :: b)) where
+      sing = SFoo sing sing
diff --git a/tests/compile-and-dump/Singletons/Lambdas.ghc78.template b/tests/compile-and-dump/Singletons/Lambdas.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Lambdas.ghc78.template
+++ /dev/null
@@ -1,793 +0,0 @@
-Singletons/Lambdas.hs:0:0: Splicing declarations
-    singletons
-      [d| foo0 :: a -> b -> a
-          foo0 = (\ x y -> x)
-          foo1 :: a -> b -> a
-          foo1 x = (\ _ -> x)
-          foo2 :: a -> b -> a
-          foo2 x y = (\ _ -> x) y
-          foo3 :: a -> a
-          foo3 x = (\ y -> y) x
-          foo4 :: a -> b -> c -> a
-          foo4 x y z = (\ _ _ -> x) y z
-          foo5 :: a -> b -> b
-          foo5 x y = (\ x -> x) y
-          foo6 :: a -> b -> a
-          foo6 a b = (\ x -> \ _ -> x) a b
-          foo7 :: a -> b -> b
-          foo7 x y = (\ (_, b) -> b) (x, y)
-          foo8 :: Foo a b -> a
-          foo8 x = (\ (Foo a _) -> a) x
-          
-          data Foo a b = Foo a b |]
-  ======>
-    Singletons/Lambdas.hs:(0,0)-(0,0)
-    foo0 :: forall a b. a -> b -> a
-    foo0 = \ x y -> x
-    foo1 :: forall a b. a -> b -> a
-    foo1 x = \ _ -> x
-    foo2 :: forall a b. a -> b -> a
-    foo2 x y = \ _ -> x y
-    foo3 :: forall a. a -> a
-    foo3 x = \ y -> y x
-    foo4 :: forall a b c. a -> b -> c -> a
-    foo4 x y z = \ _ _ -> x y z
-    foo5 :: forall a b. a -> b -> b
-    foo5 x y = \ x -> x y
-    foo6 :: forall a b. a -> b -> a
-    foo6 a b = \ x -> \ _ -> x a b
-    foo7 :: forall a b. a -> b -> b
-    foo7 x y = \ (_, b) -> b (x, y)
-    data Foo a b = Foo a b
-    foo8 :: forall a b. Foo a b -> a
-    foo8 x = \ (Foo a _) -> a x
-    type FooSym2 (t :: a) (t :: b) = Foo t t
-    instance SuppressUnusedWarnings FooSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym1KindInference GHC.Tuple.())
-    data FooSym1 (l :: a) (l :: TyFun b (Foo a b))
-      = forall arg. KindOf (Apply (FooSym1 l) arg) ~ KindOf (FooSym2 l arg) =>
-        FooSym1KindInference
-    type instance Apply (FooSym1 l) l = FooSym2 l l
-    instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
-    data FooSym0 (l :: TyFun a (TyFun b (Foo a b) -> *))
-      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
-        FooSym0KindInference
-    type instance Apply FooSym0 l = FooSym1 l
-    type family Case_0123456789 x arg_0123456789 t where
-      Case_0123456789 x arg_0123456789 (Foo a z) = a
-    type family Lambda_0123456789 x t where
-      Lambda_0123456789 x arg_0123456789 = Case_0123456789 x arg_0123456789 arg_0123456789
-    type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 x y arg_0123456789 t where
-      Case_0123456789 x y arg_0123456789 '(z, b) = b
-    type family Lambda_0123456789 x y t where
-      Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 a b x arg_0123456789 t where
-      Case_0123456789 a b x arg_0123456789 z = x
-    type family Lambda_0123456789 a b x t where
-      Lambda_0123456789 a b x arg_0123456789 = Case_0123456789 a b x arg_0123456789 arg_0123456789
-    type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
-        Lambda_0123456789Sym3KindInference
-    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Lambda_0123456789 a b t where
-      Lambda_0123456789 a b x = Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Lambda_0123456789 x y t where
-      Lambda_0123456789 x y x = x
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 x
-                                y
-                                z
-                                arg_0123456789
-                                arg_0123456789
-                                t where
-      Case_0123456789 x y z arg_0123456789 arg_0123456789 '(z, z) = x
-    type family Lambda_0123456789 x y z t t where
-      Lambda_0123456789 x y z arg_0123456789 arg_0123456789 = Case_0123456789 x y z arg_0123456789 arg_0123456789 (Apply (Apply Tuple2Sym0 arg_0123456789) arg_0123456789)
-    type Lambda_0123456789Sym5 t t t t t = Lambda_0123456789 t t t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym4 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym4KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym4 l l l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg) ~ KindOf (Lambda_0123456789Sym5 l l l l arg) =>
-        Lambda_0123456789Sym4KindInference
-    type instance Apply (Lambda_0123456789Sym4 l l l l) l = Lambda_0123456789Sym5 l l l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
-        Lambda_0123456789Sym3KindInference
-    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Lambda_0123456789 x t where
-      Lambda_0123456789 x y = y
-    type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 x y arg_0123456789 t where
-      Case_0123456789 x y arg_0123456789 z = x
-    type family Lambda_0123456789 x y t where
-      Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 x arg_0123456789 a_0123456789 t where
-      Case_0123456789 x arg_0123456789 a_0123456789 z = x
-    type family Lambda_0123456789 x a_0123456789 t where
-      Lambda_0123456789 x a_0123456789 arg_0123456789 = Case_0123456789 x arg_0123456789 a_0123456789 arg_0123456789
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Lambda_0123456789 a_0123456789 a_0123456789 t t where
-      Lambda_0123456789 a_0123456789 a_0123456789 x y = x
-    type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
-        Lambda_0123456789Sym3KindInference
-    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type Foo8Sym1 (t :: Foo a b) = Foo8 t
-    instance SuppressUnusedWarnings Foo8Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo8Sym0KindInference GHC.Tuple.())
-    data Foo8Sym0 (l :: TyFun (Foo a b) a)
-      = forall arg. KindOf (Apply Foo8Sym0 arg) ~ KindOf (Foo8Sym1 arg) =>
-        Foo8Sym0KindInference
-    type instance Apply Foo8Sym0 l = Foo8Sym1 l
-    type Foo7Sym2 (t :: a) (t :: b) = Foo7 t t
-    instance SuppressUnusedWarnings Foo7Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo7Sym1KindInference GHC.Tuple.())
-    data Foo7Sym1 (l :: a) (l :: TyFun b b)
-      = forall arg. KindOf (Apply (Foo7Sym1 l) arg) ~ KindOf (Foo7Sym2 l arg) =>
-        Foo7Sym1KindInference
-    type instance Apply (Foo7Sym1 l) l = Foo7Sym2 l l
-    instance SuppressUnusedWarnings Foo7Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo7Sym0KindInference GHC.Tuple.())
-    data Foo7Sym0 (l :: TyFun a (TyFun b b -> *))
-      = forall arg. KindOf (Apply Foo7Sym0 arg) ~ KindOf (Foo7Sym1 arg) =>
-        Foo7Sym0KindInference
-    type instance Apply Foo7Sym0 l = Foo7Sym1 l
-    type Foo6Sym2 (t :: a) (t :: b) = Foo6 t t
-    instance SuppressUnusedWarnings Foo6Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo6Sym1KindInference GHC.Tuple.())
-    data Foo6Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. KindOf (Apply (Foo6Sym1 l) arg) ~ KindOf (Foo6Sym2 l arg) =>
-        Foo6Sym1KindInference
-    type instance Apply (Foo6Sym1 l) l = Foo6Sym2 l l
-    instance SuppressUnusedWarnings Foo6Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo6Sym0KindInference GHC.Tuple.())
-    data Foo6Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. KindOf (Apply Foo6Sym0 arg) ~ KindOf (Foo6Sym1 arg) =>
-        Foo6Sym0KindInference
-    type instance Apply Foo6Sym0 l = Foo6Sym1 l
-    type Foo5Sym2 (t :: a) (t :: b) = Foo5 t t
-    instance SuppressUnusedWarnings Foo5Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo5Sym1KindInference GHC.Tuple.())
-    data Foo5Sym1 (l :: a) (l :: TyFun b b)
-      = forall arg. KindOf (Apply (Foo5Sym1 l) arg) ~ KindOf (Foo5Sym2 l arg) =>
-        Foo5Sym1KindInference
-    type instance Apply (Foo5Sym1 l) l = Foo5Sym2 l l
-    instance SuppressUnusedWarnings Foo5Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
-    data Foo5Sym0 (l :: TyFun a (TyFun b b -> *))
-      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
-        Foo5Sym0KindInference
-    type instance Apply Foo5Sym0 l = Foo5Sym1 l
-    type Foo4Sym3 (t :: a) (t :: b) (t :: c) = Foo4 t t t
-    instance SuppressUnusedWarnings Foo4Sym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo4Sym2KindInference GHC.Tuple.())
-    data Foo4Sym2 (l :: a) (l :: b) (l :: TyFun c a)
-      = forall arg. KindOf (Apply (Foo4Sym2 l l) arg) ~ KindOf (Foo4Sym3 l l arg) =>
-        Foo4Sym2KindInference
-    type instance Apply (Foo4Sym2 l l) l = Foo4Sym3 l l l
-    instance SuppressUnusedWarnings Foo4Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo4Sym1KindInference GHC.Tuple.())
-    data Foo4Sym1 (l :: a) (l :: TyFun b (TyFun c a -> *))
-      = forall arg. KindOf (Apply (Foo4Sym1 l) arg) ~ KindOf (Foo4Sym2 l arg) =>
-        Foo4Sym1KindInference
-    type instance Apply (Foo4Sym1 l) l = Foo4Sym2 l l
-    instance SuppressUnusedWarnings Foo4Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
-    data Foo4Sym0 (l :: TyFun a (TyFun b (TyFun c a -> *) -> *))
-      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
-        Foo4Sym0KindInference
-    type instance Apply Foo4Sym0 l = Foo4Sym1 l
-    type Foo3Sym1 (t :: a) = Foo3 t
-    instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
-    data Foo3Sym0 (l :: TyFun a a)
-      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
-        Foo3Sym0KindInference
-    type instance Apply Foo3Sym0 l = Foo3Sym1 l
-    type Foo2Sym2 (t :: a) (t :: b) = Foo2 t t
-    instance SuppressUnusedWarnings Foo2Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.())
-    data Foo2Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) =>
-        Foo2Sym1KindInference
-    type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l
-    instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
-    data Foo2Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
-        Foo2Sym0KindInference
-    type instance Apply Foo2Sym0 l = Foo2Sym1 l
-    type Foo1Sym2 (t :: a) (t :: b) = Foo1 t t
-    instance SuppressUnusedWarnings Foo1Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.())
-    data Foo1Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) =>
-        Foo1Sym1KindInference
-    type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l
-    instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
-    data Foo1Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
-        Foo1Sym0KindInference
-    type instance Apply Foo1Sym0 l = Foo1Sym1 l
-    type Foo0Sym2 (t :: a) (t :: b) = Foo0 t t
-    instance SuppressUnusedWarnings Foo0Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo0Sym1KindInference GHC.Tuple.())
-    data Foo0Sym1 (l :: a) (l :: TyFun b a)
-      = forall arg. KindOf (Apply (Foo0Sym1 l) arg) ~ KindOf (Foo0Sym2 l arg) =>
-        Foo0Sym1KindInference
-    type instance Apply (Foo0Sym1 l) l = Foo0Sym2 l l
-    instance SuppressUnusedWarnings Foo0Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo0Sym0KindInference GHC.Tuple.())
-    data Foo0Sym0 (l :: TyFun a (TyFun b a -> *))
-      = forall arg. KindOf (Apply Foo0Sym0 arg) ~ KindOf (Foo0Sym1 arg) =>
-        Foo0Sym0KindInference
-    type instance Apply Foo0Sym0 l = Foo0Sym1 l
-    type family Foo8 (a :: Foo a b) :: a where
-      Foo8 x = Apply (Apply Lambda_0123456789Sym0 x) x
-    type family Foo7 (a :: a) (a :: b) :: b where
-      Foo7 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) (Apply (Apply Tuple2Sym0 x) y)
-    type family Foo6 (a :: a) (a :: b) :: a where
-      Foo6 a b = Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) a) b
-    type family Foo5 (a :: a) (a :: b) :: b where
-      Foo5 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y
-    type family Foo4 (a :: a) (a :: b) (a :: c) :: a where
-      Foo4 x y z = Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z) y) z
-    type family Foo3 (a :: a) :: a where
-      Foo3 x = Apply (Apply Lambda_0123456789Sym0 x) x
-    type family Foo2 (a :: a) (a :: b) :: a where
-      Foo2 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y
-    type family Foo1 (a :: a) (a :: b) :: a where
-      Foo1 x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789
-    type family Foo0 (a :: a) (a :: b) :: a where
-      Foo0 a_0123456789 a_0123456789 = Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789
-    sFoo8 :: forall (t :: Foo a b). Sing t -> Sing (Apply Foo8Sym0 t)
-    sFoo7 ::
-      forall (t :: a) (t :: b).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t)
-    sFoo6 ::
-      forall (t :: a) (t :: b).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t)
-    sFoo5 ::
-      forall (t :: a) (t :: b).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t)
-    sFoo4 ::
-      forall (t :: a) (t :: b) (t :: c).
-      Sing t
-      -> Sing t -> Sing t -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t)
-    sFoo3 :: forall (t :: a). Sing t -> Sing (Apply Foo3Sym0 t)
-    sFoo2 ::
-      forall (t :: a) (t :: b).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t)
-    sFoo1 ::
-      forall (t :: a) (t :: b).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t)
-    sFoo0 ::
-      forall (t :: a) (t :: b).
-      Sing t -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t)
-    sFoo8 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 x)
-          lambda x
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x))
-                   (\ sArg_0123456789
-                      -> let
-                           lambda ::
-                             forall arg_0123456789.
-                             Sing arg_0123456789
-                             -> Sing (Apply (Apply Lambda_0123456789Sym0 x) arg_0123456789)
-                           lambda arg_0123456789
-                             = case arg_0123456789 of {
-                                 SFoo sA _
-                                   -> let
-                                        lambda ::
-                                          forall a wild.
-                                          Sing a
-                                          -> Sing (Case_0123456789 x arg_0123456789 (Apply (Apply FooSym0 a) wild))
-                                        lambda a = a
-                                      in lambda sA }
-                         in lambda sArg_0123456789))
-                x
-        in lambda sX
-    sFoo7 sX sY
-      = let
-          lambda ::
-            forall x y. (t ~ x, t ~ y) =>
-            Sing x -> Sing y -> Sing (Apply (Apply Foo7Sym0 x) y)
-          lambda x y
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
-                   (\ sArg_0123456789
-                      -> let
-                           lambda ::
-                             forall arg_0123456789.
-                             Sing arg_0123456789
-                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789)
-                           lambda arg_0123456789
-                             = case arg_0123456789 of {
-                                 STuple2 _ sB
-                                   -> let
-                                        lambda ::
-                                          forall b wild.
-                                          Sing b
-                                          -> Sing (Case_0123456789 x y arg_0123456789 (Apply (Apply Tuple2Sym0 wild) b))
-                                        lambda b = b
-                                      in lambda sB }
-                         in lambda sArg_0123456789))
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) x) y)
-        in lambda sX sY
-    sFoo6 sA sB
-      = let
-          lambda ::
-            forall a b. (t ~ a, t ~ b) =>
-            Sing a -> Sing b -> Sing (Apply (Apply Foo6Sym0 a) b)
-          lambda a b
-            = applySing
-                (applySing
-                   (singFun1
-                      (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 a) b))
-                      (\ sX
-                         -> let
-                              lambda ::
-                                forall x.
-                                Sing x -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x)
-                              lambda x
-                                = singFun1
-                                    (Proxy ::
-                                       Proxy (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x))
-                                    (\ sArg_0123456789
-                                       -> let
-                                            lambda ::
-                                              forall arg_0123456789.
-                                              Sing arg_0123456789
-                                              -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x) arg_0123456789)
-                                            lambda arg_0123456789
-                                              = case arg_0123456789 of {
-                                                  _ -> let
-                                                         lambda ::
-                                                           forall wild.
-                                                           Sing (Case_0123456789 a b x arg_0123456789 wild)
-                                                         lambda = x
-                                                       in lambda }
-                                          in lambda sArg_0123456789)
-                            in lambda sX))
-                   a)
-                b
-        in lambda sA sB
-    sFoo5 sX sY
-      = let
-          lambda ::
-            forall x y. (t ~ x, t ~ y) =>
-            Sing x -> Sing y -> Sing (Apply (Apply Foo5Sym0 x) y)
-          lambda x y
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
-                   (\ sX
-                      -> let
-                           lambda ::
-                             forall x.
-                             Sing x -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) x)
-                           lambda x = x
-                         in lambda sX))
-                y
-        in lambda sX sY
-    sFoo4 sX sY sZ
-      = let
-          lambda ::
-            forall x y z. (t ~ x, t ~ y, t ~ z) =>
-            Sing x
-            -> Sing y -> Sing z -> Sing (Apply (Apply (Apply Foo4Sym0 x) y) z)
-          lambda x y z
-            = applySing
-                (applySing
-                   (singFun2
-                      (Proxy ::
-                         Proxy (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z))
-                      (\ sArg_0123456789 sArg_0123456789
-                         -> let
-                              lambda ::
-                                forall arg_0123456789 arg_0123456789.
-                                Sing arg_0123456789
-                                -> Sing arg_0123456789
-                                   -> Sing (Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z) arg_0123456789) arg_0123456789)
-                              lambda arg_0123456789 arg_0123456789
-                                = case
-                                      applySing
-                                        (applySing
-                                           (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2)
-                                           arg_0123456789)
-                                        arg_0123456789
-                                  of {
-                                    STuple2 _ _
-                                      -> let
-                                           lambda ::
-                                             forall wild wild.
-                                             Sing (Case_0123456789 x y z arg_0123456789 arg_0123456789 (Apply (Apply Tuple2Sym0 wild) wild))
-                                           lambda = x
-                                         in lambda }
-                            in lambda sArg_0123456789 sArg_0123456789))
-                   y)
-                z
-        in lambda sX sY sZ
-    sFoo3 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 x)
-          lambda x
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x))
-                   (\ sY
-                      -> let
-                           lambda ::
-                             forall y. Sing y -> Sing (Apply (Apply Lambda_0123456789Sym0 x) y)
-                           lambda y = y
-                         in lambda sY))
-                x
-        in lambda sX
-    sFoo2 sX sY
-      = let
-          lambda ::
-            forall x y. (t ~ x, t ~ y) =>
-            Sing x -> Sing y -> Sing (Apply (Apply Foo2Sym0 x) y)
-          lambda x y
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
-                   (\ sArg_0123456789
-                      -> let
-                           lambda ::
-                             forall arg_0123456789.
-                             Sing arg_0123456789
-                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789)
-                           lambda arg_0123456789
-                             = case arg_0123456789 of {
-                                 _ -> let
-                                        lambda ::
-                                          forall wild.
-                                          Sing (Case_0123456789 x y arg_0123456789 wild)
-                                        lambda = x
-                                      in lambda }
-                         in lambda sArg_0123456789))
-                y
-        in lambda sX sY
-    sFoo1 sX sA_0123456789
-      = let
-          lambda ::
-            forall x a_0123456789. (t ~ x, t ~ a_0123456789) =>
-            Sing x
-            -> Sing a_0123456789
-               -> Sing (Apply (Apply Foo1Sym0 x) a_0123456789)
-          lambda x a_0123456789
-            = applySing
-                (singFun1
-                   (Proxy ::
-                      Proxy (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789))
-                   (\ sArg_0123456789
-                      -> let
-                           lambda ::
-                             forall arg_0123456789.
-                             Sing arg_0123456789
-                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) arg_0123456789)
-                           lambda arg_0123456789
-                             = case arg_0123456789 of {
-                                 _ -> let
-                                        lambda ::
-                                          forall wild.
-                                          Sing (Case_0123456789 x arg_0123456789 a_0123456789 wild)
-                                        lambda = x
-                                      in lambda }
-                         in lambda sArg_0123456789))
-                a_0123456789
-        in lambda sX sA_0123456789
-    sFoo0 sA_0123456789 sA_0123456789
-      = let
-          lambda ::
-            forall a_0123456789 a_0123456789. (t ~ a_0123456789,
-                                               t ~ a_0123456789) =>
-            Sing a_0123456789
-            -> Sing a_0123456789
-               -> Sing (Apply (Apply Foo0Sym0 a_0123456789) a_0123456789)
-          lambda a_0123456789 a_0123456789
-            = applySing
-                (applySing
-                   (singFun2
-                      (Proxy ::
-                         Proxy (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789))
-                      (\ sX sY
-                         -> let
-                              lambda ::
-                                forall x y.
-                                Sing x
-                                -> Sing y
-                                   -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) x) y)
-                              lambda x y = x
-                            in lambda sX sY))
-                   a_0123456789)
-                a_0123456789
-        in lambda sA_0123456789 sA_0123456789
-    data instance Sing (z :: Foo a b)
-      = forall (n :: a) (n :: b). z ~ Foo n n => SFoo (Sing n) (Sing n)
-    type SFoo (z :: Foo a b) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b)) =>
-             SingKind (KProxy :: KProxy (Foo a b)) where
-      type DemoteRep (KProxy :: KProxy (Foo a b)) = Foo (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
-      fromSing (SFoo b b) = Foo (fromSing b) (fromSing b)
-      toSing (Foo b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SFoo c c) }
-    instance (SingI n, SingI n) => SingI (Foo (n :: a) (n :: b)) where
-      sing = SFoo sing sing
diff --git a/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc710.template b/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc710.template
@@ -0,0 +1,81 @@
+Singletons/LambdasComprehensive.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo :: [Nat]
+          foo
+            = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)]
+          bar :: [Nat]
+          bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)] |]
+  ======>
+    foo :: [Nat]
+    foo
+      = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)]
+    bar :: [Nat]
+    bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)]
+    type family Lambda_0123456789 t where
+      Lambda_0123456789 x = Apply (Apply (Apply Either_Sym0 PredSym0) SuccSym0) x
+    type Lambda_0123456789Sym1 t = Lambda_0123456789 t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type BarSym0 = Bar
+    type FooSym0 = Foo
+    type family Bar :: [Nat] where
+      Bar = Apply (Apply MapSym0 (Apply (Apply Either_Sym0 PredSym0) SuccSym0)) (Apply (Apply (:$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[]))
+    type family Foo :: [Nat] where
+      Foo = Apply (Apply MapSym0 Lambda_0123456789Sym0) (Apply (Apply (:$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[]))
+    sBar :: Sing (BarSym0 :: [Nat])
+    sFoo :: Sing (FooSym0 :: [Nat])
+    sBar
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy MapSym0) sMap)
+             (applySing
+                (applySing
+                   (singFun3 (Proxy :: Proxy Either_Sym0) sEither_)
+                   (singFun1 (Proxy :: Proxy PredSym0) sPred))
+                (singFun1 (Proxy :: Proxy SuccSym0) SSucc)))
+          (applySing
+             (applySing
+                (singFun2 (Proxy :: Proxy (:$)) SCons)
+                (applySing (singFun1 (Proxy :: Proxy LeftSym0) SLeft) SZero))
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing
+                      (singFun1 (Proxy :: Proxy RightSym0) SRight)
+                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
+                SNil))
+    sFoo
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy MapSym0) sMap)
+             (singFun1
+                (Proxy :: Proxy Lambda_0123456789Sym0)
+                (\ sX
+                   -> let
+                        lambda :: forall x. Sing x -> Sing (Apply Lambda_0123456789Sym0 x)
+                        lambda x
+                          = applySing
+                              (applySing
+                                 (applySing
+                                    (singFun3 (Proxy :: Proxy Either_Sym0) sEither_)
+                                    (singFun1 (Proxy :: Proxy PredSym0) sPred))
+                                 (singFun1 (Proxy :: Proxy SuccSym0) SSucc))
+                              x
+                      in lambda sX)))
+          (applySing
+             (applySing
+                (singFun2 (Proxy :: Proxy (:$)) SCons)
+                (applySing (singFun1 (Proxy :: Proxy LeftSym0) SLeft) SZero))
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing
+                      (singFun1 (Proxy :: Proxy RightSym0) SRight)
+                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
+                SNil))
diff --git a/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc78.template b/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc78.template
+++ /dev/null
@@ -1,82 +0,0 @@
-Singletons/LambdasComprehensive.hs:0:0: Splicing declarations
-    singletons
-      [d| foo :: [Nat]
-          foo
-            = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)]
-          bar :: [Nat]
-          bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)] |]
-  ======>
-    Singletons/LambdasComprehensive.hs:(0,0)-(0,0)
-    foo :: [Nat]
-    foo
-      = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)]
-    bar :: [Nat]
-    bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)]
-    type family Lambda_0123456789 t where
-      Lambda_0123456789 x = Apply (Apply (Apply Either_Sym0 PredSym0) SuccSym0) x
-    type Lambda_0123456789Sym1 t = Lambda_0123456789 t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type BarSym0 = Bar
-    type FooSym0 = Foo
-    type Bar =
-        (Apply (Apply MapSym0 (Apply (Apply Either_Sym0 PredSym0) SuccSym0)) (Apply (Apply (:$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[])) :: [Nat])
-    type Foo =
-        (Apply (Apply MapSym0 Lambda_0123456789Sym0) (Apply (Apply (:$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[])) :: [Nat])
-    sBar :: Sing BarSym0
-    sFoo :: Sing FooSym0
-    sBar
-      = applySing
-          (applySing
-             (singFun2 (Proxy :: Proxy MapSym0) sMap)
-             (applySing
-                (applySing
-                   (singFun3 (Proxy :: Proxy Either_Sym0) sEither_)
-                   (singFun1 (Proxy :: Proxy PredSym0) sPred))
-                (singFun1 (Proxy :: Proxy SuccSym0) SSucc)))
-          (applySing
-             (applySing
-                (singFun2 (Proxy :: Proxy (:$)) SCons)
-                (applySing (singFun1 (Proxy :: Proxy LeftSym0) SLeft) SZero))
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing
-                      (singFun1 (Proxy :: Proxy RightSym0) SRight)
-                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
-                SNil))
-    sFoo
-      = applySing
-          (applySing
-             (singFun2 (Proxy :: Proxy MapSym0) sMap)
-             (singFun1
-                (Proxy :: Proxy Lambda_0123456789Sym0)
-                (\ sX
-                   -> let
-                        lambda :: forall x. Sing x -> Sing (Apply Lambda_0123456789Sym0 x)
-                        lambda x
-                          = applySing
-                              (applySing
-                                 (applySing
-                                    (singFun3 (Proxy :: Proxy Either_Sym0) sEither_)
-                                    (singFun1 (Proxy :: Proxy PredSym0) sPred))
-                                 (singFun1 (Proxy :: Proxy SuccSym0) SSucc))
-                              x
-                      in lambda sX)))
-          (applySing
-             (applySing
-                (singFun2 (Proxy :: Proxy (:$)) SCons)
-                (applySing (singFun1 (Proxy :: Proxy LeftSym0) SLeft) SZero))
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing
-                      (singFun1 (Proxy :: Proxy RightSym0) SRight)
-                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
-                SNil))
diff --git a/tests/compile-and-dump/Singletons/LetStatements.ghc710.template b/tests/compile-and-dump/Singletons/LetStatements.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/LetStatements.ghc710.template
@@ -0,0 +1,1026 @@
+Singletons/LetStatements.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo1 :: Nat -> Nat
+          foo1 x
+            = let
+                y :: Nat
+                y = Succ Zero
+              in y
+          foo2 :: Nat
+          foo2
+            = let
+                y = Succ Zero
+                z = Succ y
+              in z
+          foo3 :: Nat -> Nat
+          foo3 x
+            = let
+                y :: Nat
+                y = Succ x
+              in y
+          foo4 :: Nat -> Nat
+          foo4 x
+            = let
+                f :: Nat -> Nat
+                f y = Succ y
+              in f x
+          foo5 :: Nat -> Nat
+          foo5 x
+            = let
+                f :: Nat -> Nat
+                f y
+                  = let
+                      z :: Nat
+                      z = Succ y
+                    in Succ z
+              in f x
+          foo6 :: Nat -> Nat
+          foo6 x
+            = let
+                f :: Nat -> Nat
+                f y = Succ y in
+              let
+                z :: Nat
+                z = f x
+              in z
+          foo7 :: Nat -> Nat
+          foo7 x
+            = let
+                x :: Nat
+                x = Zero
+              in x
+          foo8 :: Nat -> Nat
+          foo8 x
+            = let
+                z :: Nat
+                z = (\ x -> x) Zero
+              in z
+          foo9 :: Nat -> Nat
+          foo9 x
+            = let
+                z :: Nat -> Nat
+                z = (\ x -> x)
+              in z x
+          foo10 :: Nat -> Nat
+          foo10 x
+            = let
+                (+) :: Nat -> Nat -> Nat
+                Zero + m = m
+                (Succ n) + m = Succ (n + m)
+              in (Succ Zero) + x
+          foo11 :: Nat -> Nat
+          foo11 x
+            = let
+                (+) :: Nat -> Nat -> Nat
+                Zero + m = m
+                (Succ n) + m = Succ (n + m)
+                z :: Nat
+                z = x
+              in (Succ Zero) + z
+          foo12 :: Nat -> Nat
+          foo12 x
+            = let
+                (+) :: Nat -> Nat -> Nat
+                Zero + m = m
+                (Succ n) + m = Succ (n + x)
+              in x + (Succ (Succ Zero))
+          foo13 :: forall a. a -> a
+          foo13 x
+            = let
+                bar :: a
+                bar = x
+              in foo13_ bar
+          foo13_ :: a -> a
+          foo13_ y = y
+          foo14 :: Nat -> (Nat, Nat)
+          foo14 x = let (y, z) = (Succ x, x) in (z, y) |]
+  ======>
+    foo1 :: Nat -> Nat
+    foo1 x
+      = let
+          y :: Nat
+          y = Succ Zero
+        in y
+    foo2 :: Nat
+    foo2
+      = let
+          y = Succ Zero
+          z = Succ y
+        in z
+    foo3 :: Nat -> Nat
+    foo3 x
+      = let
+          y :: Nat
+          y = Succ x
+        in y
+    foo4 :: Nat -> Nat
+    foo4 x
+      = let
+          f :: Nat -> Nat
+          f y = Succ y
+        in f x
+    foo5 :: Nat -> Nat
+    foo5 x
+      = let
+          f :: Nat -> Nat
+          f y
+            = let
+                z :: Nat
+                z = Succ y
+              in Succ z
+        in f x
+    foo6 :: Nat -> Nat
+    foo6 x
+      = let
+          f :: Nat -> Nat
+          f y = Succ y in
+        let
+          z :: Nat
+          z = f x
+        in z
+    foo7 :: Nat -> Nat
+    foo7 x
+      = let
+          x :: Nat
+          x = Zero
+        in x
+    foo8 :: Nat -> Nat
+    foo8 x
+      = let
+          z :: Nat
+          z = \ x -> x Zero
+        in z
+    foo9 :: Nat -> Nat
+    foo9 x
+      = let
+          z :: Nat -> Nat
+          z = \ x -> x
+        in z x
+    foo10 :: Nat -> Nat
+    foo10 x
+      = let
+          (+) :: Nat -> Nat -> Nat
+          (+) Zero m = m
+          (+) (Succ n) m = Succ (n + m)
+        in ((Succ Zero) + x)
+    foo11 :: Nat -> Nat
+    foo11 x
+      = let
+          (+) :: Nat -> Nat -> Nat
+          z :: Nat
+          (+) Zero m = m
+          (+) (Succ n) m = Succ (n + m)
+          z = x
+        in ((Succ Zero) + z)
+    foo12 :: Nat -> Nat
+    foo12 x
+      = let
+          (+) :: Nat -> Nat -> Nat
+          (+) Zero m = m
+          (+) (Succ n) m = Succ (n + x)
+        in (x + (Succ (Succ Zero)))
+    foo13 :: forall a. a -> a
+    foo13 x
+      = let
+          bar :: a
+          bar = x
+        in foo13_ bar
+    foo13_ :: forall a. a -> a
+    foo13_ y = y
+    foo14 :: Nat -> (Nat, Nat)
+    foo14 x = let (y, z) = (Succ x, x) in (z, y)
+    type family Case_0123456789 x t where
+      Case_0123456789 x '(y_0123456789, _z_0123456789) = y_0123456789
+    type family Case_0123456789 x t where
+      Case_0123456789 x '(_z_0123456789, y_0123456789) = y_0123456789
+    type Let0123456789YSym1 t = Let0123456789Y t
+    instance SuppressUnusedWarnings Let0123456789YSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())
+    data Let0123456789YSym0 l
+      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>
+        Let0123456789YSym0KindInference
+    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l
+    type Let0123456789ZSym1 t = Let0123456789Z t
+    instance SuppressUnusedWarnings Let0123456789ZSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
+    data Let0123456789ZSym0 l
+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
+        Let0123456789ZSym0KindInference
+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
+    type Let0123456789X_0123456789Sym1 t = Let0123456789X_0123456789 t
+    instance SuppressUnusedWarnings Let0123456789X_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789X_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789X_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789X_0123456789Sym0 arg) ~ KindOf (Let0123456789X_0123456789Sym1 arg) =>
+        Let0123456789X_0123456789Sym0KindInference
+    type instance Apply Let0123456789X_0123456789Sym0 l = Let0123456789X_0123456789Sym1 l
+    type family Let0123456789Y x where
+      Let0123456789Y x = Case_0123456789 x (Let0123456789X_0123456789Sym1 x)
+    type family Let0123456789Z x where
+      Let0123456789Z x = Case_0123456789 x (Let0123456789X_0123456789Sym1 x)
+    type family Let0123456789X_0123456789 x where
+      Let0123456789X_0123456789 x = Apply (Apply Tuple2Sym0 (Apply SuccSym0 x)) x
+    type Let0123456789BarSym1 t = Let0123456789Bar t
+    instance SuppressUnusedWarnings Let0123456789BarSym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Let0123456789BarSym0KindInference GHC.Tuple.())
+    data Let0123456789BarSym0 l
+      = forall arg. KindOf (Apply Let0123456789BarSym0 arg) ~ KindOf (Let0123456789BarSym1 arg) =>
+        Let0123456789BarSym0KindInference
+    type instance Apply Let0123456789BarSym0 l = Let0123456789BarSym1 l
+    type family Let0123456789Bar x :: a where
+      Let0123456789Bar x = x
+    type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =
+        (:<<<%%%%%%%%%%:+) t t t
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>
+        :<<<%%%%%%%%%%:+$$$###
+    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))
+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>
+        :<<<%%%%%%%%%%:+$$###
+    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$) l
+      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>
+        :<<<%%%%%%%%%%:+$###
+    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l
+    type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where
+      (:<<<%%%%%%%%%%:+) x Zero m = m
+      (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) x)
+    type Let0123456789ZSym1 t = Let0123456789Z t
+    instance SuppressUnusedWarnings Let0123456789ZSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
+    data Let0123456789ZSym0 l
+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
+        Let0123456789ZSym0KindInference
+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
+    type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =
+        (:<<<%%%%%%%%%%:+) t t t
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>
+        :<<<%%%%%%%%%%:+$$$###
+    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))
+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>
+        :<<<%%%%%%%%%%:+$$###
+    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$) l
+      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>
+        :<<<%%%%%%%%%%:+$###
+    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l
+    type family Let0123456789Z x :: Nat where
+      Let0123456789Z x = x
+    type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where
+      (:<<<%%%%%%%%%%:+) x Zero m = m
+      (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) m)
+    type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =
+        (:<<<%%%%%%%%%%:+) t t t
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>
+        :<<<%%%%%%%%%%:+$$$###
+    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))
+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>
+        :<<<%%%%%%%%%%:+$$###
+    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l
+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())
+    data (:<<<%%%%%%%%%%:+$) l
+      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>
+        :<<<%%%%%%%%%%:+$###
+    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l
+    type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where
+      (:<<<%%%%%%%%%%:+) x Zero m = m
+      (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) m)
+    type family Lambda_0123456789 x a_0123456789 t where
+      Lambda_0123456789 x a_0123456789 x = x
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type Let0123456789ZSym2 t (t :: Nat) = Let0123456789Z t t
+    instance SuppressUnusedWarnings Let0123456789ZSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())
+    data Let0123456789ZSym1 l (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>
+        Let0123456789ZSym1KindInference
+    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l
+    instance SuppressUnusedWarnings Let0123456789ZSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
+    data Let0123456789ZSym0 l
+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
+        Let0123456789ZSym0KindInference
+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
+    type family Let0123456789Z x (a :: Nat) :: Nat where
+      Let0123456789Z x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789
+    type family Lambda_0123456789 x t where
+      Lambda_0123456789 x x = x
+    type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type Let0123456789ZSym1 t = Let0123456789Z t
+    instance SuppressUnusedWarnings Let0123456789ZSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
+    data Let0123456789ZSym0 l
+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
+        Let0123456789ZSym0KindInference
+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
+    type family Let0123456789Z x :: Nat where
+      Let0123456789Z x = Apply (Apply Lambda_0123456789Sym0 x) ZeroSym0
+    type Let0123456789XSym1 t = Let0123456789X t
+    instance SuppressUnusedWarnings Let0123456789XSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789XSym0KindInference GHC.Tuple.())
+    data Let0123456789XSym0 l
+      = forall arg. KindOf (Apply Let0123456789XSym0 arg) ~ KindOf (Let0123456789XSym1 arg) =>
+        Let0123456789XSym0KindInference
+    type instance Apply Let0123456789XSym0 l = Let0123456789XSym1 l
+    type family Let0123456789X x :: Nat where
+      Let0123456789X x = ZeroSym0
+    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t
+    instance SuppressUnusedWarnings Let0123456789FSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())
+    data Let0123456789FSym1 l (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>
+        Let0123456789FSym1KindInference
+    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l
+    instance SuppressUnusedWarnings Let0123456789FSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())
+    data Let0123456789FSym0 l
+      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>
+        Let0123456789FSym0KindInference
+    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l
+    type family Let0123456789F x (a :: Nat) :: Nat where
+      Let0123456789F x y = Apply SuccSym0 y
+    type Let0123456789ZSym1 t = Let0123456789Z t
+    instance SuppressUnusedWarnings Let0123456789ZSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
+    data Let0123456789ZSym0 l
+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
+        Let0123456789ZSym0KindInference
+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
+    type family Let0123456789Z x :: Nat where
+      Let0123456789Z x = Apply (Let0123456789FSym1 x) x
+    type Let0123456789ZSym2 t t = Let0123456789Z t t
+    instance SuppressUnusedWarnings Let0123456789ZSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())
+    data Let0123456789ZSym1 l l
+      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>
+        Let0123456789ZSym1KindInference
+    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l
+    instance SuppressUnusedWarnings Let0123456789ZSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
+    data Let0123456789ZSym0 l
+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
+        Let0123456789ZSym0KindInference
+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
+    type family Let0123456789Z x y :: Nat where
+      Let0123456789Z x y = Apply SuccSym0 y
+    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t
+    instance SuppressUnusedWarnings Let0123456789FSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())
+    data Let0123456789FSym1 l (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>
+        Let0123456789FSym1KindInference
+    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l
+    instance SuppressUnusedWarnings Let0123456789FSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())
+    data Let0123456789FSym0 l
+      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>
+        Let0123456789FSym0KindInference
+    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l
+    type family Let0123456789F x (a :: Nat) :: Nat where
+      Let0123456789F x y = Apply SuccSym0 (Let0123456789ZSym2 x y)
+    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t
+    instance SuppressUnusedWarnings Let0123456789FSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())
+    data Let0123456789FSym1 l (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>
+        Let0123456789FSym1KindInference
+    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l
+    instance SuppressUnusedWarnings Let0123456789FSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())
+    data Let0123456789FSym0 l
+      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>
+        Let0123456789FSym0KindInference
+    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l
+    type family Let0123456789F x (a :: Nat) :: Nat where
+      Let0123456789F x y = Apply SuccSym0 y
+    type Let0123456789YSym1 t = Let0123456789Y t
+    instance SuppressUnusedWarnings Let0123456789YSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())
+    data Let0123456789YSym0 l
+      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>
+        Let0123456789YSym0KindInference
+    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l
+    type family Let0123456789Y x :: Nat where
+      Let0123456789Y x = Apply SuccSym0 x
+    type Let0123456789YSym0 = Let0123456789Y
+    type Let0123456789ZSym0 = Let0123456789Z
+    type family Let0123456789Y where
+      Let0123456789Y = Apply SuccSym0 ZeroSym0
+    type family Let0123456789Z where
+      Let0123456789Z = Apply SuccSym0 Let0123456789YSym0
+    type Let0123456789YSym1 t = Let0123456789Y t
+    instance SuppressUnusedWarnings Let0123456789YSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())
+    data Let0123456789YSym0 l
+      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>
+        Let0123456789YSym0KindInference
+    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l
+    type family Let0123456789Y x :: Nat where
+      Let0123456789Y x = Apply SuccSym0 ZeroSym0
+    type Foo14Sym1 (t :: Nat) = Foo14 t
+    instance SuppressUnusedWarnings Foo14Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo14Sym0KindInference GHC.Tuple.())
+    data Foo14Sym0 (l :: TyFun Nat (Nat, Nat))
+      = forall arg. KindOf (Apply Foo14Sym0 arg) ~ KindOf (Foo14Sym1 arg) =>
+        Foo14Sym0KindInference
+    type instance Apply Foo14Sym0 l = Foo14Sym1 l
+    type Foo13_Sym1 (t :: a) = Foo13_ t
+    instance SuppressUnusedWarnings Foo13_Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo13_Sym0KindInference GHC.Tuple.())
+    data Foo13_Sym0 (l :: TyFun a a)
+      = forall arg. KindOf (Apply Foo13_Sym0 arg) ~ KindOf (Foo13_Sym1 arg) =>
+        Foo13_Sym0KindInference
+    type instance Apply Foo13_Sym0 l = Foo13_Sym1 l
+    type Foo13Sym1 (t :: a) = Foo13 t
+    instance SuppressUnusedWarnings Foo13Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo13Sym0KindInference GHC.Tuple.())
+    data Foo13Sym0 (l :: TyFun a a)
+      = forall arg. KindOf (Apply Foo13Sym0 arg) ~ KindOf (Foo13Sym1 arg) =>
+        Foo13Sym0KindInference
+    type instance Apply Foo13Sym0 l = Foo13Sym1 l
+    type Foo12Sym1 (t :: Nat) = Foo12 t
+    instance SuppressUnusedWarnings Foo12Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo12Sym0KindInference GHC.Tuple.())
+    data Foo12Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo12Sym0 arg) ~ KindOf (Foo12Sym1 arg) =>
+        Foo12Sym0KindInference
+    type instance Apply Foo12Sym0 l = Foo12Sym1 l
+    type Foo11Sym1 (t :: Nat) = Foo11 t
+    instance SuppressUnusedWarnings Foo11Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo11Sym0KindInference GHC.Tuple.())
+    data Foo11Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo11Sym0 arg) ~ KindOf (Foo11Sym1 arg) =>
+        Foo11Sym0KindInference
+    type instance Apply Foo11Sym0 l = Foo11Sym1 l
+    type Foo10Sym1 (t :: Nat) = Foo10 t
+    instance SuppressUnusedWarnings Foo10Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo10Sym0KindInference GHC.Tuple.())
+    data Foo10Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo10Sym0 arg) ~ KindOf (Foo10Sym1 arg) =>
+        Foo10Sym0KindInference
+    type instance Apply Foo10Sym0 l = Foo10Sym1 l
+    type Foo9Sym1 (t :: Nat) = Foo9 t
+    instance SuppressUnusedWarnings Foo9Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo9Sym0KindInference GHC.Tuple.())
+    data Foo9Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo9Sym0 arg) ~ KindOf (Foo9Sym1 arg) =>
+        Foo9Sym0KindInference
+    type instance Apply Foo9Sym0 l = Foo9Sym1 l
+    type Foo8Sym1 (t :: Nat) = Foo8 t
+    instance SuppressUnusedWarnings Foo8Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo8Sym0KindInference GHC.Tuple.())
+    data Foo8Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo8Sym0 arg) ~ KindOf (Foo8Sym1 arg) =>
+        Foo8Sym0KindInference
+    type instance Apply Foo8Sym0 l = Foo8Sym1 l
+    type Foo7Sym1 (t :: Nat) = Foo7 t
+    instance SuppressUnusedWarnings Foo7Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo7Sym0KindInference GHC.Tuple.())
+    data Foo7Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo7Sym0 arg) ~ KindOf (Foo7Sym1 arg) =>
+        Foo7Sym0KindInference
+    type instance Apply Foo7Sym0 l = Foo7Sym1 l
+    type Foo6Sym1 (t :: Nat) = Foo6 t
+    instance SuppressUnusedWarnings Foo6Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo6Sym0KindInference GHC.Tuple.())
+    data Foo6Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo6Sym0 arg) ~ KindOf (Foo6Sym1 arg) =>
+        Foo6Sym0KindInference
+    type instance Apply Foo6Sym0 l = Foo6Sym1 l
+    type Foo5Sym1 (t :: Nat) = Foo5 t
+    instance SuppressUnusedWarnings Foo5Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
+    data Foo5Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
+        Foo5Sym0KindInference
+    type instance Apply Foo5Sym0 l = Foo5Sym1 l
+    type Foo4Sym1 (t :: Nat) = Foo4 t
+    instance SuppressUnusedWarnings Foo4Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
+    data Foo4Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
+        Foo4Sym0KindInference
+    type instance Apply Foo4Sym0 l = Foo4Sym1 l
+    type Foo3Sym1 (t :: Nat) = Foo3 t
+    instance SuppressUnusedWarnings Foo3Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
+    data Foo3Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
+        Foo3Sym0KindInference
+    type instance Apply Foo3Sym0 l = Foo3Sym1 l
+    type Foo2Sym0 = Foo2
+    type Foo1Sym1 (t :: Nat) = Foo1 t
+    instance SuppressUnusedWarnings Foo1Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
+    data Foo1Sym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
+        Foo1Sym0KindInference
+    type instance Apply Foo1Sym0 l = Foo1Sym1 l
+    type family Foo14 (a :: Nat) :: (Nat, Nat) where
+      Foo14 x = Apply (Apply Tuple2Sym0 (Let0123456789ZSym1 x)) (Let0123456789YSym1 x)
+    type family Foo13_ (a :: a) :: a where
+      Foo13_ y = y
+    type family Foo13 (a :: a) :: a where
+      Foo13 x = Apply Foo13_Sym0 (Let0123456789BarSym1 x)
+    type family Foo12 (a :: Nat) :: Nat where
+      Foo12 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))
+    type family Foo11 (a :: Nat) :: Nat where
+      Foo11 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789ZSym1 x)
+    type family Foo10 (a :: Nat) :: Nat where
+      Foo10 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) x
+    type family Foo9 (a :: Nat) :: Nat where
+      Foo9 x = Apply (Let0123456789ZSym1 x) x
+    type family Foo8 (a :: Nat) :: Nat where
+      Foo8 x = Let0123456789ZSym1 x
+    type family Foo7 (a :: Nat) :: Nat where
+      Foo7 x = Let0123456789XSym1 x
+    type family Foo6 (a :: Nat) :: Nat where
+      Foo6 x = Let0123456789ZSym1 x
+    type family Foo5 (a :: Nat) :: Nat where
+      Foo5 x = Apply (Let0123456789FSym1 x) x
+    type family Foo4 (a :: Nat) :: Nat where
+      Foo4 x = Apply (Let0123456789FSym1 x) x
+    type family Foo3 (a :: Nat) :: Nat where
+      Foo3 x = Let0123456789YSym1 x
+    type family Foo2 :: Nat where
+      Foo2 = Let0123456789ZSym0
+    type family Foo1 (a :: Nat) :: Nat where
+      Foo1 x = Let0123456789YSym1 x
+    sFoo14 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo14Sym0 t :: (Nat, Nat))
+    sFoo13_ ::
+      forall (t :: a). Sing t -> Sing (Apply Foo13_Sym0 t :: a)
+    sFoo13 :: forall (t :: a). Sing t -> Sing (Apply Foo13Sym0 t :: a)
+    sFoo12 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo12Sym0 t :: Nat)
+    sFoo11 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo11Sym0 t :: Nat)
+    sFoo10 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo10Sym0 t :: Nat)
+    sFoo9 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo9Sym0 t :: Nat)
+    sFoo8 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo8Sym0 t :: Nat)
+    sFoo7 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo7Sym0 t :: Nat)
+    sFoo6 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo6Sym0 t :: Nat)
+    sFoo5 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo5Sym0 t :: Nat)
+    sFoo4 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo4Sym0 t :: Nat)
+    sFoo3 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo3Sym0 t :: Nat)
+    sFoo2 :: Sing (Foo2Sym0 :: Nat)
+    sFoo1 ::
+      forall (t :: Nat). Sing t -> Sing (Apply Foo1Sym0 t :: Nat)
+    sFoo14 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo14Sym0 x :: (Nat, Nat))
+          lambda x
+            = let
+                sY :: Sing (Let0123456789YSym1 x)
+                sZ :: Sing (Let0123456789ZSym1 x)
+                sX_0123456789 :: Sing (Let0123456789X_0123456789Sym1 x)
+                sY
+                  = case sX_0123456789 of {
+                      STuple2 sY_0123456789 _s_z_0123456789
+                        -> let
+                             lambda ::
+                               forall y_0123456789
+                                      _z_0123456789. Apply (Apply Tuple2Sym0 y_0123456789) _z_0123456789 ~ Let0123456789X_0123456789Sym1 x =>
+                               Sing y_0123456789
+                               -> Sing _z_0123456789
+                                  -> Sing (Case_0123456789 x (Apply (Apply Tuple2Sym0 y_0123456789) _z_0123456789))
+                             lambda y_0123456789 _z_0123456789 = y_0123456789
+                           in lambda sY_0123456789 _s_z_0123456789 } ::
+                      Sing (Case_0123456789 x (Let0123456789X_0123456789Sym1 x))
+                sZ
+                  = case sX_0123456789 of {
+                      STuple2 _s_z_0123456789 sY_0123456789
+                        -> let
+                             lambda ::
+                               forall _z_0123456789
+                                      y_0123456789. Apply (Apply Tuple2Sym0 _z_0123456789) y_0123456789 ~ Let0123456789X_0123456789Sym1 x =>
+                               Sing _z_0123456789
+                               -> Sing y_0123456789
+                                  -> Sing (Case_0123456789 x (Apply (Apply Tuple2Sym0 _z_0123456789) y_0123456789))
+                             lambda _z_0123456789 y_0123456789 = y_0123456789
+                           in lambda _s_z_0123456789 sY_0123456789 } ::
+                      Sing (Case_0123456789 x (Let0123456789X_0123456789Sym1 x))
+                sX_0123456789
+                  = applySing
+                      (applySing
+                         (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2)
+                         (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) x))
+                      x
+              in
+                applySing
+                  (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) sZ) sY
+        in lambda sX
+    sFoo13_ sY
+      = let
+          lambda ::
+            forall y. t ~ y => Sing y -> Sing (Apply Foo13_Sym0 y :: a)
+          lambda y = y
+        in lambda sY
+    sFoo13 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo13Sym0 x :: a)
+          lambda x
+            = let
+                sBar :: Sing (Let0123456789BarSym1 x :: a)
+                sBar = x
+              in applySing (singFun1 (Proxy :: Proxy Foo13_Sym0) sFoo13_) sBar
+        in lambda sX
+    sFoo12 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo12Sym0 x :: Nat)
+          lambda x
+            = let
+                (%:+) ::
+                  forall (t :: Nat) (t :: Nat).
+                  Sing t
+                  -> Sing t
+                     -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat)
+                (%:+) SZero sM
+                  = let
+                      lambda ::
+                        forall m. (t ~ ZeroSym0, t ~ m) =>
+                        Sing m
+                        -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m :: Nat)
+                      lambda m = m
+                    in lambda sM
+                (%:+) (SSucc sN) sM
+                  = let
+                      lambda ::
+                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
+                        Sing n
+                        -> Sing m
+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m :: Nat)
+                      lambda n m
+                        = applySing
+                            (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                            (applySing
+                               (applySing
+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
+                               x)
+                    in lambda sN sM
+              in
+                applySing
+                  (applySing
+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) x)
+                  (applySing
+                     (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                     (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+        in lambda sX
+    sFoo11 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo11Sym0 x :: Nat)
+          lambda x
+            = let
+                sZ :: Sing (Let0123456789ZSym1 x :: Nat)
+                (%:+) ::
+                  forall (t :: Nat) (t :: Nat).
+                  Sing t
+                  -> Sing t
+                     -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat)
+                sZ = x
+                (%:+) SZero sM
+                  = let
+                      lambda ::
+                        forall m. (t ~ ZeroSym0, t ~ m) =>
+                        Sing m
+                        -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m :: Nat)
+                      lambda m = m
+                    in lambda sM
+                (%:+) (SSucc sN) sM
+                  = let
+                      lambda ::
+                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
+                        Sing n
+                        -> Sing m
+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m :: Nat)
+                      lambda n m
+                        = applySing
+                            (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                            (applySing
+                               (applySing
+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
+                               m)
+                    in lambda sN sM
+              in
+                applySing
+                  (applySing
+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+))
+                     (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+                  sZ
+        in lambda sX
+    sFoo10 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo10Sym0 x :: Nat)
+          lambda x
+            = let
+                (%:+) ::
+                  forall (t :: Nat) (t :: Nat).
+                  Sing t
+                  -> Sing t
+                     -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat)
+                (%:+) SZero sM
+                  = let
+                      lambda ::
+                        forall m. (t ~ ZeroSym0, t ~ m) =>
+                        Sing m
+                        -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m :: Nat)
+                      lambda m = m
+                    in lambda sM
+                (%:+) (SSucc sN) sM
+                  = let
+                      lambda ::
+                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
+                        Sing n
+                        -> Sing m
+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m :: Nat)
+                      lambda n m
+                        = applySing
+                            (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                            (applySing
+                               (applySing
+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
+                               m)
+                    in lambda sN sM
+              in
+                applySing
+                  (applySing
+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+))
+                     (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+                  x
+        in lambda sX
+    sFoo9 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo9Sym0 x :: Nat)
+          lambda x
+            = let
+                sZ ::
+                  forall (t :: Nat).
+                  Sing t -> Sing (Apply (Let0123456789ZSym1 x) t :: Nat)
+                sZ sA_0123456789
+                  = let
+                      lambda ::
+                        forall a_0123456789. t ~ a_0123456789 =>
+                        Sing a_0123456789
+                        -> Sing (Apply (Let0123456789ZSym1 x) a_0123456789 :: Nat)
+                      lambda a_0123456789
+                        = applySing
+                            (singFun1
+                               (Proxy ::
+                                  Proxy (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789))
+                               (\ sX
+                                  -> let
+                                       lambda ::
+                                         forall x.
+                                         Sing x
+                                         -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) x)
+                                       lambda x = x
+                                     in lambda sX))
+                            a_0123456789
+                    in lambda sA_0123456789
+              in
+                applySing (singFun1 (Proxy :: Proxy (Let0123456789ZSym1 x)) sZ) x
+        in lambda sX
+    sFoo8 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 x :: Nat)
+          lambda x
+            = let
+                sZ :: Sing (Let0123456789ZSym1 x :: Nat)
+                sZ
+                  = applySing
+                      (singFun1
+                         (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x))
+                         (\ sX
+                            -> let
+                                 lambda ::
+                                   forall x.
+                                   Sing x -> Sing (Apply (Apply Lambda_0123456789Sym0 x) x)
+                                 lambda x = x
+                               in lambda sX))
+                      SZero
+              in sZ
+        in lambda sX
+    sFoo7 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo7Sym0 x :: Nat)
+          lambda x
+            = let
+                sX :: Sing (Let0123456789XSym1 x :: Nat)
+                sX = SZero
+              in sX
+        in lambda sX
+    sFoo6 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo6Sym0 x :: Nat)
+          lambda x
+            = let
+                sF ::
+                  forall (t :: Nat).
+                  Sing t -> Sing (Apply (Let0123456789FSym1 x) t :: Nat)
+                sF sY
+                  = let
+                      lambda ::
+                        forall y. t ~ y =>
+                        Sing y -> Sing (Apply (Let0123456789FSym1 x) y :: Nat)
+                      lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y
+                    in lambda sY in
+              let
+                sZ :: Sing (Let0123456789ZSym1 x :: Nat)
+                sZ
+                  = applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x
+              in sZ
+        in lambda sX
+    sFoo5 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 x :: Nat)
+          lambda x
+            = let
+                sF ::
+                  forall (t :: Nat).
+                  Sing t -> Sing (Apply (Let0123456789FSym1 x) t :: Nat)
+                sF sY
+                  = let
+                      lambda ::
+                        forall y. t ~ y =>
+                        Sing y -> Sing (Apply (Let0123456789FSym1 x) y :: Nat)
+                      lambda y
+                        = let
+                            sZ :: Sing (Let0123456789ZSym2 x y :: Nat)
+                            sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y
+                          in applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sZ
+                    in lambda sY
+              in
+                applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x
+        in lambda sX
+    sFoo4 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 x :: Nat)
+          lambda x
+            = let
+                sF ::
+                  forall (t :: Nat).
+                  Sing t -> Sing (Apply (Let0123456789FSym1 x) t :: Nat)
+                sF sY
+                  = let
+                      lambda ::
+                        forall y. t ~ y =>
+                        Sing y -> Sing (Apply (Let0123456789FSym1 x) y :: Nat)
+                      lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y
+                    in lambda sY
+              in
+                applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x
+        in lambda sX
+    sFoo3 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 x :: Nat)
+          lambda x
+            = let
+                sY :: Sing (Let0123456789YSym1 x :: Nat)
+                sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) x
+              in sY
+        in lambda sX
+    sFoo2
+      = let
+          sY :: Sing Let0123456789YSym0
+          sZ :: Sing Let0123456789ZSym0
+          sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero
+          sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sY
+        in sZ
+    sFoo1 sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply Foo1Sym0 x :: Nat)
+          lambda x
+            = let
+                sY :: Sing (Let0123456789YSym1 x :: Nat)
+                sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero
+              in sY
+        in lambda sX
diff --git a/tests/compile-and-dump/Singletons/LetStatements.ghc78.template b/tests/compile-and-dump/Singletons/LetStatements.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/LetStatements.ghc78.template
+++ /dev/null
@@ -1,967 +0,0 @@
-Singletons/LetStatements.hs:0:0: Splicing declarations
-    singletons
-      [d| foo1 :: Nat -> Nat
-          foo1 x
-            = let
-                y :: Nat
-                y = Succ Zero
-              in y
-          foo2 :: Nat
-          foo2
-            = let
-                y = Succ Zero
-                z = Succ y
-              in z
-          foo3 :: Nat -> Nat
-          foo3 x
-            = let
-                y :: Nat
-                y = Succ x
-              in y
-          foo4 :: Nat -> Nat
-          foo4 x
-            = let
-                f :: Nat -> Nat
-                f y = Succ y
-              in f x
-          foo5 :: Nat -> Nat
-          foo5 x
-            = let
-                f :: Nat -> Nat
-                f y
-                  = let
-                      z :: Nat
-                      z = Succ y
-                    in Succ z
-              in f x
-          foo6 :: Nat -> Nat
-          foo6 x
-            = let
-                f :: Nat -> Nat
-                f y = Succ y in
-              let
-                z :: Nat
-                z = f x
-              in z
-          foo7 :: Nat -> Nat
-          foo7 x
-            = let
-                x :: Nat
-                x = Zero
-              in x
-          foo8 :: Nat -> Nat
-          foo8 x
-            = let
-                z :: Nat
-                z = (\ x -> x) Zero
-              in z
-          foo9 :: Nat -> Nat
-          foo9 x
-            = let
-                z :: Nat -> Nat
-                z = (\ x -> x)
-              in z x
-          foo10 :: Nat -> Nat
-          foo10 x
-            = let
-                (+) :: Nat -> Nat -> Nat
-                Zero + m = m
-                (Succ n) + m = Succ (n + m)
-              in (Succ Zero) + x
-          foo11 :: Nat -> Nat
-          foo11 x
-            = let
-                (+) :: Nat -> Nat -> Nat
-                Zero + m = m
-                (Succ n) + m = Succ (n + m)
-                z :: Nat
-                z = x
-              in (Succ Zero) + z
-          foo12 :: Nat -> Nat
-          foo12 x
-            = let
-                (+) :: Nat -> Nat -> Nat
-                Zero + m = m
-                (Succ n) + m = Succ (n + x)
-              in x + (Succ (Succ Zero))
-          foo13 :: forall a. a -> a
-          foo13 x
-            = let
-                bar :: a
-                bar = x
-              in foo13_ bar
-          foo13_ :: a -> a
-          foo13_ y = y
-          foo14 :: Nat -> (Nat, Nat)
-          foo14 x = let (y, z) = (Succ x, x) in (z, y) |]
-  ======>
-    Singletons/LetStatements.hs:(0,0)-(0,0)
-    foo1 :: Nat -> Nat
-    foo1 x
-      = let
-          y :: Nat
-          y = Succ Zero
-        in y
-    foo2 :: Nat
-    foo2
-      = let
-          y = Succ Zero
-          z = Succ y
-        in z
-    foo3 :: Nat -> Nat
-    foo3 x
-      = let
-          y :: Nat
-          y = Succ x
-        in y
-    foo4 :: Nat -> Nat
-    foo4 x
-      = let
-          f :: Nat -> Nat
-          f y = Succ y
-        in f x
-    foo5 :: Nat -> Nat
-    foo5 x
-      = let
-          f :: Nat -> Nat
-          f y
-            = let
-                z :: Nat
-                z = Succ y
-              in Succ z
-        in f x
-    foo6 :: Nat -> Nat
-    foo6 x
-      = let
-          f :: Nat -> Nat
-          f y = Succ y in
-        let
-          z :: Nat
-          z = f x
-        in z
-    foo7 :: Nat -> Nat
-    foo7 x
-      = let
-          x :: Nat
-          x = Zero
-        in x
-    foo8 :: Nat -> Nat
-    foo8 x
-      = let
-          z :: Nat
-          z = \ x -> x Zero
-        in z
-    foo9 :: Nat -> Nat
-    foo9 x
-      = let
-          z :: Nat -> Nat
-          z = \ x -> x
-        in z x
-    foo10 :: Nat -> Nat
-    foo10 x
-      = let
-          (+) :: Nat -> Nat -> Nat
-          (+) Zero m = m
-          (+) (Succ n) m = Succ (n + m)
-        in ((Succ Zero) + x)
-    foo11 :: Nat -> Nat
-    foo11 x
-      = let
-          (+) :: Nat -> Nat -> Nat
-          z :: Nat
-          (+) Zero m = m
-          (+) (Succ n) m = Succ (n + m)
-          z = x
-        in ((Succ Zero) + z)
-    foo12 :: Nat -> Nat
-    foo12 x
-      = let
-          (+) :: Nat -> Nat -> Nat
-          (+) Zero m = m
-          (+) (Succ n) m = Succ (n + x)
-        in (x + (Succ (Succ Zero)))
-    foo13 :: forall a. a -> a
-    foo13 x
-      = let
-          bar :: a
-          bar = x
-        in foo13_ bar
-    foo13_ :: forall a. a -> a
-    foo13_ y = y
-    foo14 :: Nat -> (Nat, Nat)
-    foo14 x = let (y, z) = (Succ x, x) in (z, y)
-    type family Case_0123456789 x t where
-      Case_0123456789 x '(y_0123456789, z) = y_0123456789
-    type family Case_0123456789 x t where
-      Case_0123456789 x '(z, y_0123456789) = y_0123456789
-    type Let0123456789YSym1 t = Let0123456789Y t
-    instance SuppressUnusedWarnings Let0123456789YSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())
-    data Let0123456789YSym0 l
-      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>
-        Let0123456789YSym0KindInference
-    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l
-    type Let0123456789ZSym1 t = Let0123456789Z t
-    instance SuppressUnusedWarnings Let0123456789ZSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
-    data Let0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
-        Let0123456789ZSym0KindInference
-    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
-    type Let0123456789X_0123456789Sym1 t = Let0123456789X_0123456789 t
-    instance SuppressUnusedWarnings Let0123456789X_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789X_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789X_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789X_0123456789Sym0 arg) ~ KindOf (Let0123456789X_0123456789Sym1 arg) =>
-        Let0123456789X_0123456789Sym0KindInference
-    type instance Apply Let0123456789X_0123456789Sym0 l = Let0123456789X_0123456789Sym1 l
-    type Let0123456789Y x =
-        Case_0123456789 x (Let0123456789X_0123456789Sym1 x)
-    type Let0123456789Z x =
-        Case_0123456789 x (Let0123456789X_0123456789Sym1 x)
-    type Let0123456789X_0123456789 x =
-        Apply (Apply Tuple2Sym0 (Apply SuccSym0 x)) x
-    type Let0123456789BarSym1 t = Let0123456789Bar t
-    instance SuppressUnusedWarnings Let0123456789BarSym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Let0123456789BarSym0KindInference GHC.Tuple.())
-    data Let0123456789BarSym0 l
-      = forall arg. KindOf (Apply Let0123456789BarSym0 arg) ~ KindOf (Let0123456789BarSym1 arg) =>
-        Let0123456789BarSym0KindInference
-    type instance Apply Let0123456789BarSym0 l = Let0123456789BarSym1 l
-    type Let0123456789Bar x = (x :: a)
-    type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =
-        (:<<<%%%%%%%%%%:+) t t t
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>
-        (:<<<%%%%%%%%%%:+$$$###)
-    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>
-        (:<<<%%%%%%%%%%:+$$###)
-    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$) l
-      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>
-        (:<<<%%%%%%%%%%:+$###)
-    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l
-    type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where
-      (:<<<%%%%%%%%%%:+) x Zero m = m
-      (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) x)
-    type Let0123456789ZSym1 t = Let0123456789Z t
-    instance SuppressUnusedWarnings Let0123456789ZSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
-    data Let0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
-        Let0123456789ZSym0KindInference
-    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
-    type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =
-        (:<<<%%%%%%%%%%:+) t t t
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>
-        (:<<<%%%%%%%%%%:+$$$###)
-    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>
-        (:<<<%%%%%%%%%%:+$$###)
-    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$) l
-      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>
-        (:<<<%%%%%%%%%%:+$###)
-    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l
-    type Let0123456789Z x = (x :: Nat)
-    type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where
-      (:<<<%%%%%%%%%%:+) x Zero m = m
-      (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) m)
-    type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =
-        (:<<<%%%%%%%%%%:+) t t t
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>
-        (:<<<%%%%%%%%%%:+$$$###)
-    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>
-        (:<<<%%%%%%%%%%:+$$###)
-    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l
-    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())
-    data (:<<<%%%%%%%%%%:+$) l
-      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>
-        (:<<<%%%%%%%%%%:+$###)
-    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l
-    type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where
-      (:<<<%%%%%%%%%%:+) x Zero m = m
-      (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) m)
-    type family Lambda_0123456789 x a_0123456789 t where
-      Lambda_0123456789 x a_0123456789 x = x
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type Let0123456789ZSym2 t (t :: Nat) = Let0123456789Z t t
-    instance SuppressUnusedWarnings Let0123456789ZSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())
-    data Let0123456789ZSym1 l (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>
-        Let0123456789ZSym1KindInference
-    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l
-    instance SuppressUnusedWarnings Let0123456789ZSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
-    data Let0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
-        Let0123456789ZSym0KindInference
-    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
-    type family Let0123456789Z x (a :: Nat) :: Nat where
-      Let0123456789Z x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789
-    type family Lambda_0123456789 x t where
-      Lambda_0123456789 x x = x
-    type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type Let0123456789ZSym1 t = Let0123456789Z t
-    instance SuppressUnusedWarnings Let0123456789ZSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
-    data Let0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
-        Let0123456789ZSym0KindInference
-    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
-    type Let0123456789Z x =
-        (Apply (Apply Lambda_0123456789Sym0 x) ZeroSym0 :: Nat)
-    type Let0123456789XSym1 t = Let0123456789X t
-    instance SuppressUnusedWarnings Let0123456789XSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789XSym0KindInference GHC.Tuple.())
-    data Let0123456789XSym0 l
-      = forall arg. KindOf (Apply Let0123456789XSym0 arg) ~ KindOf (Let0123456789XSym1 arg) =>
-        Let0123456789XSym0KindInference
-    type instance Apply Let0123456789XSym0 l = Let0123456789XSym1 l
-    type Let0123456789X x = (ZeroSym0 :: Nat)
-    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t
-    instance SuppressUnusedWarnings Let0123456789FSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())
-    data Let0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>
-        Let0123456789FSym1KindInference
-    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l
-    instance SuppressUnusedWarnings Let0123456789FSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())
-    data Let0123456789FSym0 l
-      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>
-        Let0123456789FSym0KindInference
-    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l
-    type family Let0123456789F x (a :: Nat) :: Nat where
-      Let0123456789F x y = Apply SuccSym0 y
-    type Let0123456789ZSym1 t = Let0123456789Z t
-    instance SuppressUnusedWarnings Let0123456789ZSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
-    data Let0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
-        Let0123456789ZSym0KindInference
-    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
-    type Let0123456789Z x = (Apply (Let0123456789FSym1 x) x :: Nat)
-    type Let0123456789ZSym2 t t = Let0123456789Z t t
-    instance SuppressUnusedWarnings Let0123456789ZSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())
-    data Let0123456789ZSym1 l l
-      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>
-        Let0123456789ZSym1KindInference
-    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l
-    instance SuppressUnusedWarnings Let0123456789ZSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())
-    data Let0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>
-        Let0123456789ZSym0KindInference
-    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l
-    type Let0123456789Z x y = (Apply SuccSym0 y :: Nat)
-    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t
-    instance SuppressUnusedWarnings Let0123456789FSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())
-    data Let0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>
-        Let0123456789FSym1KindInference
-    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l
-    instance SuppressUnusedWarnings Let0123456789FSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())
-    data Let0123456789FSym0 l
-      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>
-        Let0123456789FSym0KindInference
-    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l
-    type family Let0123456789F x (a :: Nat) :: Nat where
-      Let0123456789F x y = Apply SuccSym0 (Let0123456789ZSym2 x y)
-    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t
-    instance SuppressUnusedWarnings Let0123456789FSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())
-    data Let0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>
-        Let0123456789FSym1KindInference
-    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l
-    instance SuppressUnusedWarnings Let0123456789FSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())
-    data Let0123456789FSym0 l
-      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>
-        Let0123456789FSym0KindInference
-    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l
-    type family Let0123456789F x (a :: Nat) :: Nat where
-      Let0123456789F x y = Apply SuccSym0 y
-    type Let0123456789YSym1 t = Let0123456789Y t
-    instance SuppressUnusedWarnings Let0123456789YSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())
-    data Let0123456789YSym0 l
-      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>
-        Let0123456789YSym0KindInference
-    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l
-    type Let0123456789Y x = (Apply SuccSym0 x :: Nat)
-    type Let0123456789YSym0 = Let0123456789Y
-    type Let0123456789ZSym0 = Let0123456789Z
-    type Let0123456789Y = Apply SuccSym0 ZeroSym0
-    type Let0123456789Z = Apply SuccSym0 Let0123456789YSym0
-    type Let0123456789YSym1 t = Let0123456789Y t
-    instance SuppressUnusedWarnings Let0123456789YSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())
-    data Let0123456789YSym0 l
-      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>
-        Let0123456789YSym0KindInference
-    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l
-    type Let0123456789Y x = (Apply SuccSym0 ZeroSym0 :: Nat)
-    type Foo14Sym1 (t :: Nat) = Foo14 t
-    instance SuppressUnusedWarnings Foo14Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo14Sym0KindInference GHC.Tuple.())
-    data Foo14Sym0 (l :: TyFun Nat (Nat, Nat))
-      = forall arg. KindOf (Apply Foo14Sym0 arg) ~ KindOf (Foo14Sym1 arg) =>
-        Foo14Sym0KindInference
-    type instance Apply Foo14Sym0 l = Foo14Sym1 l
-    type Foo13_Sym1 (t :: a) = Foo13_ t
-    instance SuppressUnusedWarnings Foo13_Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo13_Sym0KindInference GHC.Tuple.())
-    data Foo13_Sym0 (l :: TyFun a a)
-      = forall arg. KindOf (Apply Foo13_Sym0 arg) ~ KindOf (Foo13_Sym1 arg) =>
-        Foo13_Sym0KindInference
-    type instance Apply Foo13_Sym0 l = Foo13_Sym1 l
-    type Foo13Sym1 (t :: a) = Foo13 t
-    instance SuppressUnusedWarnings Foo13Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo13Sym0KindInference GHC.Tuple.())
-    data Foo13Sym0 (l :: TyFun a a)
-      = forall arg. KindOf (Apply Foo13Sym0 arg) ~ KindOf (Foo13Sym1 arg) =>
-        Foo13Sym0KindInference
-    type instance Apply Foo13Sym0 l = Foo13Sym1 l
-    type Foo12Sym1 (t :: Nat) = Foo12 t
-    instance SuppressUnusedWarnings Foo12Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo12Sym0KindInference GHC.Tuple.())
-    data Foo12Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo12Sym0 arg) ~ KindOf (Foo12Sym1 arg) =>
-        Foo12Sym0KindInference
-    type instance Apply Foo12Sym0 l = Foo12Sym1 l
-    type Foo11Sym1 (t :: Nat) = Foo11 t
-    instance SuppressUnusedWarnings Foo11Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo11Sym0KindInference GHC.Tuple.())
-    data Foo11Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo11Sym0 arg) ~ KindOf (Foo11Sym1 arg) =>
-        Foo11Sym0KindInference
-    type instance Apply Foo11Sym0 l = Foo11Sym1 l
-    type Foo10Sym1 (t :: Nat) = Foo10 t
-    instance SuppressUnusedWarnings Foo10Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo10Sym0KindInference GHC.Tuple.())
-    data Foo10Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo10Sym0 arg) ~ KindOf (Foo10Sym1 arg) =>
-        Foo10Sym0KindInference
-    type instance Apply Foo10Sym0 l = Foo10Sym1 l
-    type Foo9Sym1 (t :: Nat) = Foo9 t
-    instance SuppressUnusedWarnings Foo9Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo9Sym0KindInference GHC.Tuple.())
-    data Foo9Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo9Sym0 arg) ~ KindOf (Foo9Sym1 arg) =>
-        Foo9Sym0KindInference
-    type instance Apply Foo9Sym0 l = Foo9Sym1 l
-    type Foo8Sym1 (t :: Nat) = Foo8 t
-    instance SuppressUnusedWarnings Foo8Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo8Sym0KindInference GHC.Tuple.())
-    data Foo8Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo8Sym0 arg) ~ KindOf (Foo8Sym1 arg) =>
-        Foo8Sym0KindInference
-    type instance Apply Foo8Sym0 l = Foo8Sym1 l
-    type Foo7Sym1 (t :: Nat) = Foo7 t
-    instance SuppressUnusedWarnings Foo7Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo7Sym0KindInference GHC.Tuple.())
-    data Foo7Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo7Sym0 arg) ~ KindOf (Foo7Sym1 arg) =>
-        Foo7Sym0KindInference
-    type instance Apply Foo7Sym0 l = Foo7Sym1 l
-    type Foo6Sym1 (t :: Nat) = Foo6 t
-    instance SuppressUnusedWarnings Foo6Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo6Sym0KindInference GHC.Tuple.())
-    data Foo6Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo6Sym0 arg) ~ KindOf (Foo6Sym1 arg) =>
-        Foo6Sym0KindInference
-    type instance Apply Foo6Sym0 l = Foo6Sym1 l
-    type Foo5Sym1 (t :: Nat) = Foo5 t
-    instance SuppressUnusedWarnings Foo5Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.())
-    data Foo5Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) =>
-        Foo5Sym0KindInference
-    type instance Apply Foo5Sym0 l = Foo5Sym1 l
-    type Foo4Sym1 (t :: Nat) = Foo4 t
-    instance SuppressUnusedWarnings Foo4Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.())
-    data Foo4Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) =>
-        Foo4Sym0KindInference
-    type instance Apply Foo4Sym0 l = Foo4Sym1 l
-    type Foo3Sym1 (t :: Nat) = Foo3 t
-    instance SuppressUnusedWarnings Foo3Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.())
-    data Foo3Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) =>
-        Foo3Sym0KindInference
-    type instance Apply Foo3Sym0 l = Foo3Sym1 l
-    type Foo2Sym0 = Foo2
-    type Foo1Sym1 (t :: Nat) = Foo1 t
-    instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
-    data Foo1Sym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
-        Foo1Sym0KindInference
-    type instance Apply Foo1Sym0 l = Foo1Sym1 l
-    type family Foo14 (a :: Nat) :: (Nat, Nat) where
-      Foo14 x = Apply (Apply Tuple2Sym0 (Let0123456789ZSym1 x)) (Let0123456789YSym1 x)
-    type family Foo13_ (a :: a) :: a where
-      Foo13_ y = y
-    type family Foo13 (a :: a) :: a where
-      Foo13 x = Apply Foo13_Sym0 (Let0123456789BarSym1 x)
-    type family Foo12 (a :: Nat) :: Nat where
-      Foo12 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))
-    type family Foo11 (a :: Nat) :: Nat where
-      Foo11 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789ZSym1 x)
-    type family Foo10 (a :: Nat) :: Nat where
-      Foo10 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) x
-    type family Foo9 (a :: Nat) :: Nat where
-      Foo9 x = Apply (Let0123456789ZSym1 x) x
-    type family Foo8 (a :: Nat) :: Nat where
-      Foo8 x = Let0123456789ZSym1 x
-    type family Foo7 (a :: Nat) :: Nat where
-      Foo7 x = Let0123456789XSym1 x
-    type family Foo6 (a :: Nat) :: Nat where
-      Foo6 x = Let0123456789ZSym1 x
-    type family Foo5 (a :: Nat) :: Nat where
-      Foo5 x = Apply (Let0123456789FSym1 x) x
-    type family Foo4 (a :: Nat) :: Nat where
-      Foo4 x = Apply (Let0123456789FSym1 x) x
-    type family Foo3 (a :: Nat) :: Nat where
-      Foo3 x = Let0123456789YSym1 x
-    type Foo2 = (Let0123456789ZSym0 :: Nat)
-    type family Foo1 (a :: Nat) :: Nat where
-      Foo1 x = Let0123456789YSym1 x
-    sFoo14 :: forall (t :: Nat). Sing t -> Sing (Apply Foo14Sym0 t)
-    sFoo13_ :: forall (t :: a). Sing t -> Sing (Apply Foo13_Sym0 t)
-    sFoo13 :: forall (t :: a). Sing t -> Sing (Apply Foo13Sym0 t)
-    sFoo12 :: forall (t :: Nat). Sing t -> Sing (Apply Foo12Sym0 t)
-    sFoo11 :: forall (t :: Nat). Sing t -> Sing (Apply Foo11Sym0 t)
-    sFoo10 :: forall (t :: Nat). Sing t -> Sing (Apply Foo10Sym0 t)
-    sFoo9 :: forall (t :: Nat). Sing t -> Sing (Apply Foo9Sym0 t)
-    sFoo8 :: forall (t :: Nat). Sing t -> Sing (Apply Foo8Sym0 t)
-    sFoo7 :: forall (t :: Nat). Sing t -> Sing (Apply Foo7Sym0 t)
-    sFoo6 :: forall (t :: Nat). Sing t -> Sing (Apply Foo6Sym0 t)
-    sFoo5 :: forall (t :: Nat). Sing t -> Sing (Apply Foo5Sym0 t)
-    sFoo4 :: forall (t :: Nat). Sing t -> Sing (Apply Foo4Sym0 t)
-    sFoo3 :: forall (t :: Nat). Sing t -> Sing (Apply Foo3Sym0 t)
-    sFoo2 :: Sing Foo2Sym0
-    sFoo1 :: forall (t :: Nat). Sing t -> Sing (Apply Foo1Sym0 t)
-    sFoo14 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo14Sym0 x)
-          lambda x
-            = let
-                sY :: Sing (Let0123456789YSym1 x)
-                sZ :: Sing (Let0123456789ZSym1 x)
-                sX_0123456789 :: Sing (Let0123456789X_0123456789Sym1 x)
-                sY
-                  = case sX_0123456789 of {
-                      STuple2 sY_0123456789 _
-                        -> let
-                             lambda ::
-                               forall y_0123456789 wild.
-                               Sing y_0123456789
-                               -> Sing (Case_0123456789 x (Apply (Apply Tuple2Sym0 y_0123456789) wild))
-                             lambda y_0123456789 = y_0123456789
-                           in lambda sY_0123456789 }
-                sZ
-                  = case sX_0123456789 of {
-                      STuple2 _ sY_0123456789
-                        -> let
-                             lambda ::
-                               forall y_0123456789 wild.
-                               Sing y_0123456789
-                               -> Sing (Case_0123456789 x (Apply (Apply Tuple2Sym0 wild) y_0123456789))
-                             lambda y_0123456789 = y_0123456789
-                           in lambda sY_0123456789 }
-                sX_0123456789
-                  = applySing
-                      (applySing
-                         (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2)
-                         (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) x))
-                      x
-              in
-                applySing
-                  (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) sZ) sY
-        in lambda sX
-    sFoo13_ sY
-      = let
-          lambda :: forall y. t ~ y => Sing y -> Sing (Apply Foo13_Sym0 y)
-          lambda y = y
-        in lambda sY
-    sFoo13 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo13Sym0 x)
-          lambda x
-            = let
-                sBar :: Sing (Let0123456789BarSym1 x)
-                sBar = x
-              in applySing (singFun1 (Proxy :: Proxy Foo13_Sym0) sFoo13_) sBar
-        in lambda sX
-    sFoo12 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo12Sym0 x)
-          lambda x
-            = let
-                (%:+) ::
-                  forall t t.
-                  Sing t
-                  -> Sing t -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t)
-                (%:+) SZero sM
-                  = let
-                      lambda ::
-                        forall m. (t ~ ZeroSym0, t ~ m) =>
-                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)
-                      lambda m = m
-                    in lambda sM
-                (%:+) (SSucc sN) sM
-                  = let
-                      lambda ::
-                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
-                        Sing n
-                        -> Sing m
-                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)
-                      lambda n m
-                        = applySing
-                            (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                            (applySing
-                               (applySing
-                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
-                               x)
-                    in lambda sN sM
-              in
-                applySing
-                  (applySing
-                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) x)
-                  (applySing
-                     (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                     (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-        in lambda sX
-    sFoo11 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo11Sym0 x)
-          lambda x
-            = let
-                sZ :: Sing (Let0123456789ZSym1 x)
-                (%:+) ::
-                  forall t t.
-                  Sing t
-                  -> Sing t -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t)
-                sZ = x
-                (%:+) SZero sM
-                  = let
-                      lambda ::
-                        forall m. (t ~ ZeroSym0, t ~ m) =>
-                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)
-                      lambda m = m
-                    in lambda sM
-                (%:+) (SSucc sN) sM
-                  = let
-                      lambda ::
-                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
-                        Sing n
-                        -> Sing m
-                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)
-                      lambda n m
-                        = applySing
-                            (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                            (applySing
-                               (applySing
-                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
-                               m)
-                    in lambda sN sM
-              in
-                applySing
-                  (applySing
-                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+))
-                     (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-                  sZ
-        in lambda sX
-    sFoo10 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo10Sym0 x)
-          lambda x
-            = let
-                (%:+) ::
-                  forall t t.
-                  Sing t
-                  -> Sing t -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t)
-                (%:+) SZero sM
-                  = let
-                      lambda ::
-                        forall m. (t ~ ZeroSym0, t ~ m) =>
-                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)
-                      lambda m = m
-                    in lambda sM
-                (%:+) (SSucc sN) sM
-                  = let
-                      lambda ::
-                        forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
-                        Sing n
-                        -> Sing m
-                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)
-                      lambda n m
-                        = applySing
-                            (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                            (applySing
-                               (applySing
-                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
-                               m)
-                    in lambda sN sM
-              in
-                applySing
-                  (applySing
-                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+))
-                     (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-                  x
-        in lambda sX
-    sFoo9 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo9Sym0 x)
-          lambda x
-            = let
-                sZ :: forall t. Sing t -> Sing (Apply (Let0123456789ZSym1 x) t)
-                sZ sA_0123456789
-                  = let
-                      lambda ::
-                        forall a_0123456789. t ~ a_0123456789 =>
-                        Sing a_0123456789
-                        -> Sing (Apply (Let0123456789ZSym1 x) a_0123456789)
-                      lambda a_0123456789
-                        = applySing
-                            (singFun1
-                               (Proxy ::
-                                  Proxy (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789))
-                               (\ sX
-                                  -> let
-                                       lambda ::
-                                         forall x.
-                                         Sing x
-                                         -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) x)
-                                       lambda x = x
-                                     in lambda sX))
-                            a_0123456789
-                    in lambda sA_0123456789
-              in
-                applySing (singFun1 (Proxy :: Proxy (Let0123456789ZSym1 x)) sZ) x
-        in lambda sX
-    sFoo8 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 x)
-          lambda x
-            = let
-                sZ :: Sing (Let0123456789ZSym1 x)
-                sZ
-                  = applySing
-                      (singFun1
-                         (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x))
-                         (\ sX
-                            -> let
-                                 lambda ::
-                                   forall x.
-                                   Sing x -> Sing (Apply (Apply Lambda_0123456789Sym0 x) x)
-                                 lambda x = x
-                               in lambda sX))
-                      SZero
-              in sZ
-        in lambda sX
-    sFoo7 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo7Sym0 x)
-          lambda x
-            = let
-                sX :: Sing (Let0123456789XSym1 x)
-                sX = SZero
-              in sX
-        in lambda sX
-    sFoo6 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo6Sym0 x)
-          lambda x
-            = let
-                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)
-                sF sY
-                  = let
-                      lambda ::
-                        forall y. t ~ y => Sing y -> Sing (Apply (Let0123456789FSym1 x) y)
-                      lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y
-                    in lambda sY in
-              let
-                sZ :: Sing (Let0123456789ZSym1 x)
-                sZ
-                  = applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x
-              in sZ
-        in lambda sX
-    sFoo5 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 x)
-          lambda x
-            = let
-                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)
-                sF sY
-                  = let
-                      lambda ::
-                        forall y. t ~ y => Sing y -> Sing (Apply (Let0123456789FSym1 x) y)
-                      lambda y
-                        = let
-                            sZ :: Sing (Let0123456789ZSym2 x y)
-                            sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y
-                          in applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sZ
-                    in lambda sY
-              in
-                applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x
-        in lambda sX
-    sFoo4 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 x)
-          lambda x
-            = let
-                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)
-                sF sY
-                  = let
-                      lambda ::
-                        forall y. t ~ y => Sing y -> Sing (Apply (Let0123456789FSym1 x) y)
-                      lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y
-                    in lambda sY
-              in
-                applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x
-        in lambda sX
-    sFoo3 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 x)
-          lambda x
-            = let
-                sY :: Sing (Let0123456789YSym1 x)
-                sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) x
-              in sY
-        in lambda sX
-    sFoo2
-      = let
-          sY :: Sing Let0123456789YSym0
-          sZ :: Sing Let0123456789ZSym0
-          sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero
-          sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sY
-        in sZ
-    sFoo1 sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo1Sym0 x)
-          lambda x
-            = let
-                sY :: Sing (Let0123456789YSym1 x)
-                sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero
-              in sY
-        in lambda sX
diff --git a/tests/compile-and-dump/Singletons/Maybe.ghc710.template b/tests/compile-and-dump/Singletons/Maybe.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Maybe.ghc710.template
@@ -0,0 +1,66 @@
+Singletons/Maybe.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data Maybe a
+            = Nothing | Just a
+            deriving (Eq, Show) |]
+  ======>
+    data Maybe a
+      = Nothing | Just a
+      deriving (Eq, Show)
+    type family Equals_0123456789 (a :: Maybe k)
+                                  (b :: Maybe k) :: Bool where
+      Equals_0123456789 Nothing Nothing = TrueSym0
+      Equals_0123456789 (Just a) (Just b) = (:==) a b
+      Equals_0123456789 (a :: Maybe k) (b :: Maybe k) = FalseSym0
+    instance PEq (KProxy :: KProxy (Maybe k)) where
+      type (:==) (a :: Maybe k) (b :: Maybe k) = Equals_0123456789 a b
+    type NothingSym0 = Nothing
+    type JustSym1 (t :: a) = Just t
+    instance SuppressUnusedWarnings JustSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) JustSym0KindInference GHC.Tuple.())
+    data JustSym0 (l :: TyFun a (Maybe a))
+      = forall arg. KindOf (Apply JustSym0 arg) ~ KindOf (JustSym1 arg) =>
+        JustSym0KindInference
+    type instance Apply JustSym0 l = JustSym1 l
+    data instance Sing (z :: Maybe a)
+      = z ~ Nothing => SNothing |
+        forall (n :: a). z ~ Just n => SJust (Sing (n :: a))
+    type SMaybe = (Sing :: Maybe a -> *)
+    instance SingKind (KProxy :: KProxy a) =>
+             SingKind (KProxy :: KProxy (Maybe a)) where
+      type DemoteRep (KProxy :: KProxy (Maybe a)) = Maybe (DemoteRep (KProxy :: KProxy a))
+      fromSing SNothing = Nothing
+      fromSing (SJust b) = Just (fromSing b)
+      toSing Nothing = SomeSing SNothing
+      toSing (Just b)
+        = case toSing b :: SomeSing (KProxy :: KProxy a) of {
+            SomeSing c -> SomeSing (SJust c) }
+    instance SEq (KProxy :: KProxy a) =>
+             SEq (KProxy :: KProxy (Maybe a)) where
+      (%:==) SNothing SNothing = STrue
+      (%:==) SNothing (SJust _) = SFalse
+      (%:==) (SJust _) SNothing = SFalse
+      (%:==) (SJust a) (SJust b) = (%:==) a b
+    instance SDecide (KProxy :: KProxy a) =>
+             SDecide (KProxy :: KProxy (Maybe a)) where
+      (%~) SNothing SNothing = Proved Refl
+      (%~) SNothing (SJust _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SJust _) SNothing
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SJust a) (SJust b)
+        = case (%~) a b of {
+            Proved Refl -> Proved Refl
+            Disproved contra
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+    instance SingI Nothing where
+      sing = SNothing
+    instance SingI n => SingI (Just (n :: a)) where
+      sing = SJust sing
diff --git a/tests/compile-and-dump/Singletons/Maybe.ghc78.template b/tests/compile-and-dump/Singletons/Maybe.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Maybe.ghc78.template
+++ /dev/null
@@ -1,67 +0,0 @@
-Singletons/Maybe.hs:0:0: Splicing declarations
-    singletons
-      [d| data Maybe a
-            = Nothing | Just a
-            deriving (Eq, Show) |]
-  ======>
-    Singletons/Maybe.hs:(0,0)-(0,0)
-    data Maybe a
-      = Nothing | Just a
-      deriving (Eq, Show)
-    type family Equals_0123456789 (a :: Maybe k)
-                                  (b :: Maybe k) :: Bool where
-      Equals_0123456789 Nothing Nothing = TrueSym0
-      Equals_0123456789 (Just a) (Just b) = (:==) a b
-      Equals_0123456789 (a :: Maybe k) (b :: Maybe k) = FalseSym0
-    instance PEq (KProxy :: KProxy (Maybe k)) where
-      type (:==) (a :: Maybe k) (b :: Maybe k) = Equals_0123456789 a b
-    type NothingSym0 = Nothing
-    type JustSym1 (t :: a) = Just t
-    instance SuppressUnusedWarnings JustSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) JustSym0KindInference GHC.Tuple.())
-    data JustSym0 (l :: TyFun a (Maybe a))
-      = forall arg. KindOf (Apply JustSym0 arg) ~ KindOf (JustSym1 arg) =>
-        JustSym0KindInference
-    type instance Apply JustSym0 l = JustSym1 l
-    data instance Sing (z :: Maybe a)
-      = z ~ Nothing => SNothing |
-        forall (n :: a). z ~ Just n => SJust (Sing n)
-    type SMaybe (z :: Maybe a) = Sing z
-    instance SingKind (KProxy :: KProxy a) =>
-             SingKind (KProxy :: KProxy (Maybe a)) where
-      type DemoteRep (KProxy :: KProxy (Maybe a)) = Maybe (DemoteRep (KProxy :: KProxy a))
-      fromSing SNothing = Nothing
-      fromSing (SJust b) = Just (fromSing b)
-      toSing Nothing = SomeSing SNothing
-      toSing (Just b)
-        = case toSing b :: SomeSing (KProxy :: KProxy a) of {
-            SomeSing c -> SomeSing (SJust c) }
-    instance SEq (KProxy :: KProxy a) =>
-             SEq (KProxy :: KProxy (Maybe a)) where
-      (%:==) SNothing SNothing = STrue
-      (%:==) SNothing (SJust _) = SFalse
-      (%:==) (SJust _) SNothing = SFalse
-      (%:==) (SJust a) (SJust b) = (%:==) a b
-    instance SDecide (KProxy :: KProxy a) =>
-             SDecide (KProxy :: KProxy (Maybe a)) where
-      (%~) SNothing SNothing = Proved Refl
-      (%~) SNothing (SJust _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SJust _) SNothing
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SJust a) (SJust b)
-        = case (%~) a b of {
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
-    instance SingI Nothing where
-      sing = SNothing
-    instance SingI n => SingI (Just (n :: a)) where
-      sing = SJust sing
diff --git a/tests/compile-and-dump/Singletons/Nat.ghc710.template b/tests/compile-and-dump/Singletons/Nat.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Nat.ghc710.template
@@ -0,0 +1,143 @@
+Singletons/Nat.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| plus :: Nat -> Nat -> Nat
+          plus Zero m = m
+          plus (Succ n) m = Succ (plus n m)
+          pred :: Nat -> Nat
+          pred Zero = Zero
+          pred (Succ n) = n
+          
+          data Nat
+            where
+              Zero :: Nat
+              Succ :: Nat -> Nat
+            deriving (Eq, Show, Read) |]
+  ======>
+    data Nat
+      = Zero | Succ Nat
+      deriving (Eq, Show, Read)
+    plus :: Nat -> Nat -> Nat
+    plus Zero m = m
+    plus (Succ n) m = Succ (plus n m)
+    pred :: Nat -> Nat
+    pred Zero = Zero
+    pred (Succ n) = n
+    type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where
+      Equals_0123456789 Zero Zero = TrueSym0
+      Equals_0123456789 (Succ a) (Succ b) = (:==) a b
+      Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0
+    instance PEq (KProxy :: KProxy Nat) where
+      type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b
+    type ZeroSym0 = Zero
+    type SuccSym1 (t :: Nat) = Succ t
+    instance SuppressUnusedWarnings SuccSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
+    data SuccSym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
+        SuccSym0KindInference
+    type instance Apply SuccSym0 l = SuccSym1 l
+    type PredSym1 (t :: Nat) = Pred t
+    instance SuppressUnusedWarnings PredSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PredSym0KindInference GHC.Tuple.())
+    data PredSym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply PredSym0 arg) ~ KindOf (PredSym1 arg) =>
+        PredSym0KindInference
+    type instance Apply PredSym0 l = PredSym1 l
+    type PlusSym2 (t :: Nat) (t :: Nat) = Plus t t
+    instance SuppressUnusedWarnings PlusSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PlusSym1KindInference GHC.Tuple.())
+    data PlusSym1 (l :: Nat) (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply (PlusSym1 l) arg) ~ KindOf (PlusSym2 l arg) =>
+        PlusSym1KindInference
+    type instance Apply (PlusSym1 l) l = PlusSym2 l l
+    instance SuppressUnusedWarnings PlusSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PlusSym0KindInference GHC.Tuple.())
+    data PlusSym0 (l :: TyFun Nat (TyFun Nat Nat -> *))
+      = forall arg. KindOf (Apply PlusSym0 arg) ~ KindOf (PlusSym1 arg) =>
+        PlusSym0KindInference
+    type instance Apply PlusSym0 l = PlusSym1 l
+    type family Pred (a :: Nat) :: Nat where
+      Pred Zero = ZeroSym0
+      Pred (Succ n) = n
+    type family Plus (a :: Nat) (a :: Nat) :: Nat where
+      Plus Zero m = m
+      Plus (Succ n) m = Apply SuccSym0 (Apply (Apply PlusSym0 n) m)
+    sPred ::
+      forall (t :: Nat). Sing t -> Sing (Apply PredSym0 t :: Nat)
+    sPlus ::
+      forall (t :: Nat) (t :: Nat).
+      Sing t -> Sing t -> Sing (Apply (Apply PlusSym0 t) t :: Nat)
+    sPred SZero
+      = let
+          lambda :: t ~ ZeroSym0 => Sing (Apply PredSym0 ZeroSym0 :: Nat)
+          lambda = SZero
+        in lambda
+    sPred (SSucc sN)
+      = let
+          lambda ::
+            forall n. t ~ Apply SuccSym0 n =>
+            Sing n -> Sing (Apply PredSym0 (Apply SuccSym0 n) :: Nat)
+          lambda n = n
+        in lambda sN
+    sPlus SZero sM
+      = let
+          lambda ::
+            forall m. (t ~ ZeroSym0, t ~ m) =>
+            Sing m -> Sing (Apply (Apply PlusSym0 ZeroSym0) m :: Nat)
+          lambda m = m
+        in lambda sM
+    sPlus (SSucc sN) sM
+      = let
+          lambda ::
+            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
+            Sing n
+            -> Sing m
+               -> Sing (Apply (Apply PlusSym0 (Apply SuccSym0 n)) m :: Nat)
+          lambda n m
+            = applySing
+                (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                (applySing
+                   (applySing (singFun2 (Proxy :: Proxy PlusSym0) sPlus) n) m)
+        in lambda sN sM
+    data instance Sing (z :: Nat)
+      = z ~ Zero => SZero |
+        forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat))
+    type SNat = (Sing :: Nat -> *)
+    instance SingKind (KProxy :: KProxy Nat) where
+      type DemoteRep (KProxy :: KProxy Nat) = Nat
+      fromSing SZero = Zero
+      fromSing (SSucc b) = Succ (fromSing b)
+      toSing Zero = SomeSing SZero
+      toSing (Succ b)
+        = case toSing b :: SomeSing (KProxy :: KProxy Nat) of {
+            SomeSing c -> SomeSing (SSucc c) }
+    instance SEq (KProxy :: KProxy Nat) where
+      (%:==) SZero SZero = STrue
+      (%:==) SZero (SSucc _) = SFalse
+      (%:==) (SSucc _) SZero = SFalse
+      (%:==) (SSucc a) (SSucc b) = (%:==) a b
+    instance SDecide (KProxy :: KProxy Nat) where
+      (%~) SZero SZero = Proved Refl
+      (%~) SZero (SSucc _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SSucc _) SZero
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SSucc a) (SSucc b)
+        = case (%~) a b of {
+            Proved Refl -> Proved Refl
+            Disproved contra
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+    instance SingI Zero where
+      sing = SZero
+    instance SingI n => SingI (Succ (n :: Nat)) where
+      sing = SSucc sing
diff --git a/tests/compile-and-dump/Singletons/Nat.ghc78.template b/tests/compile-and-dump/Singletons/Nat.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Nat.ghc78.template
+++ /dev/null
@@ -1,142 +0,0 @@
-Singletons/Nat.hs:0:0: Splicing declarations
-    singletons
-      [d| plus :: Nat -> Nat -> Nat
-          plus Zero m = m
-          plus (Succ n) m = Succ (plus n m)
-          pred :: Nat -> Nat
-          pred Zero = Zero
-          pred (Succ n) = n
-          
-          data Nat
-            where
-              Zero :: Nat
-              Succ :: Nat -> Nat
-            deriving (Eq, Show, Read) |]
-  ======>
-    Singletons/Nat.hs:(0,0)-(0,0)
-    data Nat
-      = Zero | Succ Nat
-      deriving (Eq, Show, Read)
-    plus :: Nat -> Nat -> Nat
-    plus Zero m = m
-    plus (Succ n) m = Succ (plus n m)
-    pred :: Nat -> Nat
-    pred Zero = Zero
-    pred (Succ n) = n
-    type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where
-      Equals_0123456789 Zero Zero = TrueSym0
-      Equals_0123456789 (Succ a) (Succ b) = (:==) a b
-      Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0
-    instance PEq (KProxy :: KProxy Nat) where
-      type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b
-    type ZeroSym0 = Zero
-    type SuccSym1 (t :: Nat) = Succ t
-    instance SuppressUnusedWarnings SuccSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
-    data SuccSym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
-        SuccSym0KindInference
-    type instance Apply SuccSym0 l = SuccSym1 l
-    type PredSym1 (t :: Nat) = Pred t
-    instance SuppressUnusedWarnings PredSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PredSym0KindInference GHC.Tuple.())
-    data PredSym0 (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply PredSym0 arg) ~ KindOf (PredSym1 arg) =>
-        PredSym0KindInference
-    type instance Apply PredSym0 l = PredSym1 l
-    type PlusSym2 (t :: Nat) (t :: Nat) = Plus t t
-    instance SuppressUnusedWarnings PlusSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PlusSym1KindInference GHC.Tuple.())
-    data PlusSym1 (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (PlusSym1 l) arg) ~ KindOf (PlusSym2 l arg) =>
-        PlusSym1KindInference
-    type instance Apply (PlusSym1 l) l = PlusSym2 l l
-    instance SuppressUnusedWarnings PlusSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PlusSym0KindInference GHC.Tuple.())
-    data PlusSym0 (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply PlusSym0 arg) ~ KindOf (PlusSym1 arg) =>
-        PlusSym0KindInference
-    type instance Apply PlusSym0 l = PlusSym1 l
-    type family Pred (a :: Nat) :: Nat where
-      Pred Zero = ZeroSym0
-      Pred (Succ n) = n
-    type family Plus (a :: Nat) (a :: Nat) :: Nat where
-      Plus Zero m = m
-      Plus (Succ n) m = Apply SuccSym0 (Apply (Apply PlusSym0 n) m)
-    sPred :: forall (t :: Nat). Sing t -> Sing (Apply PredSym0 t)
-    sPlus ::
-      forall (t :: Nat) (t :: Nat).
-      Sing t -> Sing t -> Sing (Apply (Apply PlusSym0 t) t)
-    sPred SZero
-      = let
-          lambda :: t ~ ZeroSym0 => Sing (Apply PredSym0 ZeroSym0)
-          lambda = SZero
-        in lambda
-    sPred (SSucc sN)
-      = let
-          lambda ::
-            forall n. t ~ Apply SuccSym0 n =>
-            Sing n -> Sing (Apply PredSym0 (Apply SuccSym0 n))
-          lambda n = n
-        in lambda sN
-    sPlus SZero sM
-      = let
-          lambda ::
-            forall m. (t ~ ZeroSym0, t ~ m) =>
-            Sing m -> Sing (Apply (Apply PlusSym0 ZeroSym0) m)
-          lambda m = m
-        in lambda sM
-    sPlus (SSucc sN) sM
-      = let
-          lambda ::
-            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
-            Sing n
-            -> Sing m -> Sing (Apply (Apply PlusSym0 (Apply SuccSym0 n)) m)
-          lambda n m
-            = applySing
-                (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                (applySing
-                   (applySing (singFun2 (Proxy :: Proxy PlusSym0) sPlus) n) m)
-        in lambda sN sM
-    data instance Sing (z :: Nat)
-      = z ~ Zero => SZero |
-        forall (n :: Nat). z ~ Succ n => SSucc (Sing n)
-    type SNat (z :: Nat) = Sing z
-    instance SingKind (KProxy :: KProxy Nat) where
-      type DemoteRep (KProxy :: KProxy Nat) = Nat
-      fromSing SZero = Zero
-      fromSing (SSucc b) = Succ (fromSing b)
-      toSing Zero = SomeSing SZero
-      toSing (Succ b)
-        = case toSing b :: SomeSing (KProxy :: KProxy Nat) of {
-            SomeSing c -> SomeSing (SSucc c) }
-    instance SEq (KProxy :: KProxy Nat) where
-      (%:==) SZero SZero = STrue
-      (%:==) SZero (SSucc _) = SFalse
-      (%:==) (SSucc _) SZero = SFalse
-      (%:==) (SSucc a) (SSucc b) = (%:==) a b
-    instance SDecide (KProxy :: KProxy Nat) where
-      (%~) SZero SZero = Proved Refl
-      (%~) SZero (SSucc _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SSucc _) SZero
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SSucc a) (SSucc b)
-        = case (%~) a b of {
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
-    instance SingI Zero where
-      sing = SZero
-    instance SingI n => SingI (Succ (n :: Nat)) where
-      sing = SSucc sing
diff --git a/tests/compile-and-dump/Singletons/Operators.ghc710.template b/tests/compile-and-dump/Singletons/Operators.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Operators.ghc710.template
@@ -0,0 +1,125 @@
+Singletons/Operators.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| child :: Foo -> Foo
+          child FLeaf = FLeaf
+          child (a :+: _) = a
+          (+) :: Nat -> Nat -> Nat
+          Zero + m = m
+          (Succ n) + m = Succ (n + m)
+          
+          data Foo
+            where
+              FLeaf :: Foo
+              :+: :: Foo -> Foo -> Foo |]
+  ======>
+    data Foo = FLeaf | :+: Foo Foo
+    child :: Foo -> Foo
+    child FLeaf = FLeaf
+    child (a :+: _) = a
+    (+) :: Nat -> Nat -> Nat
+    (+) Zero m = m
+    (+) (Succ n) m = Succ (n + m)
+    type FLeafSym0 = FLeaf
+    type (:+:$$$) (t :: Foo) (t :: Foo) = (:+:) t t
+    instance SuppressUnusedWarnings (:+:$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+:$$###) GHC.Tuple.())
+    data (:+:$$) (l :: Foo) (l :: TyFun Foo Foo)
+      = forall arg. KindOf (Apply ((:+:$$) l) arg) ~ KindOf ((:+:$$$) l arg) =>
+        :+:$$###
+    type instance Apply ((:+:$$) l) l = (:+:$$$) l l
+    instance SuppressUnusedWarnings (:+:$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+:$###) GHC.Tuple.())
+    data (:+:$) (l :: TyFun Foo (TyFun Foo Foo -> *))
+      = forall arg. KindOf (Apply (:+:$) arg) ~ KindOf ((:+:$$) arg) =>
+        :+:$###
+    type instance Apply (:+:$) l = (:+:$$) l
+    type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
+    instance SuppressUnusedWarnings (:+$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
+    data (:+$$) (l :: Nat) (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) =>
+        :+$$###
+    type instance Apply ((:+$$) l) l = (:+$$$) l l
+    instance SuppressUnusedWarnings (:+$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
+    data (:+$) (l :: TyFun Nat (TyFun Nat Nat -> *))
+      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
+        :+$###
+    type instance Apply (:+$) l = (:+$$) l
+    type ChildSym1 (t :: Foo) = Child t
+    instance SuppressUnusedWarnings ChildSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ChildSym0KindInference GHC.Tuple.())
+    data ChildSym0 (l :: TyFun Foo Foo)
+      = forall arg. KindOf (Apply ChildSym0 arg) ~ KindOf (ChildSym1 arg) =>
+        ChildSym0KindInference
+    type instance Apply ChildSym0 l = ChildSym1 l
+    type family (:+) (a :: Nat) (a :: Nat) :: Nat where
+      (:+) Zero m = m
+      (:+) (Succ n) m = Apply SuccSym0 (Apply (Apply (:+$) n) m)
+    type family Child (a :: Foo) :: Foo where
+      Child FLeaf = FLeafSym0
+      Child ((:+:) a _z_0123456789) = a
+    (%:+) ::
+      forall (t :: Nat) (t :: Nat).
+      Sing t -> Sing t -> Sing (Apply (Apply (:+$) t) t :: Nat)
+    sChild ::
+      forall (t :: Foo). Sing t -> Sing (Apply ChildSym0 t :: Foo)
+    (%:+) SZero sM
+      = let
+          lambda ::
+            forall m. (t ~ ZeroSym0, t ~ m) =>
+            Sing m -> Sing (Apply (Apply (:+$) ZeroSym0) m :: Nat)
+          lambda m = m
+        in lambda sM
+    (%:+) (SSucc sN) sM
+      = let
+          lambda ::
+            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
+            Sing n
+            -> Sing m -> Sing (Apply (Apply (:+$) (Apply SuccSym0 n)) m :: Nat)
+          lambda n m
+            = applySing
+                (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                (applySing (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) n) m)
+        in lambda sN sM
+    sChild SFLeaf
+      = let
+          lambda :: t ~ FLeafSym0 => Sing (Apply ChildSym0 FLeafSym0 :: Foo)
+          lambda = SFLeaf
+        in lambda
+    sChild ((:%+:) sA _s_z_0123456789)
+      = let
+          lambda ::
+            forall a _z_0123456789. t ~ Apply (Apply (:+:$) a) _z_0123456789 =>
+            Sing a
+            -> Sing _z_0123456789
+               -> Sing (Apply ChildSym0 (Apply (Apply (:+:$) a) _z_0123456789) :: Foo)
+          lambda a _z_0123456789 = a
+        in lambda sA _s_z_0123456789
+    data instance Sing (z :: Foo)
+      = z ~ FLeaf => SFLeaf |
+        forall (n :: Foo) (n :: Foo). z ~ (:+:) n n =>
+        :%+: (Sing (n :: Foo)) (Sing (n :: Foo))
+    type SFoo = (Sing :: Foo -> *)
+    instance SingKind (KProxy :: KProxy Foo) where
+      type DemoteRep (KProxy :: KProxy Foo) = Foo
+      fromSing SFLeaf = FLeaf
+      fromSing ((:%+:) b b) = (:+:) (fromSing b) (fromSing b)
+      toSing FLeaf = SomeSing SFLeaf
+      toSing ((:+:) b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy Foo))
+                (toSing b :: SomeSing (KProxy :: KProxy Foo))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing ((:%+:) c c) }
+    instance SingI FLeaf where
+      sing = SFLeaf
+    instance (SingI n, SingI n) =>
+             SingI ((:+:) (n :: Foo) (n :: Foo)) where
+      sing = (:%+:) sing sing
diff --git a/tests/compile-and-dump/Singletons/Operators.ghc78.template b/tests/compile-and-dump/Singletons/Operators.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Operators.ghc78.template
+++ /dev/null
@@ -1,122 +0,0 @@
-Singletons/Operators.hs:0:0: Splicing declarations
-    singletons
-      [d| child :: Foo -> Foo
-          child FLeaf = FLeaf
-          child (a :+: _) = a
-          (+) :: Nat -> Nat -> Nat
-          Zero + m = m
-          (Succ n) + m = Succ (n + m)
-          
-          data Foo
-            where
-              FLeaf :: Foo
-              :+: :: Foo -> Foo -> Foo |]
-  ======>
-    Singletons/Operators.hs:(0,0)-(0,0)
-    data Foo = FLeaf | (:+:) Foo Foo
-    child :: Foo -> Foo
-    child FLeaf = FLeaf
-    child (a :+: _) = a
-    (+) :: Nat -> Nat -> Nat
-    (+) Zero m = m
-    (+) (Succ n) m = Succ (n + m)
-    type FLeafSym0 = FLeaf
-    type (:+:$$$) (t :: Foo) (t :: Foo) = (:+:) t t
-    instance SuppressUnusedWarnings (:+:$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+:$$###) GHC.Tuple.())
-    data (:+:$$) (l :: Foo) (l :: TyFun Foo Foo)
-      = forall arg. KindOf (Apply ((:+:$$) l) arg) ~ KindOf ((:+:$$$) l arg) =>
-        (:+:$$###)
-    type instance Apply ((:+:$$) l) l = (:+:$$$) l l
-    instance SuppressUnusedWarnings (:+:$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+:$###) GHC.Tuple.())
-    data (:+:$) (l :: TyFun Foo (TyFun Foo Foo -> *))
-      = forall arg. KindOf (Apply (:+:$) arg) ~ KindOf ((:+:$$) arg) =>
-        (:+:$###)
-    type instance Apply (:+:$) l = (:+:$$) l
-    type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
-    instance SuppressUnusedWarnings (:+$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
-    data (:+$$) (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) =>
-        (:+$$###)
-    type instance Apply ((:+$$) l) l = (:+$$$) l l
-    instance SuppressUnusedWarnings (:+$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
-    data (:+$) (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
-        (:+$###)
-    type instance Apply (:+$) l = (:+$$) l
-    type ChildSym1 (t :: Foo) = Child t
-    instance SuppressUnusedWarnings ChildSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ChildSym0KindInference GHC.Tuple.())
-    data ChildSym0 (l :: TyFun Foo Foo)
-      = forall arg. KindOf (Apply ChildSym0 arg) ~ KindOf (ChildSym1 arg) =>
-        ChildSym0KindInference
-    type instance Apply ChildSym0 l = ChildSym1 l
-    type family (:+) (a :: Nat) (a :: Nat) :: Nat where
-      (:+) Zero m = m
-      (:+) (Succ n) m = Apply SuccSym0 (Apply (Apply (:+$) n) m)
-    type family Child (a :: Foo) :: Foo where
-      Child FLeaf = FLeafSym0
-      Child ((:+:) a z) = a
-    (%:+) ::
-      forall (t :: Nat) (t :: Nat).
-      Sing t -> Sing t -> Sing (Apply (Apply (:+$) t) t)
-    sChild :: forall (t :: Foo). Sing t -> Sing (Apply ChildSym0 t)
-    (%:+) SZero sM
-      = let
-          lambda ::
-            forall m. (t ~ ZeroSym0, t ~ m) =>
-            Sing m -> Sing (Apply (Apply (:+$) ZeroSym0) m)
-          lambda m = m
-        in lambda sM
-    (%:+) (SSucc sN) sM
-      = let
-          lambda ::
-            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
-            Sing n -> Sing m -> Sing (Apply (Apply (:+$) (Apply SuccSym0 n)) m)
-          lambda n m
-            = applySing
-                (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                (applySing (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) n) m)
-        in lambda sN sM
-    sChild SFLeaf
-      = let
-          lambda :: t ~ FLeafSym0 => Sing (Apply ChildSym0 FLeafSym0)
-          lambda = SFLeaf
-        in lambda
-    sChild ((:%+:) sA _)
-      = let
-          lambda ::
-            forall a wild. t ~ Apply (Apply (:+:$) a) wild =>
-            Sing a -> Sing (Apply ChildSym0 (Apply (Apply (:+:$) a) wild))
-          lambda a = a
-        in lambda sA
-    data instance Sing (z :: Foo)
-      = z ~ FLeaf => SFLeaf |
-        forall (n :: Foo) (n :: Foo). z ~ (:+:) n n =>
-        (:%+:) (Sing n) (Sing n)
-    type SFoo (z :: Foo) = Sing z
-    instance SingKind (KProxy :: KProxy Foo) where
-      type DemoteRep (KProxy :: KProxy Foo) = Foo
-      fromSing SFLeaf = FLeaf
-      fromSing ((:%+:) b b) = (:+:) (fromSing b) (fromSing b)
-      toSing FLeaf = SomeSing SFLeaf
-      toSing ((:+:) b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy Foo))
-                (toSing b :: SomeSing (KProxy :: KProxy Foo))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing ((:%+:) c c) }
-    instance SingI FLeaf where
-      sing = SFLeaf
-    instance (SingI n, SingI n) =>
-             SingI ((:+:) (n :: Foo) (n :: Foo)) where
-      sing = (:%+:) sing sing
diff --git a/tests/compile-and-dump/Singletons/OrdDeriving.ghc710.template b/tests/compile-and-dump/Singletons/OrdDeriving.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/OrdDeriving.ghc710.template
@@ -0,0 +1,2830 @@
+Singletons/OrdDeriving.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data Nat
+            = Zero | Succ Nat
+            deriving (Eq, Ord)
+          data Foo a b c d
+            = A a b c d |
+              B a b c d |
+              C a b c d |
+              D a b c d |
+              E a b c d |
+              F a b c d
+            deriving (Eq, Ord) |]
+  ======>
+    data Nat
+      = Zero | Succ Nat
+      deriving (Eq, Ord)
+    data Foo a b c d
+      = A a b c d |
+        B a b c d |
+        C a b c d |
+        D a b c d |
+        E a b c d |
+        F a b c d
+      deriving (Eq, Ord)
+    type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where
+      Equals_0123456789 Zero Zero = TrueSym0
+      Equals_0123456789 (Succ a) (Succ b) = (:==) a b
+      Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0
+    instance PEq (KProxy :: KProxy Nat) where
+      type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b
+    type ZeroSym0 = Zero
+    type SuccSym1 (t :: Nat) = Succ t
+    instance SuppressUnusedWarnings SuccSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.())
+    data SuccSym0 (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) =>
+        SuccSym0KindInference
+    type instance Apply SuccSym0 l = SuccSym1 l
+    type family Equals_0123456789 (a :: Foo k k k k)
+                                  (b :: Foo k k k k) :: Bool where
+      Equals_0123456789 (A a a a a) (A b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
+      Equals_0123456789 (B a a a a) (B b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
+      Equals_0123456789 (C a a a a) (C b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
+      Equals_0123456789 (D a a a a) (D b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
+      Equals_0123456789 (E a a a a) (E b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
+      Equals_0123456789 (F a a a a) (F b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b)))
+      Equals_0123456789 (a :: Foo k k k k) (b :: Foo k k k k) = FalseSym0
+    instance PEq (KProxy :: KProxy (Foo k k k k)) where
+      type (:==) (a :: Foo k k k k) (b :: Foo k k k k) = Equals_0123456789 a b
+    type ASym4 (t :: a) (t :: b) (t :: c) (t :: d) = A t t t t
+    instance SuppressUnusedWarnings ASym3 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ASym3KindInference GHC.Tuple.())
+    data ASym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
+      = forall arg. KindOf (Apply (ASym3 l l l) arg) ~ KindOf (ASym4 l l l arg) =>
+        ASym3KindInference
+    type instance Apply (ASym3 l l l) l = ASym4 l l l l
+    instance SuppressUnusedWarnings ASym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ASym2KindInference GHC.Tuple.())
+    data ASym2 (l :: a)
+               (l :: b)
+               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
+      = forall arg. KindOf (Apply (ASym2 l l) arg) ~ KindOf (ASym3 l l arg) =>
+        ASym2KindInference
+    type instance Apply (ASym2 l l) l = ASym3 l l l
+    instance SuppressUnusedWarnings ASym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ASym1KindInference GHC.Tuple.())
+    data ASym1 (l :: a)
+               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
+      = forall arg. KindOf (Apply (ASym1 l) arg) ~ KindOf (ASym2 l arg) =>
+        ASym1KindInference
+    type instance Apply (ASym1 l) l = ASym2 l l
+    instance SuppressUnusedWarnings ASym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ASym0KindInference GHC.Tuple.())
+    data ASym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
+                                                -> *)
+                                       -> *)
+                              -> *))
+      = forall arg. KindOf (Apply ASym0 arg) ~ KindOf (ASym1 arg) =>
+        ASym0KindInference
+    type instance Apply ASym0 l = ASym1 l
+    type BSym4 (t :: a) (t :: b) (t :: c) (t :: d) = B t t t t
+    instance SuppressUnusedWarnings BSym3 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BSym3KindInference GHC.Tuple.())
+    data BSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
+      = forall arg. KindOf (Apply (BSym3 l l l) arg) ~ KindOf (BSym4 l l l arg) =>
+        BSym3KindInference
+    type instance Apply (BSym3 l l l) l = BSym4 l l l l
+    instance SuppressUnusedWarnings BSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BSym2KindInference GHC.Tuple.())
+    data BSym2 (l :: a)
+               (l :: b)
+               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
+      = forall arg. KindOf (Apply (BSym2 l l) arg) ~ KindOf (BSym3 l l arg) =>
+        BSym2KindInference
+    type instance Apply (BSym2 l l) l = BSym3 l l l
+    instance SuppressUnusedWarnings BSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BSym1KindInference GHC.Tuple.())
+    data BSym1 (l :: a)
+               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
+      = forall arg. KindOf (Apply (BSym1 l) arg) ~ KindOf (BSym2 l arg) =>
+        BSym1KindInference
+    type instance Apply (BSym1 l) l = BSym2 l l
+    instance SuppressUnusedWarnings BSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BSym0KindInference GHC.Tuple.())
+    data BSym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
+                                                -> *)
+                                       -> *)
+                              -> *))
+      = forall arg. KindOf (Apply BSym0 arg) ~ KindOf (BSym1 arg) =>
+        BSym0KindInference
+    type instance Apply BSym0 l = BSym1 l
+    type CSym4 (t :: a) (t :: b) (t :: c) (t :: d) = C t t t t
+    instance SuppressUnusedWarnings CSym3 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) CSym3KindInference GHC.Tuple.())
+    data CSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
+      = forall arg. KindOf (Apply (CSym3 l l l) arg) ~ KindOf (CSym4 l l l arg) =>
+        CSym3KindInference
+    type instance Apply (CSym3 l l l) l = CSym4 l l l l
+    instance SuppressUnusedWarnings CSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) CSym2KindInference GHC.Tuple.())
+    data CSym2 (l :: a)
+               (l :: b)
+               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
+      = forall arg. KindOf (Apply (CSym2 l l) arg) ~ KindOf (CSym3 l l arg) =>
+        CSym2KindInference
+    type instance Apply (CSym2 l l) l = CSym3 l l l
+    instance SuppressUnusedWarnings CSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) CSym1KindInference GHC.Tuple.())
+    data CSym1 (l :: a)
+               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
+      = forall arg. KindOf (Apply (CSym1 l) arg) ~ KindOf (CSym2 l arg) =>
+        CSym1KindInference
+    type instance Apply (CSym1 l) l = CSym2 l l
+    instance SuppressUnusedWarnings CSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) CSym0KindInference GHC.Tuple.())
+    data CSym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
+                                                -> *)
+                                       -> *)
+                              -> *))
+      = forall arg. KindOf (Apply CSym0 arg) ~ KindOf (CSym1 arg) =>
+        CSym0KindInference
+    type instance Apply CSym0 l = CSym1 l
+    type DSym4 (t :: a) (t :: b) (t :: c) (t :: d) = D t t t t
+    instance SuppressUnusedWarnings DSym3 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) DSym3KindInference GHC.Tuple.())
+    data DSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
+      = forall arg. KindOf (Apply (DSym3 l l l) arg) ~ KindOf (DSym4 l l l arg) =>
+        DSym3KindInference
+    type instance Apply (DSym3 l l l) l = DSym4 l l l l
+    instance SuppressUnusedWarnings DSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) DSym2KindInference GHC.Tuple.())
+    data DSym2 (l :: a)
+               (l :: b)
+               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
+      = forall arg. KindOf (Apply (DSym2 l l) arg) ~ KindOf (DSym3 l l arg) =>
+        DSym2KindInference
+    type instance Apply (DSym2 l l) l = DSym3 l l l
+    instance SuppressUnusedWarnings DSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) DSym1KindInference GHC.Tuple.())
+    data DSym1 (l :: a)
+               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
+      = forall arg. KindOf (Apply (DSym1 l) arg) ~ KindOf (DSym2 l arg) =>
+        DSym1KindInference
+    type instance Apply (DSym1 l) l = DSym2 l l
+    instance SuppressUnusedWarnings DSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) DSym0KindInference GHC.Tuple.())
+    data DSym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
+                                                -> *)
+                                       -> *)
+                              -> *))
+      = forall arg. KindOf (Apply DSym0 arg) ~ KindOf (DSym1 arg) =>
+        DSym0KindInference
+    type instance Apply DSym0 l = DSym1 l
+    type ESym4 (t :: a) (t :: b) (t :: c) (t :: d) = E t t t t
+    instance SuppressUnusedWarnings ESym3 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ESym3KindInference GHC.Tuple.())
+    data ESym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
+      = forall arg. KindOf (Apply (ESym3 l l l) arg) ~ KindOf (ESym4 l l l arg) =>
+        ESym3KindInference
+    type instance Apply (ESym3 l l l) l = ESym4 l l l l
+    instance SuppressUnusedWarnings ESym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ESym2KindInference GHC.Tuple.())
+    data ESym2 (l :: a)
+               (l :: b)
+               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
+      = forall arg. KindOf (Apply (ESym2 l l) arg) ~ KindOf (ESym3 l l arg) =>
+        ESym2KindInference
+    type instance Apply (ESym2 l l) l = ESym3 l l l
+    instance SuppressUnusedWarnings ESym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ESym1KindInference GHC.Tuple.())
+    data ESym1 (l :: a)
+               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
+      = forall arg. KindOf (Apply (ESym1 l) arg) ~ KindOf (ESym2 l arg) =>
+        ESym1KindInference
+    type instance Apply (ESym1 l) l = ESym2 l l
+    instance SuppressUnusedWarnings ESym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ESym0KindInference GHC.Tuple.())
+    data ESym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
+                                                -> *)
+                                       -> *)
+                              -> *))
+      = forall arg. KindOf (Apply ESym0 arg) ~ KindOf (ESym1 arg) =>
+        ESym0KindInference
+    type instance Apply ESym0 l = ESym1 l
+    type FSym4 (t :: a) (t :: b) (t :: c) (t :: d) = F t t t t
+    instance SuppressUnusedWarnings FSym3 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FSym3KindInference GHC.Tuple.())
+    data FSym3 (l :: a) (l :: b) (l :: c) (l :: TyFun d (Foo a b c d))
+      = forall arg. KindOf (Apply (FSym3 l l l) arg) ~ KindOf (FSym4 l l l arg) =>
+        FSym3KindInference
+    type instance Apply (FSym3 l l l) l = FSym4 l l l l
+    instance SuppressUnusedWarnings FSym2 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FSym2KindInference GHC.Tuple.())
+    data FSym2 (l :: a)
+               (l :: b)
+               (l :: TyFun c (TyFun d (Foo a b c d) -> *))
+      = forall arg. KindOf (Apply (FSym2 l l) arg) ~ KindOf (FSym3 l l arg) =>
+        FSym2KindInference
+    type instance Apply (FSym2 l l) l = FSym3 l l l
+    instance SuppressUnusedWarnings FSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FSym1KindInference GHC.Tuple.())
+    data FSym1 (l :: a)
+               (l :: TyFun b (TyFun c (TyFun d (Foo a b c d) -> *) -> *))
+      = forall arg. KindOf (Apply (FSym1 l) arg) ~ KindOf (FSym2 l arg) =>
+        FSym1KindInference
+    type instance Apply (FSym1 l) l = FSym2 l l
+    instance SuppressUnusedWarnings FSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FSym0KindInference GHC.Tuple.())
+    data FSym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (Foo a b c d)
+                                                -> *)
+                                       -> *)
+                              -> *))
+      = forall arg. KindOf (Apply FSym0 arg) ~ KindOf (FSym1 arg) =>
+        FSym0KindInference
+    type instance Apply FSym0 l = FSym1 l
+    type family Compare_0123456789 (a :: Nat)
+                                   (a :: Nat) :: Ordering where
+      Compare_0123456789 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]
+      Compare_0123456789 (Succ a_0123456789) (Succ b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])
+      Compare_0123456789 Zero (Succ _z_0123456789) = LTSym0
+      Compare_0123456789 (Succ _z_0123456789) Zero = GTSym0
+    type Compare_0123456789Sym2 (t :: Nat) (t :: Nat) =
+        Compare_0123456789 t t
+    instance SuppressUnusedWarnings Compare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.())
+    data Compare_0123456789Sym1 (l :: Nat) (l :: TyFun Nat Ordering)
+      = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) =>
+        Compare_0123456789Sym1KindInference
+    type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Compare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.())
+    data Compare_0123456789Sym0 (l :: TyFun Nat (TyFun Nat Ordering
+                                                 -> *))
+      = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) =>
+        Compare_0123456789Sym0KindInference
+    type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l
+    instance POrd (KProxy :: KProxy Nat) where
+      type Compare (a :: Nat) (a :: Nat) = Apply (Apply Compare_0123456789Sym0 a) a
+    type family Compare_0123456789 (a :: Foo a b c d)
+                                   (a :: Foo a b c d) :: Ordering where
+      Compare_0123456789 (A a_0123456789 a_0123456789 a_0123456789 a_0123456789) (A b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]))))
+      Compare_0123456789 (B a_0123456789 a_0123456789 a_0123456789 a_0123456789) (B b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]))))
+      Compare_0123456789 (C a_0123456789 a_0123456789 a_0123456789 a_0123456789) (C b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]))))
+      Compare_0123456789 (D a_0123456789 a_0123456789 a_0123456789 a_0123456789) (D b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]))))
+      Compare_0123456789 (E a_0123456789 a_0123456789 a_0123456789 a_0123456789) (E b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]))))
+      Compare_0123456789 (F a_0123456789 a_0123456789 a_0123456789 a_0123456789) (F b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]))))
+      Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+      Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0
+    type Compare_0123456789Sym2 (t :: Foo a b c d) (t :: Foo a b c d) =
+        Compare_0123456789 t t
+    instance SuppressUnusedWarnings Compare_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.())
+    data Compare_0123456789Sym1 (l :: Foo a b c d)
+                                (l :: TyFun (Foo a b c d) Ordering)
+      = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) =>
+        Compare_0123456789Sym1KindInference
+    type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Compare_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.())
+    data Compare_0123456789Sym0 (l :: TyFun (Foo a b c d) (TyFun (Foo a b c d) Ordering
+                                                           -> *))
+      = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) =>
+        Compare_0123456789Sym0KindInference
+    type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l
+    instance POrd (KProxy :: KProxy (Foo a b c d)) where
+      type Compare (a :: Foo a b c d) (a :: Foo a b c d) = Apply (Apply Compare_0123456789Sym0 a) a
+    data instance Sing (z :: Nat)
+      = z ~ Zero => SZero |
+        forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat))
+    type SNat = (Sing :: Nat -> *)
+    instance SingKind (KProxy :: KProxy Nat) where
+      type DemoteRep (KProxy :: KProxy Nat) = Nat
+      fromSing SZero = Zero
+      fromSing (SSucc b) = Succ (fromSing b)
+      toSing Zero = SomeSing SZero
+      toSing (Succ b)
+        = case toSing b :: SomeSing (KProxy :: KProxy Nat) of {
+            SomeSing c -> SomeSing (SSucc c) }
+    instance SEq (KProxy :: KProxy Nat) where
+      (%:==) SZero SZero = STrue
+      (%:==) SZero (SSucc _) = SFalse
+      (%:==) (SSucc _) SZero = SFalse
+      (%:==) (SSucc a) (SSucc b) = (%:==) a b
+    instance SDecide (KProxy :: KProxy Nat) where
+      (%~) SZero SZero = Proved Refl
+      (%~) SZero (SSucc _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SSucc _) SZero
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SSucc a) (SSucc b)
+        = case (%~) a b of {
+            Proved Refl -> Proved Refl
+            Disproved contra
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+    data instance Sing (z :: Foo a b c d)
+      = forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ A n n n n =>
+        SA (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) |
+        forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ B n n n n =>
+        SB (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) |
+        forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ C n n n n =>
+        SC (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) |
+        forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ D n n n n =>
+        SD (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) |
+        forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ E n n n n =>
+        SE (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) |
+        forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ F n n n n =>
+        SF (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d))
+    type SFoo = (Sing :: Foo a b c d -> *)
+    instance (SingKind (KProxy :: KProxy a),
+              SingKind (KProxy :: KProxy b),
+              SingKind (KProxy :: KProxy c),
+              SingKind (KProxy :: KProxy d)) =>
+             SingKind (KProxy :: KProxy (Foo a b c d)) where
+      type DemoteRep (KProxy :: KProxy (Foo a b c d)) = Foo (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) (DemoteRep (KProxy :: KProxy c)) (DemoteRep (KProxy :: KProxy d))
+      fromSing (SA b b b b)
+        = A (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SB b b b b)
+        = B (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SC b b b b)
+        = C (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SD b b b b)
+        = D (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SE b b b b)
+        = E (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      fromSing (SF b b b b)
+        = F (fromSing b) (fromSing b) (fromSing b) (fromSing b)
+      toSing (A b b b b)
+        = case
+              GHC.Tuple.(,,,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+                (toSing b :: SomeSing (KProxy :: KProxy c))
+                (toSing b :: SomeSing (KProxy :: KProxy d))
+          of {
+            GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+              -> SomeSing (SA c c c c) }
+      toSing (B b b b b)
+        = case
+              GHC.Tuple.(,,,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+                (toSing b :: SomeSing (KProxy :: KProxy c))
+                (toSing b :: SomeSing (KProxy :: KProxy d))
+          of {
+            GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+              -> SomeSing (SB c c c c) }
+      toSing (C b b b b)
+        = case
+              GHC.Tuple.(,,,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+                (toSing b :: SomeSing (KProxy :: KProxy c))
+                (toSing b :: SomeSing (KProxy :: KProxy d))
+          of {
+            GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+              -> SomeSing (SC c c c c) }
+      toSing (D b b b b)
+        = case
+              GHC.Tuple.(,,,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+                (toSing b :: SomeSing (KProxy :: KProxy c))
+                (toSing b :: SomeSing (KProxy :: KProxy d))
+          of {
+            GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+              -> SomeSing (SD c c c c) }
+      toSing (E b b b b)
+        = case
+              GHC.Tuple.(,,,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+                (toSing b :: SomeSing (KProxy :: KProxy c))
+                (toSing b :: SomeSing (KProxy :: KProxy d))
+          of {
+            GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+              -> SomeSing (SE c c c c) }
+      toSing (F b b b b)
+        = case
+              GHC.Tuple.(,,,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+                (toSing b :: SomeSing (KProxy :: KProxy c))
+                (toSing b :: SomeSing (KProxy :: KProxy d))
+          of {
+            GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
+              -> SomeSing (SF c c c c) }
+    instance (SEq (KProxy :: KProxy a),
+              SEq (KProxy :: KProxy b),
+              SEq (KProxy :: KProxy c),
+              SEq (KProxy :: KProxy d)) =>
+             SEq (KProxy :: KProxy (Foo a b c d)) where
+      (%:==) (SA a a a a) (SA b b b b)
+        = (%:&&)
+            ((%:==) a b)
+            ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b)))
+      (%:==) (SA _ _ _ _) (SB _ _ _ _) = SFalse
+      (%:==) (SA _ _ _ _) (SC _ _ _ _) = SFalse
+      (%:==) (SA _ _ _ _) (SD _ _ _ _) = SFalse
+      (%:==) (SA _ _ _ _) (SE _ _ _ _) = SFalse
+      (%:==) (SA _ _ _ _) (SF _ _ _ _) = SFalse
+      (%:==) (SB _ _ _ _) (SA _ _ _ _) = SFalse
+      (%:==) (SB a a a a) (SB b b b b)
+        = (%:&&)
+            ((%:==) a b)
+            ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b)))
+      (%:==) (SB _ _ _ _) (SC _ _ _ _) = SFalse
+      (%:==) (SB _ _ _ _) (SD _ _ _ _) = SFalse
+      (%:==) (SB _ _ _ _) (SE _ _ _ _) = SFalse
+      (%:==) (SB _ _ _ _) (SF _ _ _ _) = SFalse
+      (%:==) (SC _ _ _ _) (SA _ _ _ _) = SFalse
+      (%:==) (SC _ _ _ _) (SB _ _ _ _) = SFalse
+      (%:==) (SC a a a a) (SC b b b b)
+        = (%:&&)
+            ((%:==) a b)
+            ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b)))
+      (%:==) (SC _ _ _ _) (SD _ _ _ _) = SFalse
+      (%:==) (SC _ _ _ _) (SE _ _ _ _) = SFalse
+      (%:==) (SC _ _ _ _) (SF _ _ _ _) = SFalse
+      (%:==) (SD _ _ _ _) (SA _ _ _ _) = SFalse
+      (%:==) (SD _ _ _ _) (SB _ _ _ _) = SFalse
+      (%:==) (SD _ _ _ _) (SC _ _ _ _) = SFalse
+      (%:==) (SD a a a a) (SD b b b b)
+        = (%:&&)
+            ((%:==) a b)
+            ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b)))
+      (%:==) (SD _ _ _ _) (SE _ _ _ _) = SFalse
+      (%:==) (SD _ _ _ _) (SF _ _ _ _) = SFalse
+      (%:==) (SE _ _ _ _) (SA _ _ _ _) = SFalse
+      (%:==) (SE _ _ _ _) (SB _ _ _ _) = SFalse
+      (%:==) (SE _ _ _ _) (SC _ _ _ _) = SFalse
+      (%:==) (SE _ _ _ _) (SD _ _ _ _) = SFalse
+      (%:==) (SE a a a a) (SE b b b b)
+        = (%:&&)
+            ((%:==) a b)
+            ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b)))
+      (%:==) (SE _ _ _ _) (SF _ _ _ _) = SFalse
+      (%:==) (SF _ _ _ _) (SA _ _ _ _) = SFalse
+      (%:==) (SF _ _ _ _) (SB _ _ _ _) = SFalse
+      (%:==) (SF _ _ _ _) (SC _ _ _ _) = SFalse
+      (%:==) (SF _ _ _ _) (SD _ _ _ _) = SFalse
+      (%:==) (SF _ _ _ _) (SE _ _ _ _) = SFalse
+      (%:==) (SF a a a a) (SF b b b b)
+        = (%:&&)
+            ((%:==) a b)
+            ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b)))
+    instance (SDecide (KProxy :: KProxy a),
+              SDecide (KProxy :: KProxy b),
+              SDecide (KProxy :: KProxy c),
+              SDecide (KProxy :: KProxy d)) =>
+             SDecide (KProxy :: KProxy (Foo a b c d)) where
+      (%~) (SA a a a a) (SA b b b b)
+        = case
+              GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+          of {
+            GHC.Tuple.(,,,) (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+              -> Proved Refl
+            GHC.Tuple.(,,,) (Disproved contra) _ _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ (Disproved contra) _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ (Disproved contra) _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ _ (Disproved contra)
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+      (%~) (SA _ _ _ _) (SB _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SA _ _ _ _) (SC _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SA _ _ _ _) (SD _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SA _ _ _ _) (SE _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SA _ _ _ _) (SF _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SB _ _ _ _) (SA _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SB a a a a) (SB b b b b)
+        = case
+              GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+          of {
+            GHC.Tuple.(,,,) (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+              -> Proved Refl
+            GHC.Tuple.(,,,) (Disproved contra) _ _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ (Disproved contra) _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ (Disproved contra) _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ _ (Disproved contra)
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+      (%~) (SB _ _ _ _) (SC _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SB _ _ _ _) (SD _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SB _ _ _ _) (SE _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SB _ _ _ _) (SF _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SC _ _ _ _) (SA _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SC _ _ _ _) (SB _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SC a a a a) (SC b b b b)
+        = case
+              GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+          of {
+            GHC.Tuple.(,,,) (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+              -> Proved Refl
+            GHC.Tuple.(,,,) (Disproved contra) _ _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ (Disproved contra) _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ (Disproved contra) _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ _ (Disproved contra)
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+      (%~) (SC _ _ _ _) (SD _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SC _ _ _ _) (SE _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SC _ _ _ _) (SF _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SD _ _ _ _) (SA _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SD _ _ _ _) (SB _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SD _ _ _ _) (SC _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SD a a a a) (SD b b b b)
+        = case
+              GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+          of {
+            GHC.Tuple.(,,,) (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+              -> Proved Refl
+            GHC.Tuple.(,,,) (Disproved contra) _ _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ (Disproved contra) _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ (Disproved contra) _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ _ (Disproved contra)
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+      (%~) (SD _ _ _ _) (SE _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SD _ _ _ _) (SF _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SE _ _ _ _) (SA _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SE _ _ _ _) (SB _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SE _ _ _ _) (SC _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SE _ _ _ _) (SD _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SE a a a a) (SE b b b b)
+        = case
+              GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+          of {
+            GHC.Tuple.(,,,) (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+              -> Proved Refl
+            GHC.Tuple.(,,,) (Disproved contra) _ _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ (Disproved contra) _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ (Disproved contra) _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ _ (Disproved contra)
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+      (%~) (SE _ _ _ _) (SF _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SF _ _ _ _) (SA _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SF _ _ _ _) (SB _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SF _ _ _ _) (SC _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SF _ _ _ _) (SD _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SF _ _ _ _) (SE _ _ _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SF a a a a) (SF b b b b)
+        = case
+              GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b)
+          of {
+            GHC.Tuple.(,,,) (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+                            (Proved Refl)
+              -> Proved Refl
+            GHC.Tuple.(,,,) (Disproved contra) _ _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ (Disproved contra) _ _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ (Disproved contra) _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,,,) _ _ _ (Disproved contra)
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+    instance SOrd (KProxy :: KProxy Nat) =>
+             SOrd (KProxy :: KProxy Nat) where
+      sCompare ::
+        forall (t0 :: Nat) (t1 :: Nat).
+        Sing t0
+        -> Sing t1
+           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat (TyFun Nat Ordering
+                                                            -> *)
+                                                 -> *) t0 :: TyFun Nat Ordering
+                                                             -> *) t1 :: Ordering)
+      sCompare SZero SZero
+        = let
+            lambda ::
+              (t0 ~ ZeroSym0, t1 ~ ZeroSym0) =>
+              Sing (Apply (Apply CompareSym0 ZeroSym0) ZeroSym0 :: Ordering)
+            lambda
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  SNil
+          in lambda
+      sCompare (SSucc sA_0123456789) (SSucc sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     b_0123456789. (t0 ~ Apply SuccSym0 a_0123456789,
+                                    t1 ~ Apply SuccSym0 b_0123456789) =>
+              Sing a_0123456789
+              -> Sing b_0123456789
+                 -> Sing (Apply (Apply CompareSym0 (Apply SuccSym0 a_0123456789)) (Apply SuccSym0 b_0123456789) :: Ordering)
+            lambda a_0123456789 b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Proxy :: Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                           b_0123456789))
+                     SNil)
+          in lambda sA_0123456789 sB_0123456789
+      sCompare SZero (SSucc _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ ZeroSym0,
+                                     t1 ~ Apply SuccSym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 ZeroSym0) (Apply SuccSym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 = SLT
+          in lambda _s_z_0123456789
+      sCompare (SSucc _s_z_0123456789) SZero
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ Apply SuccSym0 _z_0123456789,
+                                     t1 ~ ZeroSym0) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 (Apply SuccSym0 _z_0123456789)) ZeroSym0 :: Ordering)
+            lambda _z_0123456789 = SGT
+          in lambda _s_z_0123456789
+    instance (SOrd (KProxy :: KProxy a),
+              SOrd (KProxy :: KProxy b),
+              SOrd (KProxy :: KProxy c),
+              SOrd (KProxy :: KProxy d)) =>
+             SOrd (KProxy :: KProxy (Foo a b c d)) where
+      sCompare ::
+        forall (t0 :: Foo a b c d) (t1 :: Foo a b c d).
+        Sing t0
+        -> Sing t1
+           -> Sing (Apply (Apply (CompareSym0 :: TyFun (Foo a b c d) (TyFun (Foo a b c d) Ordering
+                                                                      -> *)
+                                                 -> *) t0 :: TyFun (Foo a b c d) Ordering
+                                                             -> *) t1 :: Ordering)
+      sCompare
+        (SA sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789)
+        (SA sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789,
+                                    t1 ~ Apply (Apply (Apply (Apply ASym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing a_0123456789
+                    -> Sing a_0123456789
+                       -> Sing b_0123456789
+                          -> Sing b_0123456789
+                             -> Sing b_0123456789
+                                -> Sing b_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ASym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789)) (Apply (Apply (Apply (Apply ASym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) :: Ordering)
+            lambda
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Proxy :: Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                           b_0123456789))
+                     (applySing
+                        (applySing
+                           (singFun2 (Proxy :: Proxy (:$)) SCons)
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                              b_0123456789))
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy (:$)) SCons)
+                              (applySing
+                                 (applySing
+                                    (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                                 b_0123456789))
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy (:$)) SCons)
+                                 (applySing
+                                    (applySing
+                                       (singFun2 (Proxy :: Proxy CompareSym0) sCompare)
+                                       a_0123456789)
+                                    b_0123456789))
+                              SNil))))
+          in
+            lambda
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+      sCompare
+        (SB sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789)
+        (SB sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789,
+                                    t1 ~ Apply (Apply (Apply (Apply BSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing a_0123456789
+                    -> Sing a_0123456789
+                       -> Sing b_0123456789
+                          -> Sing b_0123456789
+                             -> Sing b_0123456789
+                                -> Sing b_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply BSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789)) (Apply (Apply (Apply (Apply BSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) :: Ordering)
+            lambda
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Proxy :: Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                           b_0123456789))
+                     (applySing
+                        (applySing
+                           (singFun2 (Proxy :: Proxy (:$)) SCons)
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                              b_0123456789))
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy (:$)) SCons)
+                              (applySing
+                                 (applySing
+                                    (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                                 b_0123456789))
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy (:$)) SCons)
+                                 (applySing
+                                    (applySing
+                                       (singFun2 (Proxy :: Proxy CompareSym0) sCompare)
+                                       a_0123456789)
+                                    b_0123456789))
+                              SNil))))
+          in
+            lambda
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+      sCompare
+        (SC sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789)
+        (SC sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789,
+                                    t1 ~ Apply (Apply (Apply (Apply CSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing a_0123456789
+                    -> Sing a_0123456789
+                       -> Sing b_0123456789
+                          -> Sing b_0123456789
+                             -> Sing b_0123456789
+                                -> Sing b_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply CSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789)) (Apply (Apply (Apply (Apply CSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) :: Ordering)
+            lambda
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Proxy :: Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                           b_0123456789))
+                     (applySing
+                        (applySing
+                           (singFun2 (Proxy :: Proxy (:$)) SCons)
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                              b_0123456789))
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy (:$)) SCons)
+                              (applySing
+                                 (applySing
+                                    (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                                 b_0123456789))
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy (:$)) SCons)
+                                 (applySing
+                                    (applySing
+                                       (singFun2 (Proxy :: Proxy CompareSym0) sCompare)
+                                       a_0123456789)
+                                    b_0123456789))
+                              SNil))))
+          in
+            lambda
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+      sCompare
+        (SD sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789)
+        (SD sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789,
+                                    t1 ~ Apply (Apply (Apply (Apply DSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing a_0123456789
+                    -> Sing a_0123456789
+                       -> Sing b_0123456789
+                          -> Sing b_0123456789
+                             -> Sing b_0123456789
+                                -> Sing b_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply DSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789)) (Apply (Apply (Apply (Apply DSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) :: Ordering)
+            lambda
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Proxy :: Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                           b_0123456789))
+                     (applySing
+                        (applySing
+                           (singFun2 (Proxy :: Proxy (:$)) SCons)
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                              b_0123456789))
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy (:$)) SCons)
+                              (applySing
+                                 (applySing
+                                    (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                                 b_0123456789))
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy (:$)) SCons)
+                                 (applySing
+                                    (applySing
+                                       (singFun2 (Proxy :: Proxy CompareSym0) sCompare)
+                                       a_0123456789)
+                                    b_0123456789))
+                              SNil))))
+          in
+            lambda
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+      sCompare
+        (SE sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789)
+        (SE sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789,
+                                    t1 ~ Apply (Apply (Apply (Apply ESym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing a_0123456789
+                    -> Sing a_0123456789
+                       -> Sing b_0123456789
+                          -> Sing b_0123456789
+                             -> Sing b_0123456789
+                                -> Sing b_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ESym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789)) (Apply (Apply (Apply (Apply ESym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) :: Ordering)
+            lambda
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Proxy :: Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                           b_0123456789))
+                     (applySing
+                        (applySing
+                           (singFun2 (Proxy :: Proxy (:$)) SCons)
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                              b_0123456789))
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy (:$)) SCons)
+                              (applySing
+                                 (applySing
+                                    (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                                 b_0123456789))
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy (:$)) SCons)
+                                 (applySing
+                                    (applySing
+                                       (singFun2 (Proxy :: Proxy CompareSym0) sCompare)
+                                       a_0123456789)
+                                    b_0123456789))
+                              SNil))))
+          in
+            lambda
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+      sCompare
+        (SF sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789)
+        (SF sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     a_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789
+                     b_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789,
+                                    t1 ~ Apply (Apply (Apply (Apply FSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing a_0123456789
+                    -> Sing a_0123456789
+                       -> Sing b_0123456789
+                          -> Sing b_0123456789
+                             -> Sing b_0123456789
+                                -> Sing b_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply FSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789)) (Apply (Apply (Apply (Apply FSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) :: Ordering)
+            lambda
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              a_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl)
+                        (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Proxy :: Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                           b_0123456789))
+                     (applySing
+                        (applySing
+                           (singFun2 (Proxy :: Proxy (:$)) SCons)
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                              b_0123456789))
+                        (applySing
+                           (applySing
+                              (singFun2 (Proxy :: Proxy (:$)) SCons)
+                              (applySing
+                                 (applySing
+                                    (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789)
+                                 b_0123456789))
+                           (applySing
+                              (applySing
+                                 (singFun2 (Proxy :: Proxy (:$)) SCons)
+                                 (applySing
+                                    (applySing
+                                       (singFun2 (Proxy :: Proxy CompareSym0) sCompare)
+                                       a_0123456789)
+                                    b_0123456789))
+                              SNil))))
+          in
+            lambda
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sA_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+              sB_0123456789
+      sCompare
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SLT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SA _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SB _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SC _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SD _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+      sCompare
+        (SF _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        (SE _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789
+            _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing _z_0123456789
+                       -> Sing _z_0123456789
+                          -> Sing _z_0123456789
+                             -> Sing _z_0123456789
+                                -> Sing _z_0123456789
+                                   -> Sing (Apply (Apply CompareSym0 (Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789)) (Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) :: Ordering)
+            lambda
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              _z_0123456789
+              = SGT
+          in
+            lambda
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+              _s_z_0123456789
+    instance SingI Zero where
+      sing = SZero
+    instance SingI n => SingI (Succ (n :: Nat)) where
+      sing = SSucc sing
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (A (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SA sing sing sing sing
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (B (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SB sing sing sing sing
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (C (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SC sing sing sing sing
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (D (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SD sing sing sing sing
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (E (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SE sing sing sing sing
+    instance (SingI n, SingI n, SingI n, SingI n) =>
+             SingI (F (n :: a) (n :: b) (n :: c) (n :: d)) where
+      sing = SF sing sing sing sing
diff --git a/tests/compile-and-dump/Singletons/OrdDeriving.hs b/tests/compile-and-dump/Singletons/OrdDeriving.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/OrdDeriving.hs
@@ -0,0 +1,58 @@
+module Singletons.OrdDeriving where
+
+import Data.Singletons.Prelude
+import Data.Singletons.TH
+
+$(singletons [d|
+  data Nat = Zero | Succ Nat
+    deriving (Eq, Ord)
+
+  data Foo a b c d = A a b c d
+                   | B a b c d
+                   | C a b c d
+                   | D a b c d
+                   | E a b c d
+                   | F a b c d deriving (Eq,Ord)
+  |])
+
+foo1a :: Proxy (Zero :< Succ Zero)
+foo1a = Proxy
+
+foo1b :: Proxy True
+foo1b = foo1a
+
+foo2a :: Proxy (Succ (Succ Zero) `Compare` Zero)
+foo2a = Proxy
+
+foo2b :: Proxy GT
+foo2b = foo2a
+
+foo3a :: Proxy (A 1 2 3 4 `Compare` A 1 2 3 4)
+foo3a = Proxy
+
+foo3b :: Proxy EQ
+foo3b = foo3a
+
+foo4a :: Proxy (A 1 2 3 4 `Compare` A 1 2 3 5)
+foo4a = Proxy
+
+foo4b :: Proxy LT
+foo4b = foo4a
+
+foo5a :: Proxy (A 1 2 3 4 `Compare` A 1 2 3 3)
+foo5a = Proxy
+
+foo5b :: Proxy GT
+foo5b = foo5a
+
+foo6a :: Proxy (A 1 2 3 4 `Compare` B 1 2 3 4)
+foo6a = Proxy
+
+foo6b :: Proxy LT
+foo6b = foo6a
+
+foo7a :: Proxy (B 1 2 3 4 `Compare` A 1 2 3 4)
+foo7a = Proxy
+
+foo7b :: Proxy GT
+foo7b = foo7a
diff --git a/tests/compile-and-dump/Singletons/PatternMatching.ghc710.template b/tests/compile-and-dump/Singletons/PatternMatching.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/PatternMatching.ghc710.template
@@ -0,0 +1,639 @@
+Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| pr = Pair (Succ Zero) ([Zero])
+          complex = Pair (Pair (Just Zero) Zero) False
+          tuple = (False, Just Zero, True)
+          aList = [Zero, Succ Zero, Succ (Succ Zero)]
+          
+          data Pair a b
+            = Pair a b
+            deriving (Show) |]
+  ======>
+    data Pair a b
+      = Pair a b
+      deriving (Show)
+    pr = Pair (Succ Zero) [Zero]
+    complex = Pair (Pair (Just Zero) Zero) False
+    tuple = (False, Just Zero, True)
+    aList = [Zero, Succ Zero, Succ (Succ Zero)]
+    type PairSym2 (t :: a) (t :: b) = Pair t t
+    instance SuppressUnusedWarnings PairSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
+    data PairSym1 (l :: a) (l :: TyFun b (Pair a b))
+      = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) =>
+        PairSym1KindInference
+    type instance Apply (PairSym1 l) l = PairSym2 l l
+    instance SuppressUnusedWarnings PairSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
+    data PairSym0 (l :: TyFun a (TyFun b (Pair a b) -> *))
+      = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) =>
+        PairSym0KindInference
+    type instance Apply PairSym0 l = PairSym1 l
+    type AListSym0 = AList
+    type TupleSym0 = Tuple
+    type ComplexSym0 = Complex
+    type PrSym0 = Pr
+    type family AList where
+      AList = Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[]))
+    type family Tuple where
+      Tuple = Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0
+    type family Complex where
+      Complex = Apply (Apply PairSym0 (Apply (Apply PairSym0 (Apply JustSym0 ZeroSym0)) ZeroSym0)) FalseSym0
+    type family Pr where
+      Pr = Apply (Apply PairSym0 (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) ZeroSym0) '[])
+    sAList :: Sing AListSym0
+    sTuple :: Sing TupleSym0
+    sComplex :: Sing ComplexSym0
+    sPr :: Sing PrSym0
+    sAList
+      = applySing
+          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
+          (applySing
+             (applySing
+                (singFun2 (Proxy :: Proxy (:$)) SCons)
+                (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing
+                      (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
+                SNil))
+    sTuple
+      = applySing
+          (applySing
+             (applySing (singFun3 (Proxy :: Proxy Tuple3Sym0) STuple3) SFalse)
+             (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero))
+          STrue
+    sComplex
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy PairSym0) SPair)
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy PairSym0) SPair)
+                   (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero))
+                SZero))
+          SFalse
+    sPr
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy PairSym0) SPair)
+             (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) SNil)
+    data instance Sing (z :: Pair a b)
+      = forall (n :: a) (n :: b). z ~ Pair n n =>
+        SPair (Sing (n :: a)) (Sing (n :: b))
+    type SPair = (Sing :: Pair a b -> *)
+    instance (SingKind (KProxy :: KProxy a),
+              SingKind (KProxy :: KProxy b)) =>
+             SingKind (KProxy :: KProxy (Pair a b)) where
+      type DemoteRep (KProxy :: KProxy (Pair a b)) = Pair (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
+      fromSing (SPair b b) = Pair (fromSing b) (fromSing b)
+      toSing (Pair b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy b))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) }
+    instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where
+      sing = SPair sing sing
+Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| Pair sz lz = pr
+          Pair (Pair jz zz) fls = complex
+          (tf, tjz, tt) = tuple
+          [_, lsz, (Succ blimy)] = aList
+          lsz :: Nat
+          fls :: Bool
+          foo1 :: (a, b) -> a
+          foo1 (x, y) = (\ _ -> x) y
+          foo2 :: (# a, b #) -> a
+          foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b }
+          silly :: a -> ()
+          silly x = case x of { _ -> () } |]
+  ======>
+    Pair sz lz = pr
+    Pair (Pair jz zz) fls = complex
+    (tf, tjz, tt) = tuple
+    [_, lsz, Succ blimy] = aList
+    lsz :: Nat
+    fls :: Bool
+    foo1 :: forall a b. (a, b) -> a
+    foo1 (x, y) = \ _ -> x y
+    foo2 :: forall a b. (# a, b #) -> a
+    foo2 t@(# x, y #) = case t of { (# a, b #) -> \ _ -> a b }
+    silly :: forall a. a -> ()
+    silly x = case x of { _ -> GHC.Tuple.() }
+    type Let0123456789Scrutinee_0123456789Sym1 t =
+        Let0123456789Scrutinee_0123456789 t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 x where
+      Let0123456789Scrutinee_0123456789 x = x
+    type family Case_0123456789 x t where
+      Case_0123456789 x _z_0123456789 = Tuple0Sym0
+    type Let0123456789TSym2 t t = Let0123456789T t t
+    instance SuppressUnusedWarnings Let0123456789TSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789TSym1KindInference GHC.Tuple.())
+    data Let0123456789TSym1 l l
+      = forall arg. KindOf (Apply (Let0123456789TSym1 l) arg) ~ KindOf (Let0123456789TSym2 l arg) =>
+        Let0123456789TSym1KindInference
+    type instance Apply (Let0123456789TSym1 l) l = Let0123456789TSym2 l l
+    instance SuppressUnusedWarnings Let0123456789TSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Let0123456789TSym0KindInference GHC.Tuple.())
+    data Let0123456789TSym0 l
+      = forall arg. KindOf (Apply Let0123456789TSym0 arg) ~ KindOf (Let0123456789TSym1 arg) =>
+        Let0123456789TSym0KindInference
+    type instance Apply Let0123456789TSym0 l = Let0123456789TSym1 l
+    type family Let0123456789T x y where
+      Let0123456789T x y = Apply (Apply Tuple2Sym0 x) y
+    type Let0123456789Scrutinee_0123456789Sym2 t t =
+        Let0123456789Scrutinee_0123456789 t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
+        Let0123456789Scrutinee_0123456789Sym1KindInference
+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 x y where
+      Let0123456789Scrutinee_0123456789 x y = Let0123456789TSym2 x y
+    type family Case_0123456789 x y a b arg_0123456789 t where
+      Case_0123456789 x y a b arg_0123456789 _z_0123456789 = a
+    type family Lambda_0123456789 x y a b t where
+      Lambda_0123456789 x y a b arg_0123456789 = Case_0123456789 x y a b arg_0123456789 arg_0123456789
+    type Lambda_0123456789Sym5 t t t t t = Lambda_0123456789 t t t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym4 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym4KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym4 l l l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg) ~ KindOf (Lambda_0123456789Sym5 l l l l arg) =>
+        Lambda_0123456789Sym4KindInference
+    type instance Apply (Lambda_0123456789Sym4 l l l l) l = Lambda_0123456789Sym5 l l l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym3 l l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
+        Lambda_0123456789Sym3KindInference
+    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 x y t where
+      Case_0123456789 x y '(a,
+                            b) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b) b
+    type family Case_0123456789 x y arg_0123456789 t where
+      Case_0123456789 x y arg_0123456789 _z_0123456789 = x
+    type family Lambda_0123456789 x y t where
+      Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789
+    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym2 l l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
+        Lambda_0123456789Sym2KindInference
+    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym1 l l
+      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
+        Lambda_0123456789Sym1KindInference
+    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type family Case_0123456789 t where
+      Case_0123456789 '[_z_0123456789,
+                        y_0123456789,
+                        Succ _z_0123456789] = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 '[_z_0123456789,
+                        _z_0123456789,
+                        Succ y_0123456789] = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 '(y_0123456789,
+                        _z_0123456789,
+                        _z_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 '(_z_0123456789,
+                        y_0123456789,
+                        _z_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 '(_z_0123456789,
+                        _z_0123456789,
+                        y_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 (Pair (Pair y_0123456789 _z_0123456789) _z_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 (Pair (Pair _z_0123456789 y_0123456789) _z_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 (Pair (Pair _z_0123456789 _z_0123456789) y_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 (Pair y_0123456789 _z_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 (Pair _z_0123456789 y_0123456789) = y_0123456789
+    type SillySym1 (t :: a) = Silly t
+    instance SuppressUnusedWarnings SillySym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) SillySym0KindInference GHC.Tuple.())
+    data SillySym0 (l :: TyFun a ())
+      = forall arg. KindOf (Apply SillySym0 arg) ~ KindOf (SillySym1 arg) =>
+        SillySym0KindInference
+    type instance Apply SillySym0 l = SillySym1 l
+    type Foo2Sym1 (t :: (a, b)) = Foo2 t
+    instance SuppressUnusedWarnings Foo2Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
+    data Foo2Sym0 (l :: TyFun (a, b) a)
+      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
+        Foo2Sym0KindInference
+    type instance Apply Foo2Sym0 l = Foo2Sym1 l
+    type Foo1Sym1 (t :: (a, b)) = Foo1 t
+    instance SuppressUnusedWarnings Foo1Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
+    data Foo1Sym0 (l :: TyFun (a, b) a)
+      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
+        Foo1Sym0KindInference
+    type instance Apply Foo1Sym0 l = Foo1Sym1 l
+    type LszSym0 = Lsz
+    type BlimySym0 = Blimy
+    type TfSym0 = Tf
+    type TjzSym0 = Tjz
+    type TtSym0 = Tt
+    type JzSym0 = Jz
+    type ZzSym0 = Zz
+    type FlsSym0 = Fls
+    type SzSym0 = Sz
+    type LzSym0 = Lz
+    type X_0123456789Sym0 = X_0123456789
+    type X_0123456789Sym0 = X_0123456789
+    type X_0123456789Sym0 = X_0123456789
+    type X_0123456789Sym0 = X_0123456789
+    type family Silly (a :: a) :: () where
+      Silly x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)
+    type family Foo2 (a :: (a, b)) :: a where
+      Foo2 '(x,
+             y) = Case_0123456789 x y (Let0123456789Scrutinee_0123456789Sym2 x y)
+    type family Foo1 (a :: (a, b)) :: a where
+      Foo1 '(x, y) = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y
+    type family Lsz :: Nat where
+      Lsz = Case_0123456789 X_0123456789Sym0
+    type family Blimy where
+      Blimy = Case_0123456789 X_0123456789Sym0
+    type family Tf where
+      Tf = Case_0123456789 X_0123456789Sym0
+    type family Tjz where
+      Tjz = Case_0123456789 X_0123456789Sym0
+    type family Tt where
+      Tt = Case_0123456789 X_0123456789Sym0
+    type family Jz where
+      Jz = Case_0123456789 X_0123456789Sym0
+    type family Zz where
+      Zz = Case_0123456789 X_0123456789Sym0
+    type family Fls :: Bool where
+      Fls = Case_0123456789 X_0123456789Sym0
+    type family Sz where
+      Sz = Case_0123456789 X_0123456789Sym0
+    type family Lz where
+      Lz = Case_0123456789 X_0123456789Sym0
+    type family X_0123456789 where
+      X_0123456789 = PrSym0
+    type family X_0123456789 where
+      X_0123456789 = ComplexSym0
+    type family X_0123456789 where
+      X_0123456789 = TupleSym0
+    type family X_0123456789 where
+      X_0123456789 = AListSym0
+    sSilly :: forall (t :: a). Sing t -> Sing (Apply SillySym0 t :: ())
+    sFoo2 ::
+      forall (t :: (a, b)). Sing t -> Sing (Apply Foo2Sym0 t :: a)
+    sFoo1 ::
+      forall (t :: (a, b)). Sing t -> Sing (Apply Foo1Sym0 t :: a)
+    sLsz :: Sing (LszSym0 :: Nat)
+    sBlimy :: Sing BlimySym0
+    sTf :: Sing TfSym0
+    sTjz :: Sing TjzSym0
+    sTt :: Sing TtSym0
+    sJz :: Sing JzSym0
+    sZz :: Sing ZzSym0
+    sFls :: Sing (FlsSym0 :: Bool)
+    sSz :: Sing SzSym0
+    sLz :: Sing LzSym0
+    sX_0123456789 :: Sing X_0123456789Sym0
+    sX_0123456789 :: Sing X_0123456789Sym0
+    sX_0123456789 :: Sing X_0123456789Sym0
+    sX_0123456789 :: Sing X_0123456789Sym0
+    sSilly sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply SillySym0 x :: ())
+          lambda x
+            = let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)
+                sScrutinee_0123456789 = x
+              in  case sScrutinee_0123456789 of {
+                    _s_z_0123456789
+                      -> let
+                           lambda ::
+                             forall _z_0123456789. _z_0123456789 ~ Let0123456789Scrutinee_0123456789Sym1 x =>
+                             Sing _z_0123456789 -> Sing (Case_0123456789 x _z_0123456789)
+                           lambda _z_0123456789 = STuple0
+                         in lambda _s_z_0123456789 } ::
+                    Sing (Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x))
+        in lambda sX
+    sFoo2 (STuple2 sX sY)
+      = let
+          lambda ::
+            forall x y. t ~ Apply (Apply Tuple2Sym0 x) y =>
+            Sing x
+            -> Sing y
+               -> Sing (Apply Foo2Sym0 (Apply (Apply Tuple2Sym0 x) y) :: a)
+          lambda x y
+            = let
+                sT :: Sing (Let0123456789TSym2 x y)
+                sT
+                  = applySing
+                      (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) x) y in
+              let
+                sScrutinee_0123456789 ::
+                  Sing (Let0123456789Scrutinee_0123456789Sym2 x y)
+                sScrutinee_0123456789 = sT
+              in  case sScrutinee_0123456789 of {
+                    STuple2 sA sB
+                      -> let
+                           lambda ::
+                             forall a
+                                    b. Apply (Apply Tuple2Sym0 a) b ~ Let0123456789Scrutinee_0123456789Sym2 x y =>
+                             Sing a
+                             -> Sing b
+                                -> Sing (Case_0123456789 x y (Apply (Apply Tuple2Sym0 a) b))
+                           lambda a b
+                             = applySing
+                                 (singFun1
+                                    (Proxy ::
+                                       Proxy (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b))
+                                    (\ sArg_0123456789
+                                       -> let
+                                            lambda ::
+                                              forall arg_0123456789.
+                                              Sing arg_0123456789
+                                              -> Sing (Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b) arg_0123456789)
+                                            lambda arg_0123456789
+                                              = case arg_0123456789 of {
+                                                  _s_z_0123456789
+                                                    -> let
+                                                         lambda ::
+                                                           forall _z_0123456789. _z_0123456789 ~ arg_0123456789 =>
+                                                           Sing _z_0123456789
+                                                           -> Sing (Case_0123456789 x y a b arg_0123456789 _z_0123456789)
+                                                         lambda _z_0123456789 = a
+                                                       in lambda _s_z_0123456789 } ::
+                                                  Sing (Case_0123456789 x y a b arg_0123456789 arg_0123456789)
+                                          in lambda sArg_0123456789))
+                                 b
+                         in lambda sA sB } ::
+                    Sing (Case_0123456789 x y (Let0123456789Scrutinee_0123456789Sym2 x y))
+        in lambda sX sY
+    sFoo1 (STuple2 sX sY)
+      = let
+          lambda ::
+            forall x y. t ~ Apply (Apply Tuple2Sym0 x) y =>
+            Sing x
+            -> Sing y
+               -> Sing (Apply Foo1Sym0 (Apply (Apply Tuple2Sym0 x) y) :: a)
+          lambda x y
+            = applySing
+                (singFun1
+                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
+                   (\ sArg_0123456789
+                      -> let
+                           lambda ::
+                             forall arg_0123456789.
+                             Sing arg_0123456789
+                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789)
+                           lambda arg_0123456789
+                             = case arg_0123456789 of {
+                                 _s_z_0123456789
+                                   -> let
+                                        lambda ::
+                                          forall _z_0123456789. _z_0123456789 ~ arg_0123456789 =>
+                                          Sing _z_0123456789
+                                          -> Sing (Case_0123456789 x y arg_0123456789 _z_0123456789)
+                                        lambda _z_0123456789 = x
+                                      in lambda _s_z_0123456789 } ::
+                                 Sing (Case_0123456789 x y arg_0123456789 arg_0123456789)
+                         in lambda sArg_0123456789))
+                y
+        in lambda sX sY
+    sLsz
+      = case sX_0123456789 of {
+          SCons _s_z_0123456789
+                (SCons sY_0123456789 (SCons (SSucc _s_z_0123456789) SNil))
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          y_0123456789
+                          _z_0123456789. Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) (Apply SuccSym0 _z_0123456789)) '[])) ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing y_0123456789
+                      -> Sing _z_0123456789
+                         -> Sing (Case_0123456789 (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) (Apply SuccSym0 _z_0123456789)) '[]))))
+                 lambda _z_0123456789 y_0123456789 _z_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 sY_0123456789 _s_z_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sBlimy
+      = case sX_0123456789 of {
+          SCons _s_z_0123456789
+                (SCons _s_z_0123456789 (SCons (SSucc sY_0123456789) SNil))
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          _z_0123456789
+                          y_0123456789. Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) (Apply SuccSym0 y_0123456789)) '[])) ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing _z_0123456789
+                      -> Sing y_0123456789
+                         -> Sing (Case_0123456789 (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) (Apply SuccSym0 y_0123456789)) '[]))))
+                 lambda _z_0123456789 _z_0123456789 y_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 _s_z_0123456789 sY_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sTf
+      = case sX_0123456789 of {
+          STuple3 sY_0123456789 _s_z_0123456789 _s_z_0123456789
+            -> let
+                 lambda ::
+                   forall y_0123456789
+                          _z_0123456789
+                          _z_0123456789. Apply (Apply (Apply Tuple3Sym0 y_0123456789) _z_0123456789) _z_0123456789 ~ X_0123456789Sym0 =>
+                   Sing y_0123456789
+                   -> Sing _z_0123456789
+                      -> Sing _z_0123456789
+                         -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 y_0123456789) _z_0123456789) _z_0123456789))
+                 lambda y_0123456789 _z_0123456789 _z_0123456789 = y_0123456789
+               in lambda sY_0123456789 _s_z_0123456789 _s_z_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sTjz
+      = case sX_0123456789 of {
+          STuple3 _s_z_0123456789 sY_0123456789 _s_z_0123456789
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          y_0123456789
+                          _z_0123456789. Apply (Apply (Apply Tuple3Sym0 _z_0123456789) y_0123456789) _z_0123456789 ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing y_0123456789
+                      -> Sing _z_0123456789
+                         -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 _z_0123456789) y_0123456789) _z_0123456789))
+                 lambda _z_0123456789 y_0123456789 _z_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 sY_0123456789 _s_z_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sTt
+      = case sX_0123456789 of {
+          STuple3 _s_z_0123456789 _s_z_0123456789 sY_0123456789
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          _z_0123456789
+                          y_0123456789. Apply (Apply (Apply Tuple3Sym0 _z_0123456789) _z_0123456789) y_0123456789 ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing _z_0123456789
+                      -> Sing y_0123456789
+                         -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 _z_0123456789) _z_0123456789) y_0123456789))
+                 lambda _z_0123456789 _z_0123456789 y_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 _s_z_0123456789 sY_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sJz
+      = case sX_0123456789 of {
+          SPair (SPair sY_0123456789 _s_z_0123456789) _s_z_0123456789
+            -> let
+                 lambda ::
+                   forall y_0123456789
+                          _z_0123456789
+                          _z_0123456789. Apply (Apply PairSym0 (Apply (Apply PairSym0 y_0123456789) _z_0123456789)) _z_0123456789 ~ X_0123456789Sym0 =>
+                   Sing y_0123456789
+                   -> Sing _z_0123456789
+                      -> Sing _z_0123456789
+                         -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 y_0123456789) _z_0123456789)) _z_0123456789))
+                 lambda y_0123456789 _z_0123456789 _z_0123456789 = y_0123456789
+               in lambda sY_0123456789 _s_z_0123456789 _s_z_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sZz
+      = case sX_0123456789 of {
+          SPair (SPair _s_z_0123456789 sY_0123456789) _s_z_0123456789
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          y_0123456789
+                          _z_0123456789. Apply (Apply PairSym0 (Apply (Apply PairSym0 _z_0123456789) y_0123456789)) _z_0123456789 ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing y_0123456789
+                      -> Sing _z_0123456789
+                         -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 _z_0123456789) y_0123456789)) _z_0123456789))
+                 lambda _z_0123456789 y_0123456789 _z_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 sY_0123456789 _s_z_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sFls
+      = case sX_0123456789 of {
+          SPair (SPair _s_z_0123456789 _s_z_0123456789) sY_0123456789
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          _z_0123456789
+                          y_0123456789. Apply (Apply PairSym0 (Apply (Apply PairSym0 _z_0123456789) _z_0123456789)) y_0123456789 ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing _z_0123456789
+                      -> Sing y_0123456789
+                         -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 _z_0123456789) _z_0123456789)) y_0123456789))
+                 lambda _z_0123456789 _z_0123456789 y_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 _s_z_0123456789 sY_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sSz
+      = case sX_0123456789 of {
+          SPair sY_0123456789 _s_z_0123456789
+            -> let
+                 lambda ::
+                   forall y_0123456789
+                          _z_0123456789. Apply (Apply PairSym0 y_0123456789) _z_0123456789 ~ X_0123456789Sym0 =>
+                   Sing y_0123456789
+                   -> Sing _z_0123456789
+                      -> Sing (Case_0123456789 (Apply (Apply PairSym0 y_0123456789) _z_0123456789))
+                 lambda y_0123456789 _z_0123456789 = y_0123456789
+               in lambda sY_0123456789 _s_z_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sLz
+      = case sX_0123456789 of {
+          SPair _s_z_0123456789 sY_0123456789
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          y_0123456789. Apply (Apply PairSym0 _z_0123456789) y_0123456789 ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing y_0123456789
+                      -> Sing (Case_0123456789 (Apply (Apply PairSym0 _z_0123456789) y_0123456789))
+                 lambda _z_0123456789 y_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 sY_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sX_0123456789 = sPr
+    sX_0123456789 = sComplex
+    sX_0123456789 = sTuple
+    sX_0123456789 = sAList
diff --git a/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template b/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template
+++ /dev/null
@@ -1,506 +0,0 @@
-Singletons/PatternMatching.hs:0:0: Splicing declarations
-    singletons
-      [d| pr = Pair (Succ Zero) ([Zero])
-          complex = Pair (Pair (Just Zero) Zero) False
-          tuple = (False, Just Zero, True)
-          aList = [Zero, Succ Zero, Succ (Succ Zero)]
-          
-          data Pair a b
-            = Pair a b
-            deriving (Show) |]
-  ======>
-    Singletons/PatternMatching.hs:(0,0)-(0,0)
-    data Pair a b
-      = Pair a b
-      deriving (Show)
-    pr = Pair (Succ Zero) [Zero]
-    complex = Pair (Pair (Just Zero) Zero) False
-    tuple = (False, Just Zero, True)
-    aList = [Zero, Succ Zero, Succ (Succ Zero)]
-    type PairSym2 (t :: a) (t :: b) = Pair t t
-    instance SuppressUnusedWarnings PairSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.())
-    data PairSym1 (l :: a) (l :: TyFun b (Pair a b))
-      = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) =>
-        PairSym1KindInference
-    type instance Apply (PairSym1 l) l = PairSym2 l l
-    instance SuppressUnusedWarnings PairSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.())
-    data PairSym0 (l :: TyFun a (TyFun b (Pair a b) -> *))
-      = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) =>
-        PairSym0KindInference
-    type instance Apply PairSym0 l = PairSym1 l
-    type AListSym0 = AList
-    type TupleSym0 = Tuple
-    type ComplexSym0 = Complex
-    type PrSym0 = Pr
-    type AList =
-        Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[]))
-    type Tuple =
-        Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0
-    type Complex =
-        Apply (Apply PairSym0 (Apply (Apply PairSym0 (Apply JustSym0 ZeroSym0)) ZeroSym0)) FalseSym0
-    type Pr =
-        Apply (Apply PairSym0 (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) ZeroSym0) '[])
-    sAList :: Sing AListSym0
-    sTuple :: Sing TupleSym0
-    sComplex :: Sing ComplexSym0
-    sPr :: Sing PrSym0
-    sAList
-      = applySing
-          (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
-          (applySing
-             (applySing
-                (singFun2 (Proxy :: Proxy (:$)) SCons)
-                (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing
-                      (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
-                SNil))
-    sTuple
-      = applySing
-          (applySing
-             (applySing (singFun3 (Proxy :: Proxy Tuple3Sym0) STuple3) SFalse)
-             (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero))
-          STrue
-    sComplex
-      = applySing
-          (applySing
-             (singFun2 (Proxy :: Proxy PairSym0) SPair)
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy PairSym0) SPair)
-                   (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero))
-                SZero))
-          SFalse
-    sPr
-      = applySing
-          (applySing
-             (singFun2 (Proxy :: Proxy PairSym0) SPair)
-             (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) SNil)
-    data instance Sing (z :: Pair a b)
-      = forall (n :: a) (n :: b). z ~ Pair n n => SPair (Sing n) (Sing n)
-    type SPair (z :: Pair a b) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b)) =>
-             SingKind (KProxy :: KProxy (Pair a b)) where
-      type DemoteRep (KProxy :: KProxy (Pair a b)) = Pair (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b))
-      fromSing (SPair b b) = Pair (fromSing b) (fromSing b)
-      toSing (Pair b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) }
-    instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where
-      sing = SPair sing sing
-Singletons/PatternMatching.hs:0:0: Splicing declarations
-    singletons
-      [d| Pair sz lz = pr
-          Pair (Pair jz zz) fls = complex
-          (tf, tjz, tt) = tuple
-          [_, lsz, (Succ blimy)] = aList
-          lsz :: Nat
-          fls :: Bool
-          foo1 :: (a, b) -> a
-          foo1 (x, y) = (\ _ -> x) y
-          foo2 :: (# a, b #) -> a
-          foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b } |]
-  ======>
-    Singletons/PatternMatching.hs:(0,0)-(0,0)
-    Pair sz lz = pr
-    Pair (Pair jz zz) fls = complex
-    (tf, tjz, tt) = tuple
-    [_, lsz, Succ blimy] = aList
-    lsz :: Nat
-    fls :: Bool
-    foo1 :: forall a b. (a, b) -> a
-    foo1 (x, y) = \ _ -> x y
-    foo2 :: forall a b. (# a, b #) -> a
-    foo2 t@(# x, y #) = case t of { (# a, b #) -> \ _ -> a b }
-    type Let0123456789TSym2 t t = Let0123456789T t t
-    instance SuppressUnusedWarnings Let0123456789TSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789TSym1KindInference GHC.Tuple.())
-    data Let0123456789TSym1 l l
-      = forall arg. KindOf (Apply (Let0123456789TSym1 l) arg) ~ KindOf (Let0123456789TSym2 l arg) =>
-        Let0123456789TSym1KindInference
-    type instance Apply (Let0123456789TSym1 l) l = Let0123456789TSym2 l l
-    instance SuppressUnusedWarnings Let0123456789TSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let0123456789TSym0KindInference GHC.Tuple.())
-    data Let0123456789TSym0 l
-      = forall arg. KindOf (Apply Let0123456789TSym0 arg) ~ KindOf (Let0123456789TSym1 arg) =>
-        Let0123456789TSym0KindInference
-    type instance Apply Let0123456789TSym0 l = Let0123456789TSym1 l
-    type Let0123456789T x y = Apply (Apply Tuple2Sym0 x) y
-    type Let0123456789Scrutinee_0123456789Sym2 t t =
-        Let0123456789Scrutinee_0123456789 t t
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,)
-               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
-    type Let0123456789Scrutinee_0123456789 x y = Let0123456789TSym2 x y
-    type family Case_0123456789 x y a b arg_0123456789 t where
-      Case_0123456789 x y a b arg_0123456789 z = a
-    type family Lambda_0123456789 x y a b t where
-      Lambda_0123456789 x y a b arg_0123456789 = Case_0123456789 x y a b arg_0123456789 arg_0123456789
-    type Lambda_0123456789Sym5 t t t t t = Lambda_0123456789 t t t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym4 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym4KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym4 l l l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg) ~ KindOf (Lambda_0123456789Sym5 l l l l arg) =>
-        Lambda_0123456789Sym4KindInference
-    type instance Apply (Lambda_0123456789Sym4 l l l l) l = Lambda_0123456789Sym5 l l l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym3 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) =>
-        Lambda_0123456789Sym3KindInference
-    type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 x y t where
-      Case_0123456789 x y '(a,
-                            b) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b) b
-    type family Case_0123456789 x y arg_0123456789 t where
-      Case_0123456789 x y arg_0123456789 z = x
-    type family Lambda_0123456789 x y t where
-      Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789
-    type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym2 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) =>
-        Lambda_0123456789Sym2KindInference
-    type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym1 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) =>
-        Lambda_0123456789Sym1KindInference
-    type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type family Case_0123456789 t where
-      Case_0123456789 '[z, y_0123456789, Succ z] = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 '[z, z, Succ y_0123456789] = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 '(y_0123456789, z, z) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 '(z, y_0123456789, z) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 '(z, z, y_0123456789) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 (Pair (Pair y_0123456789 z) z) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 (Pair (Pair z y_0123456789) z) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 (Pair (Pair z z) y_0123456789) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 (Pair y_0123456789 z) = y_0123456789
-    type family Case_0123456789 t where
-      Case_0123456789 (Pair z y_0123456789) = y_0123456789
-    type Foo2Sym1 (t :: (a, b)) = Foo2 t
-    instance SuppressUnusedWarnings Foo2Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.())
-    data Foo2Sym0 (l :: TyFun (a, b) a)
-      = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) =>
-        Foo2Sym0KindInference
-    type instance Apply Foo2Sym0 l = Foo2Sym1 l
-    type Foo1Sym1 (t :: (a, b)) = Foo1 t
-    instance SuppressUnusedWarnings Foo1Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.())
-    data Foo1Sym0 (l :: TyFun (a, b) a)
-      = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) =>
-        Foo1Sym0KindInference
-    type instance Apply Foo1Sym0 l = Foo1Sym1 l
-    type LszSym0 = Lsz
-    type BlimySym0 = Blimy
-    type TfSym0 = Tf
-    type TjzSym0 = Tjz
-    type TtSym0 = Tt
-    type JzSym0 = Jz
-    type ZzSym0 = Zz
-    type FlsSym0 = Fls
-    type SzSym0 = Sz
-    type LzSym0 = Lz
-    type X_0123456789Sym0 = X_0123456789
-    type X_0123456789Sym0 = X_0123456789
-    type X_0123456789Sym0 = X_0123456789
-    type X_0123456789Sym0 = X_0123456789
-    type family Foo2 (a :: (a, b)) :: a where
-      Foo2 '(x,
-             y) = Case_0123456789 x y (Let0123456789Scrutinee_0123456789Sym2 x y)
-    type family Foo1 (a :: (a, b)) :: a where
-      Foo1 '(x, y) = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y
-    type Lsz = (Case_0123456789 X_0123456789Sym0 :: Nat)
-    type Blimy = Case_0123456789 X_0123456789Sym0
-    type Tf = Case_0123456789 X_0123456789Sym0
-    type Tjz = Case_0123456789 X_0123456789Sym0
-    type Tt = Case_0123456789 X_0123456789Sym0
-    type Jz = Case_0123456789 X_0123456789Sym0
-    type Zz = Case_0123456789 X_0123456789Sym0
-    type Fls = (Case_0123456789 X_0123456789Sym0 :: Bool)
-    type Sz = Case_0123456789 X_0123456789Sym0
-    type Lz = Case_0123456789 X_0123456789Sym0
-    type X_0123456789 = PrSym0
-    type X_0123456789 = ComplexSym0
-    type X_0123456789 = TupleSym0
-    type X_0123456789 = AListSym0
-    sFoo2 :: forall (t :: (a, b)). Sing t -> Sing (Apply Foo2Sym0 t)
-    sFoo1 :: forall (t :: (a, b)). Sing t -> Sing (Apply Foo1Sym0 t)
-    sLsz :: Sing LszSym0
-    sBlimy :: Sing BlimySym0
-    sTf :: Sing TfSym0
-    sTjz :: Sing TjzSym0
-    sTt :: Sing TtSym0
-    sJz :: Sing JzSym0
-    sZz :: Sing ZzSym0
-    sFls :: Sing FlsSym0
-    sSz :: Sing SzSym0
-    sLz :: Sing LzSym0
-    sX_0123456789 :: Sing X_0123456789Sym0
-    sX_0123456789 :: Sing X_0123456789Sym0
-    sX_0123456789 :: Sing X_0123456789Sym0
-    sX_0123456789 :: Sing X_0123456789Sym0
-    sFoo2 (STuple2 sX sY)
-      = let
-          lambda ::
-            forall x y. t ~ Apply (Apply Tuple2Sym0 x) y =>
-            Sing x
-            -> Sing y -> Sing (Apply Foo2Sym0 (Apply (Apply Tuple2Sym0 x) y))
-          lambda x y
-            = let
-                sT :: Sing (Let0123456789TSym2 x y)
-                sT
-                  = applySing
-                      (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) x) y in
-              let
-                sScrutinee_0123456789 ::
-                  Sing (Let0123456789Scrutinee_0123456789Sym2 x y)
-                sScrutinee_0123456789 = sT
-              in
-                case sScrutinee_0123456789 of {
-                  STuple2 sA sB
-                    -> let
-                         lambda ::
-                           forall a b.
-                           Sing a
-                           -> Sing b
-                              -> Sing (Case_0123456789 x y (Apply (Apply Tuple2Sym0 a) b))
-                         lambda a b
-                           = applySing
-                               (singFun1
-                                  (Proxy ::
-                                     Proxy (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b))
-                                  (\ sArg_0123456789
-                                     -> let
-                                          lambda ::
-                                            forall arg_0123456789.
-                                            Sing arg_0123456789
-                                            -> Sing (Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b) arg_0123456789)
-                                          lambda arg_0123456789
-                                            = case arg_0123456789 of {
-                                                _ -> let
-                                                       lambda ::
-                                                         forall wild.
-                                                         Sing (Case_0123456789 x y a b arg_0123456789 wild)
-                                                       lambda = a
-                                                     in lambda }
-                                        in lambda sArg_0123456789))
-                               b
-                       in lambda sA sB }
-        in lambda sX sY
-    sFoo1 (STuple2 sX sY)
-      = let
-          lambda ::
-            forall x y. t ~ Apply (Apply Tuple2Sym0 x) y =>
-            Sing x
-            -> Sing y -> Sing (Apply Foo1Sym0 (Apply (Apply Tuple2Sym0 x) y))
-          lambda x y
-            = applySing
-                (singFun1
-                   (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y))
-                   (\ sArg_0123456789
-                      -> let
-                           lambda ::
-                             forall arg_0123456789.
-                             Sing arg_0123456789
-                             -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789)
-                           lambda arg_0123456789
-                             = case arg_0123456789 of {
-                                 _ -> let
-                                        lambda ::
-                                          forall wild.
-                                          Sing (Case_0123456789 x y arg_0123456789 wild)
-                                        lambda = x
-                                      in lambda }
-                         in lambda sArg_0123456789))
-                y
-        in lambda sX sY
-    sLsz
-      = case sX_0123456789 of {
-          SCons _ (SCons sY_0123456789 (SCons (SSucc _) SNil))
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply (:$) wild) (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) (Apply SuccSym0 wild)) '[]))))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sBlimy
-      = case sX_0123456789 of {
-          SCons _ (SCons _ (SCons (SSucc sY_0123456789) SNil))
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply (:$) wild) (Apply (Apply (:$) wild) (Apply (Apply (:$) (Apply SuccSym0 y_0123456789)) '[]))))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sTf
-      = case sX_0123456789 of {
-          STuple3 sY_0123456789 _ _
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 y_0123456789) wild) wild))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sTjz
-      = case sX_0123456789 of {
-          STuple3 _ sY_0123456789 _
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 wild) y_0123456789) wild))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sTt
-      = case sX_0123456789 of {
-          STuple3 _ _ sY_0123456789
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 wild) wild) y_0123456789))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sJz
-      = case sX_0123456789 of {
-          SPair (SPair sY_0123456789 _) _
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 y_0123456789) wild)) wild))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sZz
-      = case sX_0123456789 of {
-          SPair (SPair _ sY_0123456789) _
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 wild) y_0123456789)) wild))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sFls
-      = case sX_0123456789 of {
-          SPair (SPair _ _) sY_0123456789
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 wild) wild)) y_0123456789))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sSz
-      = case sX_0123456789 of {
-          SPair sY_0123456789 _
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply PairSym0 y_0123456789) wild))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sLz
-      = case sX_0123456789 of {
-          SPair _ sY_0123456789
-            -> let
-                 lambda ::
-                   forall y_0123456789 wild.
-                   Sing y_0123456789
-                   -> Sing (Case_0123456789 (Apply (Apply PairSym0 wild) y_0123456789))
-                 lambda y_0123456789 = y_0123456789
-               in lambda sY_0123456789 }
-    sX_0123456789 = sPr
-    sX_0123456789 = sComplex
-    sX_0123456789 = sTuple
-    sX_0123456789 = sAList
diff --git a/tests/compile-and-dump/Singletons/PatternMatching.hs b/tests/compile-and-dump/Singletons/PatternMatching.hs
--- a/tests/compile-and-dump/Singletons/PatternMatching.hs
+++ b/tests/compile-and-dump/Singletons/PatternMatching.hs
@@ -22,9 +22,6 @@
   [_, lsz, (Succ blimy)] = aList
   lsz :: Nat
   fls :: Bool
-#if __GLASGOW_HASKELL__ < 707
-  blimy :: Nat   -- this is necessary to promote nested patterns
-#endif
 
   foo1 :: (a, b) -> a
   foo1 (x, y) = (\_ -> x) y
@@ -32,6 +29,9 @@
   foo2 :: (# a, b #) -> a
   foo2 t@(# x, y #) = case t of
                         (# a, b #) -> (\_ -> a) b
+
+  silly :: a -> ()
+  silly x = case x of _ -> ()
   |])
 
 test1 :: Proxy (Foo1 '(Int, Char)) -> Proxy Int
diff --git a/tests/compile-and-dump/Singletons/Records.ghc710.template b/tests/compile-and-dump/Singletons/Records.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Records.ghc710.template
@@ -0,0 +1,59 @@
+Singletons/Records.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data Record a = MkRecord {field1 :: a, field2 :: Bool} |]
+  ======>
+    data Record a = MkRecord {field1 :: a, field2 :: Bool}
+    type Field1Sym1 (t :: Record a) = Field1 t
+    instance SuppressUnusedWarnings Field1Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Field1Sym0KindInference GHC.Tuple.())
+    data Field1Sym0 (l :: TyFun (Record a) a)
+      = forall arg. KindOf (Apply Field1Sym0 arg) ~ KindOf (Field1Sym1 arg) =>
+        Field1Sym0KindInference
+    type instance Apply Field1Sym0 l = Field1Sym1 l
+    type Field2Sym1 (t :: Record a) = Field2 t
+    instance SuppressUnusedWarnings Field2Sym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) Field2Sym0KindInference GHC.Tuple.())
+    data Field2Sym0 (l :: TyFun (Record a) Bool)
+      = forall arg. KindOf (Apply Field2Sym0 arg) ~ KindOf (Field2Sym1 arg) =>
+        Field2Sym0KindInference
+    type instance Apply Field2Sym0 l = Field2Sym1 l
+    type family Field1 (a :: Record a) :: a where
+      Field1 (MkRecord field _z_0123456789) = field
+    type family Field2 (a :: Record a) :: Bool where
+      Field2 (MkRecord _z_0123456789 field) = field
+    type MkRecordSym2 (t :: a) (t :: Bool) = MkRecord t t
+    instance SuppressUnusedWarnings MkRecordSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MkRecordSym1KindInference GHC.Tuple.())
+    data MkRecordSym1 (l :: a) (l :: TyFun Bool (Record a))
+      = forall arg. KindOf (Apply (MkRecordSym1 l) arg) ~ KindOf (MkRecordSym2 l arg) =>
+        MkRecordSym1KindInference
+    type instance Apply (MkRecordSym1 l) l = MkRecordSym2 l l
+    instance SuppressUnusedWarnings MkRecordSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MkRecordSym0KindInference GHC.Tuple.())
+    data MkRecordSym0 (l :: TyFun a (TyFun Bool (Record a) -> *))
+      = forall arg. KindOf (Apply MkRecordSym0 arg) ~ KindOf (MkRecordSym1 arg) =>
+        MkRecordSym0KindInference
+    type instance Apply MkRecordSym0 l = MkRecordSym1 l
+    data instance Sing (z :: Record a)
+      = forall (n :: a) (n :: Bool). z ~ MkRecord n n =>
+        SMkRecord {sField1 :: Sing (n :: a), sField2 :: Sing (n :: Bool)}
+    type SRecord = (Sing :: Record a -> *)
+    instance SingKind (KProxy :: KProxy a) =>
+             SingKind (KProxy :: KProxy (Record a)) where
+      type DemoteRep (KProxy :: KProxy (Record a)) = Record (DemoteRep (KProxy :: KProxy a))
+      fromSing (SMkRecord b b) = MkRecord (fromSing b) (fromSing b)
+      toSing (MkRecord b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy a))
+                (toSing b :: SomeSing (KProxy :: KProxy Bool))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c)
+              -> SomeSing (SMkRecord c c) }
+    instance (SingI n, SingI n) =>
+             SingI (MkRecord (n :: a) (n :: Bool)) where
+      sing = SMkRecord sing sing
diff --git a/tests/compile-and-dump/Singletons/Records.ghc78.template b/tests/compile-and-dump/Singletons/Records.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Records.ghc78.template
+++ /dev/null
@@ -1,60 +0,0 @@
-Singletons/Records.hs:0:0: Splicing declarations
-    singletons
-      [d| data Record a = MkRecord {field1 :: a, field2 :: Bool} |]
-  ======>
-    Singletons/Records.hs:(0,0)-(0,0)
-    data Record a = MkRecord {field1 :: a, field2 :: Bool}
-    type Field1Sym1 (t :: Record a) = Field1 t
-    instance SuppressUnusedWarnings Field1Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Field1Sym0KindInference GHC.Tuple.())
-    data Field1Sym0 (l :: TyFun (Record a) a)
-      = forall arg. KindOf (Apply Field1Sym0 arg) ~ KindOf (Field1Sym1 arg) =>
-        Field1Sym0KindInference
-    type instance Apply Field1Sym0 l = Field1Sym1 l
-    type Field2Sym1 (t :: Record a) = Field2 t
-    instance SuppressUnusedWarnings Field2Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Field2Sym0KindInference GHC.Tuple.())
-    data Field2Sym0 (l :: TyFun (Record a) Bool)
-      = forall arg. KindOf (Apply Field2Sym0 arg) ~ KindOf (Field2Sym1 arg) =>
-        Field2Sym0KindInference
-    type instance Apply Field2Sym0 l = Field2Sym1 l
-    type family Field1 (a :: Record a) :: a where
-      Field1 (MkRecord field z) = field
-    type family Field2 (a :: Record a) :: Bool where
-      Field2 (MkRecord z field) = field
-    type MkRecordSym2 (t :: a) (t :: Bool) = MkRecord t t
-    instance SuppressUnusedWarnings MkRecordSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) MkRecordSym1KindInference GHC.Tuple.())
-    data MkRecordSym1 (l :: a) (l :: TyFun Bool (Record a))
-      = forall arg. KindOf (Apply (MkRecordSym1 l) arg) ~ KindOf (MkRecordSym2 l arg) =>
-        MkRecordSym1KindInference
-    type instance Apply (MkRecordSym1 l) l = MkRecordSym2 l l
-    instance SuppressUnusedWarnings MkRecordSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) MkRecordSym0KindInference GHC.Tuple.())
-    data MkRecordSym0 (l :: TyFun a (TyFun Bool (Record a) -> *))
-      = forall arg. KindOf (Apply MkRecordSym0 arg) ~ KindOf (MkRecordSym1 arg) =>
-        MkRecordSym0KindInference
-    type instance Apply MkRecordSym0 l = MkRecordSym1 l
-    data instance Sing (z :: Record a)
-      = forall (n :: a) (n :: Bool). z ~ MkRecord n n =>
-        SMkRecord {sField1 :: Sing n, sField2 :: Sing n}
-    type SRecord (z :: Record a) = Sing z
-    instance SingKind (KProxy :: KProxy a) =>
-             SingKind (KProxy :: KProxy (Record a)) where
-      type DemoteRep (KProxy :: KProxy (Record a)) = Record (DemoteRep (KProxy :: KProxy a))
-      fromSing (SMkRecord b b) = MkRecord (fromSing b) (fromSing b)
-      toSing (MkRecord b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy Bool))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c)
-              -> SomeSing (SMkRecord c c) }
-    instance (SingI n, SingI n) =>
-             SingI (MkRecord (n :: a) (n :: Bool)) where
-      sing = SMkRecord sing sing
diff --git a/tests/compile-and-dump/Singletons/ReturnFunc.ghc710.template b/tests/compile-and-dump/Singletons/ReturnFunc.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/ReturnFunc.ghc710.template
@@ -0,0 +1,93 @@
+Singletons/ReturnFunc.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| returnFunc :: Nat -> Nat -> Nat
+          returnFunc _ = Succ
+          id :: a -> a
+          id x = x
+          idFoo :: c -> a -> a
+          idFoo _ = id |]
+  ======>
+    returnFunc :: Nat -> Nat -> Nat
+    returnFunc _ = Succ
+    id :: forall a. a -> a
+    id x = x
+    idFoo :: forall c a. c -> a -> a
+    idFoo _ = id
+    type IdSym1 (t :: a) = Id t
+    instance SuppressUnusedWarnings IdSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.())
+    data IdSym0 (l :: TyFun a a)
+      = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) =>
+        IdSym0KindInference
+    type instance Apply IdSym0 l = IdSym1 l
+    type IdFooSym2 (t :: c) (t :: a) = IdFoo t t
+    instance SuppressUnusedWarnings IdFooSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) IdFooSym1KindInference GHC.Tuple.())
+    data IdFooSym1 (l :: c) (l :: TyFun a a)
+      = forall arg. KindOf (Apply (IdFooSym1 l) arg) ~ KindOf (IdFooSym2 l arg) =>
+        IdFooSym1KindInference
+    type instance Apply (IdFooSym1 l) l = IdFooSym2 l l
+    instance SuppressUnusedWarnings IdFooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) IdFooSym0KindInference GHC.Tuple.())
+    data IdFooSym0 (l :: TyFun c (TyFun a a -> *))
+      = forall arg. KindOf (Apply IdFooSym0 arg) ~ KindOf (IdFooSym1 arg) =>
+        IdFooSym0KindInference
+    type instance Apply IdFooSym0 l = IdFooSym1 l
+    type ReturnFuncSym2 (t :: Nat) (t :: Nat) = ReturnFunc t t
+    instance SuppressUnusedWarnings ReturnFuncSym1 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ReturnFuncSym1KindInference GHC.Tuple.())
+    data ReturnFuncSym1 (l :: Nat) (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply (ReturnFuncSym1 l) arg) ~ KindOf (ReturnFuncSym2 l arg) =>
+        ReturnFuncSym1KindInference
+    type instance Apply (ReturnFuncSym1 l) l = ReturnFuncSym2 l l
+    instance SuppressUnusedWarnings ReturnFuncSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) ReturnFuncSym0KindInference GHC.Tuple.())
+    data ReturnFuncSym0 (l :: TyFun Nat (TyFun Nat Nat -> *))
+      = forall arg. KindOf (Apply ReturnFuncSym0 arg) ~ KindOf (ReturnFuncSym1 arg) =>
+        ReturnFuncSym0KindInference
+    type instance Apply ReturnFuncSym0 l = ReturnFuncSym1 l
+    type family Id (a :: a) :: a where
+      Id x = x
+    type family IdFoo (a :: c) (a :: a) :: a where
+      IdFoo _z_0123456789 a_0123456789 = Apply IdSym0 a_0123456789
+    type family ReturnFunc (a :: Nat) (a :: Nat) :: Nat where
+      ReturnFunc _z_0123456789 a_0123456789 = Apply SuccSym0 a_0123456789
+    sId :: forall (t :: a). Sing t -> Sing (Apply IdSym0 t :: a)
+    sIdFoo ::
+      forall (t :: c) (t :: a).
+      Sing t -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t :: a)
+    sReturnFunc ::
+      forall (t :: Nat) (t :: Nat).
+      Sing t -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t :: Nat)
+    sId sX
+      = let
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply IdSym0 x :: a)
+          lambda x = x
+        in lambda sX
+    sIdFoo _s_z_0123456789 sA_0123456789
+      = let
+          lambda ::
+            forall _z_0123456789 a_0123456789. (t ~ _z_0123456789,
+                                                t ~ a_0123456789) =>
+            Sing _z_0123456789
+            -> Sing a_0123456789
+               -> Sing (Apply (Apply IdFooSym0 _z_0123456789) a_0123456789 :: a)
+          lambda _z_0123456789 a_0123456789
+            = applySing (singFun1 (Proxy :: Proxy IdSym0) sId) a_0123456789
+        in lambda _s_z_0123456789 sA_0123456789
+    sReturnFunc _s_z_0123456789 sA_0123456789
+      = let
+          lambda ::
+            forall _z_0123456789 a_0123456789. (t ~ _z_0123456789,
+                                                t ~ a_0123456789) =>
+            Sing _z_0123456789
+            -> Sing a_0123456789
+               -> Sing (Apply (Apply ReturnFuncSym0 _z_0123456789) a_0123456789 :: Nat)
+          lambda _z_0123456789 a_0123456789
+            = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) a_0123456789
+        in lambda _s_z_0123456789 sA_0123456789
diff --git a/tests/compile-and-dump/Singletons/ReturnFunc.ghc78.template b/tests/compile-and-dump/Singletons/ReturnFunc.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/ReturnFunc.ghc78.template
+++ /dev/null
@@ -1,90 +0,0 @@
-Singletons/ReturnFunc.hs:0:0: Splicing declarations
-    singletons
-      [d| returnFunc :: Nat -> Nat -> Nat
-          returnFunc _ = Succ
-          id :: a -> a
-          id x = x
-          idFoo :: c -> a -> a
-          idFoo _ = id |]
-  ======>
-    Singletons/ReturnFunc.hs:(0,0)-(0,0)
-    returnFunc :: Nat -> Nat -> Nat
-    returnFunc _ = Succ
-    id :: forall a. a -> a
-    id x = x
-    idFoo :: forall c a. c -> a -> a
-    idFoo _ = id
-    type IdSym1 (t :: a) = Id t
-    instance SuppressUnusedWarnings IdSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.())
-    data IdSym0 (l :: TyFun a a)
-      = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) =>
-        IdSym0KindInference
-    type instance Apply IdSym0 l = IdSym1 l
-    type IdFooSym2 (t :: c) (t :: a) = IdFoo t t
-    instance SuppressUnusedWarnings IdFooSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) IdFooSym1KindInference GHC.Tuple.())
-    data IdFooSym1 (l :: c) (l :: TyFun a a)
-      = forall arg. KindOf (Apply (IdFooSym1 l) arg) ~ KindOf (IdFooSym2 l arg) =>
-        IdFooSym1KindInference
-    type instance Apply (IdFooSym1 l) l = IdFooSym2 l l
-    instance SuppressUnusedWarnings IdFooSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) IdFooSym0KindInference GHC.Tuple.())
-    data IdFooSym0 (l :: TyFun c (TyFun a a -> *))
-      = forall arg. KindOf (Apply IdFooSym0 arg) ~ KindOf (IdFooSym1 arg) =>
-        IdFooSym0KindInference
-    type instance Apply IdFooSym0 l = IdFooSym1 l
-    type ReturnFuncSym2 (t :: Nat) (t :: Nat) = ReturnFunc t t
-    instance SuppressUnusedWarnings ReturnFuncSym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ReturnFuncSym1KindInference GHC.Tuple.())
-    data ReturnFuncSym1 (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (ReturnFuncSym1 l) arg) ~ KindOf (ReturnFuncSym2 l arg) =>
-        ReturnFuncSym1KindInference
-    type instance Apply (ReturnFuncSym1 l) l = ReturnFuncSym2 l l
-    instance SuppressUnusedWarnings ReturnFuncSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) ReturnFuncSym0KindInference GHC.Tuple.())
-    data ReturnFuncSym0 (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply ReturnFuncSym0 arg) ~ KindOf (ReturnFuncSym1 arg) =>
-        ReturnFuncSym0KindInference
-    type instance Apply ReturnFuncSym0 l = ReturnFuncSym1 l
-    type family Id (a :: a) :: a where
-      Id x = x
-    type family IdFoo (a :: c) (a :: a) :: a where
-      IdFoo z a_0123456789 = Apply IdSym0 a_0123456789
-    type family ReturnFunc (a :: Nat) (a :: Nat) :: Nat where
-      ReturnFunc z a_0123456789 = Apply SuccSym0 a_0123456789
-    sId :: forall (t :: a). Sing t -> Sing (Apply IdSym0 t)
-    sIdFoo ::
-      forall (t :: c) (t :: a).
-      Sing t -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t)
-    sReturnFunc ::
-      forall (t :: Nat) (t :: Nat).
-      Sing t -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t)
-    sId sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply IdSym0 x)
-          lambda x = x
-        in lambda sX
-    sIdFoo _ sA_0123456789
-      = let
-          lambda ::
-            forall a_0123456789 wild. (t ~ wild, t ~ a_0123456789) =>
-            Sing a_0123456789
-            -> Sing (Apply (Apply IdFooSym0 wild) a_0123456789)
-          lambda a_0123456789
-            = applySing (singFun1 (Proxy :: Proxy IdSym0) sId) a_0123456789
-        in lambda sA_0123456789
-    sReturnFunc _ sA_0123456789
-      = let
-          lambda ::
-            forall a_0123456789 wild. (t ~ wild, t ~ a_0123456789) =>
-            Sing a_0123456789
-            -> Sing (Apply (Apply ReturnFuncSym0 wild) a_0123456789)
-          lambda a_0123456789
-            = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) a_0123456789
-        in lambda sA_0123456789
diff --git a/tests/compile-and-dump/Singletons/Sections.ghc710.template b/tests/compile-and-dump/Singletons/Sections.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Sections.ghc710.template
@@ -0,0 +1,143 @@
+Singletons/Sections.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| (+) :: Nat -> Nat -> Nat
+          Zero + m = m
+          (Succ n) + m = Succ (n + m)
+          foo1 :: [Nat]
+          foo1 = map ((Succ Zero) +) [Zero, Succ Zero]
+          foo2 :: [Nat]
+          foo2 = map (+ (Succ Zero)) [Zero, Succ Zero]
+          foo3 :: [Nat]
+          foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero] |]
+  ======>
+    (+) :: Nat -> Nat -> Nat
+    (+) Zero m = m
+    (+) (Succ n) m = Succ (n + m)
+    foo1 :: [Nat]
+    foo1 = map (Succ Zero +) [Zero, Succ Zero]
+    foo2 :: [Nat]
+    foo2 = map (+ Succ Zero) [Zero, Succ Zero]
+    foo3 :: [Nat]
+    foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero]
+    type family Lambda_0123456789 t where
+      Lambda_0123456789 lhs_0123456789 = Apply (Apply (:+$) lhs_0123456789) (Apply SuccSym0 ZeroSym0)
+    type Lambda_0123456789Sym1 t = Lambda_0123456789 t
+    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
+    data Lambda_0123456789Sym0 l
+      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
+        Lambda_0123456789Sym0KindInference
+    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
+    type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
+    instance SuppressUnusedWarnings (:+$$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
+    data (:+$$) (l :: Nat) (l :: TyFun Nat Nat)
+      = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) =>
+        :+$$###
+    type instance Apply ((:+$$) l) l = (:+$$$) l l
+    instance SuppressUnusedWarnings (:+$) where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
+    data (:+$) (l :: TyFun Nat (TyFun Nat Nat -> *))
+      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
+        :+$###
+    type instance Apply (:+$) l = (:+$$) l
+    type Foo1Sym0 = Foo1
+    type Foo2Sym0 = Foo2
+    type Foo3Sym0 = Foo3
+    type family (:+) (a :: Nat) (a :: Nat) :: Nat where
+      (:+) Zero m = m
+      (:+) (Succ n) m = Apply SuccSym0 (Apply (Apply (:+$) n) m)
+    type family Foo1 :: [Nat] where
+      Foo1 = Apply (Apply MapSym0 (Apply (:+$) (Apply SuccSym0 ZeroSym0))) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[]))
+    type family Foo2 :: [Nat] where
+      Foo2 = Apply (Apply MapSym0 Lambda_0123456789Sym0) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[]))
+    type family Foo3 :: [Nat] where
+      Foo3 = Apply (Apply (Apply ZipWithSym0 (:+$)) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[]))) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[]))
+    (%:+) ::
+      forall (t :: Nat) (t :: Nat).
+      Sing t -> Sing t -> Sing (Apply (Apply (:+$) t) t :: Nat)
+    sFoo1 :: Sing (Foo1Sym0 :: [Nat])
+    sFoo2 :: Sing (Foo2Sym0 :: [Nat])
+    sFoo3 :: Sing (Foo3Sym0 :: [Nat])
+    (%:+) SZero sM
+      = let
+          lambda ::
+            forall m. (t ~ ZeroSym0, t ~ m) =>
+            Sing m -> Sing (Apply (Apply (:+$) ZeroSym0) m :: Nat)
+          lambda m = m
+        in lambda sM
+    (%:+) (SSucc sN) sM
+      = let
+          lambda ::
+            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
+            Sing n
+            -> Sing m -> Sing (Apply (Apply (:+$) (Apply SuccSym0 n)) m :: Nat)
+          lambda n m
+            = applySing
+                (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
+                (applySing (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) n) m)
+        in lambda sN sM
+    sFoo1
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy MapSym0) sMap)
+             (applySing
+                (singFun2 (Proxy :: Proxy (:+$)) (%:+))
+                (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+                SNil))
+    sFoo2
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy MapSym0) sMap)
+             (singFun1
+                (Proxy :: Proxy Lambda_0123456789Sym0)
+                (\ sLhs_0123456789
+                   -> let
+                        lambda ::
+                          forall lhs_0123456789.
+                          Sing lhs_0123456789
+                          -> Sing (Apply Lambda_0123456789Sym0 lhs_0123456789)
+                        lambda lhs_0123456789
+                          = applySing
+                              (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) lhs_0123456789)
+                              (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)
+                      in lambda sLhs_0123456789)))
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+                SNil))
+    sFoo3
+      = applySing
+          (applySing
+             (applySing
+                (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith)
+                (singFun2 (Proxy :: Proxy (:+$)) (%:+)))
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+                (applySing
+                   (applySing
+                      (singFun2 (Proxy :: Proxy (:$)) SCons)
+                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+                   SNil)))
+          (applySing
+             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
+             (applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy (:$)) SCons)
+                   (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
+                SNil))
diff --git a/tests/compile-and-dump/Singletons/Sections.ghc78.template b/tests/compile-and-dump/Singletons/Sections.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Sections.ghc78.template
+++ /dev/null
@@ -1,143 +0,0 @@
-Singletons/Sections.hs:0:0: Splicing declarations
-    singletons
-      [d| (+) :: Nat -> Nat -> Nat
-          Zero + m = m
-          (Succ n) + m = Succ (n + m)
-          foo1 :: [Nat]
-          foo1 = map ((Succ Zero) +) [Zero, Succ Zero]
-          foo2 :: [Nat]
-          foo2 = map (+ (Succ Zero)) [Zero, Succ Zero]
-          foo3 :: [Nat]
-          foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero] |]
-  ======>
-    Singletons/Sections.hs:(0,0)-(0,0)
-    (+) :: Nat -> Nat -> Nat
-    (+) Zero m = m
-    (+) (Succ n) m = Succ (n + m)
-    foo1 :: [Nat]
-    foo1 = map (Succ Zero +) [Zero, Succ Zero]
-    foo2 :: [Nat]
-    foo2 = map (+ Succ Zero) [Zero, Succ Zero]
-    foo3 :: [Nat]
-    foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero]
-    type family Lambda_0123456789 t where
-      Lambda_0123456789 lhs_0123456789 = Apply (Apply (:+$) lhs_0123456789) (Apply SuccSym0 ZeroSym0)
-    type Lambda_0123456789Sym1 t = Lambda_0123456789 t
-    instance SuppressUnusedWarnings Lambda_0123456789Sym0 where
-      suppressUnusedWarnings _
-        = snd
-            (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.())
-    data Lambda_0123456789Sym0 l
-      = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
-        Lambda_0123456789Sym0KindInference
-    type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t
-    instance SuppressUnusedWarnings (:+$$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.())
-    data (:+$$) (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) =>
-        (:+$$###)
-    type instance Apply ((:+$$) l) l = (:+$$$) l l
-    instance SuppressUnusedWarnings (:+$) where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.())
-    data (:+$) (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) =>
-        (:+$###)
-    type instance Apply (:+$) l = (:+$$) l
-    type Foo1Sym0 = Foo1
-    type Foo2Sym0 = Foo2
-    type Foo3Sym0 = Foo3
-    type family (:+) (a :: Nat) (a :: Nat) :: Nat where
-      (:+) Zero m = m
-      (:+) (Succ n) m = Apply SuccSym0 (Apply (Apply (:+$) n) m)
-    type Foo1 =
-        (Apply (Apply MapSym0 (Apply (:+$) (Apply SuccSym0 ZeroSym0))) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[])) :: [Nat])
-    type Foo2 =
-        (Apply (Apply MapSym0 Lambda_0123456789Sym0) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[])) :: [Nat])
-    type Foo3 =
-        (Apply (Apply (Apply ZipWithSym0 (:+$)) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[]))) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[])) :: [Nat])
-    (%:+) ::
-      forall (t :: Nat) (t :: Nat).
-      Sing t -> Sing t -> Sing (Apply (Apply (:+$) t) t)
-    sFoo1 :: Sing Foo1Sym0
-    sFoo2 :: Sing Foo2Sym0
-    sFoo3 :: Sing Foo3Sym0
-    (%:+) SZero sM
-      = let
-          lambda ::
-            forall m. (t ~ ZeroSym0, t ~ m) =>
-            Sing m -> Sing (Apply (Apply (:+$) ZeroSym0) m)
-          lambda m = m
-        in lambda sM
-    (%:+) (SSucc sN) sM
-      = let
-          lambda ::
-            forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
-            Sing n -> Sing m -> Sing (Apply (Apply (:+$) (Apply SuccSym0 n)) m)
-          lambda n m
-            = applySing
-                (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
-                (applySing (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) n) m)
-        in lambda sN sM
-    sFoo1
-      = applySing
-          (applySing
-             (singFun2 (Proxy :: Proxy MapSym0) sMap)
-             (applySing
-                (singFun2 (Proxy :: Proxy (:+$)) (%:+))
-                (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)))
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-                SNil))
-    sFoo2
-      = applySing
-          (applySing
-             (singFun2 (Proxy :: Proxy MapSym0) sMap)
-             (singFun1
-                (Proxy :: Proxy Lambda_0123456789Sym0)
-                (\ sLhs_0123456789
-                   -> let
-                        lambda ::
-                          forall lhs_0123456789.
-                          Sing lhs_0123456789
-                          -> Sing (Apply Lambda_0123456789Sym0 lhs_0123456789)
-                        lambda lhs_0123456789
-                          = applySing
-                              (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) lhs_0123456789)
-                              (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)
-                      in lambda sLhs_0123456789)))
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-                SNil))
-    sFoo3
-      = applySing
-          (applySing
-             (applySing
-                (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith)
-                (singFun2 (Proxy :: Proxy (:+$)) (%:+)))
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-                (applySing
-                   (applySing
-                      (singFun2 (Proxy :: Proxy (:$)) SCons)
-                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-                   SNil)))
-          (applySing
-             (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero)
-             (applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy (:$)) SCons)
-                   (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
-                SNil))
diff --git a/tests/compile-and-dump/Singletons/Star.ghc710.template b/tests/compile-and-dump/Singletons/Star.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Star.ghc710.template
@@ -0,0 +1,587 @@
+Singletons/Star.hs:0:0:: Splicing declarations
+    singletonStar [''Nat, ''Int, ''String, ''Maybe, ''Vec]
+  ======>
+    data Rep
+      = Singletons.Star.Nat |
+        Singletons.Star.Int |
+        Singletons.Star.String |
+        Singletons.Star.Maybe Rep |
+        Singletons.Star.Vec Rep Nat
+      deriving (Eq, Show, Read)
+    type family Equals_0123456789 (a :: *) (b :: *) :: Bool where
+      Equals_0123456789 Nat Nat = TrueSym0
+      Equals_0123456789 Int Int = TrueSym0
+      Equals_0123456789 String String = TrueSym0
+      Equals_0123456789 (Maybe a) (Maybe b) = (:==) a b
+      Equals_0123456789 (Vec a a) (Vec b b) = (:&&) ((:==) a b) ((:==) a b)
+      Equals_0123456789 (a :: *) (b :: *) = FalseSym0
+    instance PEq (KProxy :: KProxy *) where
+      type (:==) (a :: *) (b :: *) = Equals_0123456789 a b
+    type NatSym0 = Nat
+    type IntSym0 = Int
+    type StringSym0 = String
+    type MaybeSym1 (t :: *) = Maybe t
+    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings MaybeSym0 where
+      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) MaybeSym0KindInference GHC.Tuple.())
+    data MaybeSym0 (l :: TyFun * *)
+      = forall arg. KindOf (Apply MaybeSym0 arg) ~ KindOf (MaybeSym1 arg) =>
+        MaybeSym0KindInference
+    type instance Apply MaybeSym0 l = MaybeSym1 l
+    type VecSym2 (t :: *) (t :: Nat) = Vec t t
+    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings VecSym1 where
+      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) VecSym1KindInference GHC.Tuple.())
+    data VecSym1 (l :: *) (l :: TyFun Nat *)
+      = forall arg. KindOf (Apply (VecSym1 l) arg) ~ KindOf (VecSym2 l arg) =>
+        VecSym1KindInference
+    type instance Apply (VecSym1 l) l = VecSym2 l l
+    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings VecSym0 where
+      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) VecSym0KindInference GHC.Tuple.())
+    data VecSym0 (l :: TyFun * (TyFun Nat * -> *))
+      = forall arg. KindOf (Apply VecSym0 arg) ~ KindOf (VecSym1 arg) =>
+        VecSym0KindInference
+    type instance Apply VecSym0 l = VecSym1 l
+    type family Compare_0123456789 (a :: *) (a :: *) :: Ordering where
+      Compare_0123456789 Nat Nat = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]
+      Compare_0123456789 Int Int = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]
+      Compare_0123456789 String String = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]
+      Compare_0123456789 (Maybe a_0123456789) (Maybe b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])
+      Compare_0123456789 (Vec a_0123456789 a_0123456789) (Vec b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]))
+      Compare_0123456789 Nat Int = LTSym0
+      Compare_0123456789 Nat String = LTSym0
+      Compare_0123456789 Nat (Maybe _z_0123456789) = LTSym0
+      Compare_0123456789 Nat (Vec _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 Int Nat = GTSym0
+      Compare_0123456789 Int String = LTSym0
+      Compare_0123456789 Int (Maybe _z_0123456789) = LTSym0
+      Compare_0123456789 Int (Vec _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 String Nat = GTSym0
+      Compare_0123456789 String Int = GTSym0
+      Compare_0123456789 String (Maybe _z_0123456789) = LTSym0
+      Compare_0123456789 String (Vec _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (Maybe _z_0123456789) Nat = GTSym0
+      Compare_0123456789 (Maybe _z_0123456789) Int = GTSym0
+      Compare_0123456789 (Maybe _z_0123456789) String = GTSym0
+      Compare_0123456789 (Maybe _z_0123456789) (Vec _z_0123456789 _z_0123456789) = LTSym0
+      Compare_0123456789 (Vec _z_0123456789 _z_0123456789) Nat = GTSym0
+      Compare_0123456789 (Vec _z_0123456789 _z_0123456789) Int = GTSym0
+      Compare_0123456789 (Vec _z_0123456789 _z_0123456789) String = GTSym0
+      Compare_0123456789 (Vec _z_0123456789 _z_0123456789) (Maybe _z_0123456789) = GTSym0
+    type Compare_0123456789Sym2 (t :: *) (t :: *) =
+        Compare_0123456789 t t
+    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings Compare_0123456789Sym1 where
+      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.())
+    data Compare_0123456789Sym1 (l :: *) (l :: TyFun * Ordering)
+      = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) =>
+        Compare_0123456789Sym1KindInference
+    type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l
+    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings Compare_0123456789Sym0 where
+      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.())
+    data Compare_0123456789Sym0 (l :: TyFun * (TyFun * Ordering -> *))
+      = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) =>
+        Compare_0123456789Sym0KindInference
+    type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l
+    instance POrd (KProxy :: KProxy *) where
+      type Compare (a :: *) (a :: *) = Apply (Apply Compare_0123456789Sym0 a) a
+    instance (SOrd (KProxy :: KProxy *),
+              SOrd (KProxy :: KProxy Nat)) =>
+             SOrd (KProxy :: KProxy *) where
+      sCompare ::
+        forall (t0 :: *) (t1 :: *).
+        Sing t0
+        -> Sing t1
+           -> Sing (Apply (Apply (CompareSym0 :: TyFun * (TyFun * Ordering
+                                                          -> *)
+                                                 -> *) t0 :: TyFun * Ordering -> *) t1 :: Ordering)
+      sCompare SNat SNat
+        = let
+            lambda ::
+              (t0 ~ NatSym0, t1 ~ NatSym0) =>
+              Sing (Apply (Apply CompareSym0 NatSym0) NatSym0 :: Ordering)
+            lambda
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl)
+                        (singFun2
+                           (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  SNil
+          in lambda
+      sCompare SInt SInt
+        = let
+            lambda ::
+              (t0 ~ IntSym0, t1 ~ IntSym0) =>
+              Sing (Apply (Apply CompareSym0 IntSym0) IntSym0 :: Ordering)
+            lambda
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl)
+                        (singFun2
+                           (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  SNil
+          in lambda
+      sCompare SString SString
+        = let
+            lambda ::
+              (t0 ~ StringSym0, t1 ~ StringSym0) =>
+              Sing (Apply (Apply CompareSym0 StringSym0) StringSym0 :: Ordering)
+            lambda
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl)
+                        (singFun2
+                           (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  SNil
+          in lambda
+      sCompare (SMaybe sA_0123456789) (SMaybe sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     b_0123456789. (t0 ~ Apply MaybeSym0 a_0123456789,
+                                    t1 ~ Apply MaybeSym0 b_0123456789) =>
+              Sing a_0123456789
+              -> Sing b_0123456789
+                 -> Sing (Apply (Apply CompareSym0 (Apply MaybeSym0 a_0123456789)) (Apply MaybeSym0 b_0123456789) :: Ordering)
+            lambda a_0123456789 b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl)
+                        (singFun2
+                           (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2
+                                 (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare)
+                              a_0123456789)
+                           b_0123456789))
+                     SNil)
+          in lambda sA_0123456789 sB_0123456789
+      sCompare
+        (SVec sA_0123456789 sA_0123456789)
+        (SVec sB_0123456789 sB_0123456789)
+        = let
+            lambda ::
+              forall a_0123456789
+                     a_0123456789
+                     b_0123456789
+                     b_0123456789. (t0 ~ Apply (Apply VecSym0 a_0123456789) a_0123456789,
+                                    t1 ~ Apply (Apply VecSym0 b_0123456789) b_0123456789) =>
+              Sing a_0123456789
+              -> Sing a_0123456789
+                 -> Sing b_0123456789
+                    -> Sing b_0123456789
+                       -> Sing (Apply (Apply CompareSym0 (Apply (Apply VecSym0 a_0123456789) a_0123456789)) (Apply (Apply VecSym0 b_0123456789) b_0123456789) :: Ordering)
+            lambda a_0123456789 a_0123456789 b_0123456789 b_0123456789
+              = applySing
+                  (applySing
+                     (applySing
+                        (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl)
+                        (singFun2
+                           (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp))
+                     SEQ)
+                  (applySing
+                     (applySing
+                        (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons)
+                        (applySing
+                           (applySing
+                              (singFun2
+                                 (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare)
+                              a_0123456789)
+                           b_0123456789))
+                     (applySing
+                        (applySing
+                           (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons)
+                           (applySing
+                              (applySing
+                                 (singFun2
+                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare)
+                                 a_0123456789)
+                              b_0123456789))
+                        SNil))
+          in lambda sA_0123456789 sA_0123456789 sB_0123456789 sB_0123456789
+      sCompare SNat SInt
+        = let
+            lambda ::
+              (t0 ~ NatSym0, t1 ~ IntSym0) =>
+              Sing (Apply (Apply CompareSym0 NatSym0) IntSym0 :: Ordering)
+            lambda = SLT
+          in lambda
+      sCompare SNat SString
+        = let
+            lambda ::
+              (t0 ~ NatSym0, t1 ~ StringSym0) =>
+              Sing (Apply (Apply CompareSym0 NatSym0) StringSym0 :: Ordering)
+            lambda = SLT
+          in lambda
+      sCompare SNat (SMaybe _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ NatSym0,
+                                     t1 ~ Apply MaybeSym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 NatSym0) (Apply MaybeSym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 = SLT
+          in lambda _s_z_0123456789
+      sCompare SNat (SVec _s_z_0123456789 _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789 _z_0123456789. (t0 ~ NatSym0,
+                                                   t1 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing (Apply (Apply CompareSym0 NatSym0) (Apply (Apply VecSym0 _z_0123456789) _z_0123456789) :: Ordering)
+            lambda _z_0123456789 _z_0123456789 = SLT
+          in lambda _s_z_0123456789 _s_z_0123456789
+      sCompare SInt SNat
+        = let
+            lambda ::
+              (t0 ~ IntSym0, t1 ~ NatSym0) =>
+              Sing (Apply (Apply CompareSym0 IntSym0) NatSym0 :: Ordering)
+            lambda = SGT
+          in lambda
+      sCompare SInt SString
+        = let
+            lambda ::
+              (t0 ~ IntSym0, t1 ~ StringSym0) =>
+              Sing (Apply (Apply CompareSym0 IntSym0) StringSym0 :: Ordering)
+            lambda = SLT
+          in lambda
+      sCompare SInt (SMaybe _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ IntSym0,
+                                     t1 ~ Apply MaybeSym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 IntSym0) (Apply MaybeSym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 = SLT
+          in lambda _s_z_0123456789
+      sCompare SInt (SVec _s_z_0123456789 _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789 _z_0123456789. (t0 ~ IntSym0,
+                                                   t1 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing (Apply (Apply CompareSym0 IntSym0) (Apply (Apply VecSym0 _z_0123456789) _z_0123456789) :: Ordering)
+            lambda _z_0123456789 _z_0123456789 = SLT
+          in lambda _s_z_0123456789 _s_z_0123456789
+      sCompare SString SNat
+        = let
+            lambda ::
+              (t0 ~ StringSym0, t1 ~ NatSym0) =>
+              Sing (Apply (Apply CompareSym0 StringSym0) NatSym0 :: Ordering)
+            lambda = SGT
+          in lambda
+      sCompare SString SInt
+        = let
+            lambda ::
+              (t0 ~ StringSym0, t1 ~ IntSym0) =>
+              Sing (Apply (Apply CompareSym0 StringSym0) IntSym0 :: Ordering)
+            lambda = SGT
+          in lambda
+      sCompare SString (SMaybe _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ StringSym0,
+                                     t1 ~ Apply MaybeSym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 StringSym0) (Apply MaybeSym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 = SLT
+          in lambda _s_z_0123456789
+      sCompare SString (SVec _s_z_0123456789 _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789 _z_0123456789. (t0 ~ StringSym0,
+                                                   t1 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing (Apply (Apply CompareSym0 StringSym0) (Apply (Apply VecSym0 _z_0123456789) _z_0123456789) :: Ordering)
+            lambda _z_0123456789 _z_0123456789 = SLT
+          in lambda _s_z_0123456789 _s_z_0123456789
+      sCompare (SMaybe _s_z_0123456789) SNat
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ Apply MaybeSym0 _z_0123456789,
+                                     t1 ~ NatSym0) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 (Apply MaybeSym0 _z_0123456789)) NatSym0 :: Ordering)
+            lambda _z_0123456789 = SGT
+          in lambda _s_z_0123456789
+      sCompare (SMaybe _s_z_0123456789) SInt
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ Apply MaybeSym0 _z_0123456789,
+                                     t1 ~ IntSym0) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 (Apply MaybeSym0 _z_0123456789)) IntSym0 :: Ordering)
+            lambda _z_0123456789 = SGT
+          in lambda _s_z_0123456789
+      sCompare (SMaybe _s_z_0123456789) SString
+        = let
+            lambda ::
+              forall _z_0123456789. (t0 ~ Apply MaybeSym0 _z_0123456789,
+                                     t1 ~ StringSym0) =>
+              Sing _z_0123456789
+              -> Sing (Apply (Apply CompareSym0 (Apply MaybeSym0 _z_0123456789)) StringSym0 :: Ordering)
+            lambda _z_0123456789 = SGT
+          in lambda _s_z_0123456789
+      sCompare
+        (SMaybe _s_z_0123456789)
+        (SVec _s_z_0123456789 _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply MaybeSym0 _z_0123456789,
+                                     t1 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing (Apply (Apply CompareSym0 (Apply MaybeSym0 _z_0123456789)) (Apply (Apply VecSym0 _z_0123456789) _z_0123456789) :: Ordering)
+            lambda _z_0123456789 _z_0123456789 _z_0123456789 = SLT
+          in lambda _s_z_0123456789 _s_z_0123456789 _s_z_0123456789
+      sCompare (SVec _s_z_0123456789 _s_z_0123456789) SNat
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789,
+                                     t1 ~ NatSym0) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing (Apply (Apply CompareSym0 (Apply (Apply VecSym0 _z_0123456789) _z_0123456789)) NatSym0 :: Ordering)
+            lambda _z_0123456789 _z_0123456789 = SGT
+          in lambda _s_z_0123456789 _s_z_0123456789
+      sCompare (SVec _s_z_0123456789 _s_z_0123456789) SInt
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789,
+                                     t1 ~ IntSym0) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing (Apply (Apply CompareSym0 (Apply (Apply VecSym0 _z_0123456789) _z_0123456789)) IntSym0 :: Ordering)
+            lambda _z_0123456789 _z_0123456789 = SGT
+          in lambda _s_z_0123456789 _s_z_0123456789
+      sCompare (SVec _s_z_0123456789 _s_z_0123456789) SString
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789,
+                                     t1 ~ StringSym0) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing (Apply (Apply CompareSym0 (Apply (Apply VecSym0 _z_0123456789) _z_0123456789)) StringSym0 :: Ordering)
+            lambda _z_0123456789 _z_0123456789 = SGT
+          in lambda _s_z_0123456789 _s_z_0123456789
+      sCompare
+        (SVec _s_z_0123456789 _s_z_0123456789)
+        (SMaybe _s_z_0123456789)
+        = let
+            lambda ::
+              forall _z_0123456789
+                     _z_0123456789
+                     _z_0123456789. (t0 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789,
+                                     t1 ~ Apply MaybeSym0 _z_0123456789) =>
+              Sing _z_0123456789
+              -> Sing _z_0123456789
+                 -> Sing _z_0123456789
+                    -> Sing (Apply (Apply CompareSym0 (Apply (Apply VecSym0 _z_0123456789) _z_0123456789)) (Apply MaybeSym0 _z_0123456789) :: Ordering)
+            lambda _z_0123456789 _z_0123456789 _z_0123456789 = SGT
+          in lambda _s_z_0123456789 _s_z_0123456789 _s_z_0123456789
+    data instance Sing (z :: *)
+      = z ~ Nat => SNat |
+        z ~ Int => SInt |
+        z ~ String => SString |
+        forall (n :: *). z ~ Maybe n => SMaybe (Sing (n :: *)) |
+        forall (n :: *) (n :: Nat). z ~ Vec n n =>
+        SVec (Sing (n :: *)) (Sing (n :: Nat))
+    type SRep = (Sing :: * -> *)
+    instance SingKind (KProxy :: KProxy *) where
+      type DemoteRep (KProxy :: KProxy *) = Rep
+      fromSing SNat = Singletons.Star.Nat
+      fromSing SInt = Singletons.Star.Int
+      fromSing SString = Singletons.Star.String
+      fromSing (SMaybe b) = Singletons.Star.Maybe (fromSing b)
+      fromSing (SVec b b) = Singletons.Star.Vec (fromSing b) (fromSing b)
+      toSing Singletons.Star.Nat = SomeSing SNat
+      toSing Singletons.Star.Int = SomeSing SInt
+      toSing Singletons.Star.String = SomeSing SString
+      toSing (Singletons.Star.Maybe b)
+        = case toSing b :: SomeSing (KProxy :: KProxy *) of {
+            SomeSing c -> SomeSing (SMaybe c) }
+      toSing (Singletons.Star.Vec b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy *))
+                (toSing b :: SomeSing (KProxy :: KProxy Nat))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SVec c c) }
+    instance SEq (KProxy :: KProxy *) where
+      (%:==) SNat SNat = STrue
+      (%:==) SNat SInt = SFalse
+      (%:==) SNat SString = SFalse
+      (%:==) SNat (SMaybe _) = SFalse
+      (%:==) SNat (SVec _ _) = SFalse
+      (%:==) SInt SNat = SFalse
+      (%:==) SInt SInt = STrue
+      (%:==) SInt SString = SFalse
+      (%:==) SInt (SMaybe _) = SFalse
+      (%:==) SInt (SVec _ _) = SFalse
+      (%:==) SString SNat = SFalse
+      (%:==) SString SInt = SFalse
+      (%:==) SString SString = STrue
+      (%:==) SString (SMaybe _) = SFalse
+      (%:==) SString (SVec _ _) = SFalse
+      (%:==) (SMaybe _) SNat = SFalse
+      (%:==) (SMaybe _) SInt = SFalse
+      (%:==) (SMaybe _) SString = SFalse
+      (%:==) (SMaybe a) (SMaybe b) = (%:==) a b
+      (%:==) (SMaybe _) (SVec _ _) = SFalse
+      (%:==) (SVec _ _) SNat = SFalse
+      (%:==) (SVec _ _) SInt = SFalse
+      (%:==) (SVec _ _) SString = SFalse
+      (%:==) (SVec _ _) (SMaybe _) = SFalse
+      (%:==) (SVec a a) (SVec b b) = (%:&&) ((%:==) a b) ((%:==) a b)
+    instance SDecide (KProxy :: KProxy *) where
+      (%~) SNat SNat = Proved Refl
+      (%~) SNat SInt
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SNat SString
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SNat (SMaybe _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SNat (SVec _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SInt SNat
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SInt SInt = Proved Refl
+      (%~) SInt SString
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SInt (SMaybe _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SInt (SVec _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SString SNat
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SString SInt
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SString SString = Proved Refl
+      (%~) SString (SMaybe _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) SString (SVec _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SMaybe _) SNat
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SMaybe _) SInt
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SMaybe _) SString
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SMaybe a) (SMaybe b)
+        = case (%~) a b of {
+            Proved Refl -> Proved Refl
+            Disproved contra
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+      (%~) (SMaybe _) (SVec _ _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVec _ _) SNat
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVec _ _) SInt
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVec _ _) SString
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVec _ _) (SMaybe _)
+        = Disproved
+            (\ x
+               -> case x of {
+                    _ -> error "Empty case reached -- this should be impossible" })
+      (%~) (SVec a a) (SVec b b)
+        = case GHC.Tuple.(,) ((%~) a b) ((%~) a b) of {
+            GHC.Tuple.(,) (Proved Refl) (Proved Refl) -> Proved Refl
+            GHC.Tuple.(,) (Disproved contra) _
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
+            GHC.Tuple.(,) _ (Disproved contra)
+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
+    instance SingI Nat where
+      sing = SNat
+    instance SingI Int where
+      sing = SInt
+    instance SingI String where
+      sing = SString
+    instance SingI n => SingI (Maybe (n :: *)) where
+      sing = SMaybe sing
+    instance (SingI n, SingI n) =>
+             SingI (Vec (n :: *) (n :: Nat)) where
+      sing = SVec sing sing
diff --git a/tests/compile-and-dump/Singletons/Star.ghc78.template b/tests/compile-and-dump/Singletons/Star.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Star.ghc78.template
+++ /dev/null
@@ -1,252 +0,0 @@
-Singletons/Star.hs:0:0: Splicing declarations
-    singletonStar [''Nat, ''Int, ''String, ''Maybe, ''Vec]
-  ======>
-    Singletons/Star.hs:0:0:
-    data Rep
-      = Singletons.Star.Nat |
-        Singletons.Star.Int |
-        Singletons.Star.String |
-        Singletons.Star.Maybe Rep |
-        Singletons.Star.Vec Rep Nat
-      deriving (Eq, Show, Read)
-    type family Equals_0123456789 (a :: *) (b :: *) :: Bool where
-      Equals_0123456789 Nat Nat = TrueSym0
-      Equals_0123456789 Int Int = TrueSym0
-      Equals_0123456789 String String = TrueSym0
-      Equals_0123456789 (Maybe a) (Maybe b) = (:==) a b
-      Equals_0123456789 (Vec a a) (Vec b b) = (:&&) ((:==) a b) ((:==) a b)
-      Equals_0123456789 (a :: *) (b :: *) = FalseSym0
-    instance PEq (KProxy :: KProxy *) where
-      type (:==) (a :: *) (b :: *) = Equals_0123456789 a b
-    instance POrd (KProxy :: KProxy *) where
-      type Compare Nat Nat = EQ
-      type Compare Nat Int = LT
-      type Compare Nat String = LT
-      type Compare Nat (Maybe rhs) = LT
-      type Compare Nat (Vec rhs rhs) = LT
-      type Compare Int Nat = GT
-      type Compare Int Int = EQ
-      type Compare Int String = LT
-      type Compare Int (Maybe rhs) = LT
-      type Compare Int (Vec rhs rhs) = LT
-      type Compare String Nat = GT
-      type Compare String Int = GT
-      type Compare String String = EQ
-      type Compare String (Maybe rhs) = LT
-      type Compare String (Vec rhs rhs) = LT
-      type Compare (Maybe lhs) Nat = GT
-      type Compare (Maybe lhs) Int = GT
-      type Compare (Maybe lhs) String = GT
-      type Compare (Maybe lhs) (Maybe rhs) = ThenCmp EQ (Compare lhs rhs)
-      type Compare (Maybe lhs) (Vec rhs rhs) = LT
-      type Compare (Vec lhs lhs) Nat = GT
-      type Compare (Vec lhs lhs) Int = GT
-      type Compare (Vec lhs lhs) String = GT
-      type Compare (Vec lhs lhs) (Maybe rhs) = GT
-      type Compare (Vec lhs lhs) (Vec rhs rhs) = ThenCmp (ThenCmp EQ (Compare lhs rhs)) (Compare lhs rhs)
-    type NatSym0 = Nat
-    type IntSym0 = Int
-    type StringSym0 = String
-    type MaybeSym1 (t :: *) = Maybe t
-    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings MaybeSym0 where
-      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) MaybeSym0KindInference GHC.Tuple.())
-    data MaybeSym0 (l :: TyFun * *)
-      = forall arg. KindOf (Apply MaybeSym0 arg) ~ KindOf (MaybeSym1 arg) =>
-        MaybeSym0KindInference
-    type instance Apply MaybeSym0 l = MaybeSym1 l
-    type VecSym2 (t :: *) (t :: Nat) = Vec t t
-    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings VecSym1 where
-      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) VecSym1KindInference GHC.Tuple.())
-    data VecSym1 (l :: *) (l :: TyFun Nat *)
-      = forall arg. KindOf (Apply (VecSym1 l) arg) ~ KindOf (VecSym2 l arg) =>
-        VecSym1KindInference
-    type instance Apply (VecSym1 l) l = VecSym2 l l
-    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings VecSym0 where
-      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) VecSym0KindInference GHC.Tuple.())
-    data VecSym0 (l :: TyFun * (TyFun Nat * -> *))
-      = forall arg. KindOf (Apply VecSym0 arg) ~ KindOf (VecSym1 arg) =>
-        VecSym0KindInference
-    type instance Apply VecSym0 l = VecSym1 l
-    data instance Sing (z :: *)
-      = z ~ Nat => SNat |
-        z ~ Int => SInt |
-        z ~ String => SString |
-        forall (n :: *). z ~ Maybe n => SMaybe (Sing n) |
-        forall (n :: *) (n :: Nat). z ~ Vec n n => SVec (Sing n) (Sing n)
-    type SRep (z :: *) = Sing z
-    instance SingKind (KProxy :: KProxy *) where
-      type DemoteRep (KProxy :: KProxy *) = Rep
-      fromSing SNat = Singletons.Star.Nat
-      fromSing SInt = Singletons.Star.Int
-      fromSing SString = Singletons.Star.String
-      fromSing (SMaybe b) = Singletons.Star.Maybe (fromSing b)
-      fromSing (SVec b b) = Singletons.Star.Vec (fromSing b) (fromSing b)
-      toSing Singletons.Star.Nat = SomeSing SNat
-      toSing Singletons.Star.Int = SomeSing SInt
-      toSing Singletons.Star.String = SomeSing SString
-      toSing (Singletons.Star.Maybe b)
-        = case toSing b :: SomeSing (KProxy :: KProxy *) of {
-            SomeSing c -> SomeSing (SMaybe c) }
-      toSing (Singletons.Star.Vec b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy *))
-                (toSing b :: SomeSing (KProxy :: KProxy Nat))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SVec c c) }
-    instance SEq (KProxy :: KProxy *) where
-      (%:==) SNat SNat = STrue
-      (%:==) SNat SInt = SFalse
-      (%:==) SNat SString = SFalse
-      (%:==) SNat (SMaybe _) = SFalse
-      (%:==) SNat (SVec _ _) = SFalse
-      (%:==) SInt SNat = SFalse
-      (%:==) SInt SInt = STrue
-      (%:==) SInt SString = SFalse
-      (%:==) SInt (SMaybe _) = SFalse
-      (%:==) SInt (SVec _ _) = SFalse
-      (%:==) SString SNat = SFalse
-      (%:==) SString SInt = SFalse
-      (%:==) SString SString = STrue
-      (%:==) SString (SMaybe _) = SFalse
-      (%:==) SString (SVec _ _) = SFalse
-      (%:==) (SMaybe _) SNat = SFalse
-      (%:==) (SMaybe _) SInt = SFalse
-      (%:==) (SMaybe _) SString = SFalse
-      (%:==) (SMaybe a) (SMaybe b) = (%:==) a b
-      (%:==) (SMaybe _) (SVec _ _) = SFalse
-      (%:==) (SVec _ _) SNat = SFalse
-      (%:==) (SVec _ _) SInt = SFalse
-      (%:==) (SVec _ _) SString = SFalse
-      (%:==) (SVec _ _) (SMaybe _) = SFalse
-      (%:==) (SVec a a) (SVec b b) = (%:&&) ((%:==) a b) ((%:==) a b)
-    instance SDecide (KProxy :: KProxy *) where
-      (%~) SNat SNat = Proved Refl
-      (%~) SNat SInt
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SNat SString
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SNat (SMaybe _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SNat (SVec _ _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SInt SNat
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SInt SInt = Proved Refl
-      (%~) SInt SString
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SInt (SMaybe _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SInt (SVec _ _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SString SNat
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SString SInt
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SString SString = Proved Refl
-      (%~) SString (SMaybe _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) SString (SVec _ _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SMaybe _) SNat
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SMaybe _) SInt
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SMaybe _) SString
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SMaybe a) (SMaybe b)
-        = case (%~) a b of {
-            Proved Refl -> Proved Refl
-            Disproved contra
-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
-      (%~) (SMaybe _) (SVec _ _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVec _ _) SNat
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVec _ _) SInt
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVec _ _) SString
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVec _ _) (SMaybe _)
-        = Disproved
-            (\ x
-               -> case x of {
-                    _ -> error "Empty case reached -- this should be impossible" })
-      (%~) (SVec a a) (SVec b b)
-        = case GHC.Tuple.(,) ((%~) a b) ((%~) a b) of {
-            GHC.Tuple.(,) (Proved Refl) (Proved Refl) -> Proved Refl
-            GHC.Tuple.(,) (Disproved contra) _
-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })
-            GHC.Tuple.(,) _ (Disproved contra)
-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) }
-    instance SingI Nat where
-      sing = SNat
-    instance SingI Int where
-      sing = SInt
-    instance SingI String where
-      sing = SString
-    instance SingI n => SingI (Maybe (n :: *)) where
-      sing = SMaybe sing
-    instance (SingI n, SingI n) =>
-             SingI (Vec (n :: *) (n :: Nat)) where
-      sing = SVec sing sing
diff --git a/tests/compile-and-dump/Singletons/T124.ghc710.template b/tests/compile-and-dump/Singletons/T124.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T124.ghc710.template
@@ -0,0 +1,37 @@
+Singletons/T124.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo :: Bool -> ()
+          foo True = ()
+          foo False = () |]
+  ======>
+    foo :: Bool -> ()
+    foo True = GHC.Tuple.()
+    foo False = GHC.Tuple.()
+    type FooSym1 (t :: Bool) = Foo t
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun Bool ())
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type family Foo (a :: Bool) :: () where
+      Foo True = Tuple0Sym0
+      Foo False = Tuple0Sym0
+    sFoo :: forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: ())
+    sFoo STrue
+      = let
+          lambda :: t ~ TrueSym0 => Sing (Apply FooSym0 TrueSym0 :: ())
+          lambda = STuple0
+        in lambda
+    sFoo SFalse
+      = let
+          lambda :: t ~ FalseSym0 => Sing (Apply FooSym0 FalseSym0 :: ())
+          lambda = STuple0
+        in lambda
+Singletons/T124.hs:0:0:: Splicing expression
+    sCases ''Bool [| b |] [| STuple0 |]
+  ======>
+    case b of {
+      SFalse -> STuple0
+      STrue -> STuple0 }
diff --git a/tests/compile-and-dump/Singletons/T124.hs b/tests/compile-and-dump/Singletons/T124.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T124.hs
@@ -0,0 +1,13 @@
+module Singletons.T124 where
+
+import Data.Singletons.TH
+import Data.Singletons.Prelude
+
+$(singletons [d|
+  foo :: Bool -> ()
+  foo True = ()
+  foo False = ()
+  |])
+
+bar :: SBool b -> STuple0 (Foo b)
+bar b = $(sCases ''Bool [| b |] [| STuple0 |])
diff --git a/tests/compile-and-dump/Singletons/T29.ghc710.template b/tests/compile-and-dump/Singletons/T29.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T29.ghc710.template
@@ -0,0 +1,127 @@
+Singletons/T29.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo :: Bool -> Bool
+          foo x = not $ x
+          bar :: Bool -> Bool
+          bar x = not . not . not $ x
+          baz :: Bool -> Bool
+          baz x = not $! x
+          ban :: Bool -> Bool
+          ban x = not . not . not $! x |]
+  ======>
+    foo :: Bool -> Bool
+    foo x = (not $ x)
+    bar :: Bool -> Bool
+    bar x = ((not . (not . not)) $ x)
+    baz :: Bool -> Bool
+    baz x = (not $! x)
+    ban :: Bool -> Bool
+    ban x = ((not . (not . not)) $! x)
+    type BanSym1 (t :: Bool) = Ban t
+    instance SuppressUnusedWarnings BanSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BanSym0KindInference GHC.Tuple.())
+    data BanSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply BanSym0 arg) ~ KindOf (BanSym1 arg) =>
+        BanSym0KindInference
+    type instance Apply BanSym0 l = BanSym1 l
+    type BazSym1 (t :: Bool) = Baz t
+    instance SuppressUnusedWarnings BazSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.())
+    data BazSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>
+        BazSym0KindInference
+    type instance Apply BazSym0 l = BazSym1 l
+    type BarSym1 (t :: Bool) = Bar t
+    instance SuppressUnusedWarnings BarSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
+    data BarSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
+        BarSym0KindInference
+    type instance Apply BarSym0 l = BarSym1 l
+    type FooSym1 (t :: Bool) = Foo t
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type family Ban (a :: Bool) :: Bool where
+      Ban x = Apply (Apply ($!$) (Apply (Apply (:.$) NotSym0) (Apply (Apply (:.$) NotSym0) NotSym0))) x
+    type family Baz (a :: Bool) :: Bool where
+      Baz x = Apply (Apply ($!$) NotSym0) x
+    type family Bar (a :: Bool) :: Bool where
+      Bar x = Apply (Apply ($$) (Apply (Apply (:.$) NotSym0) (Apply (Apply (:.$) NotSym0) NotSym0))) x
+    type family Foo (a :: Bool) :: Bool where
+      Foo x = Apply (Apply ($$) NotSym0) x
+    sBan ::
+      forall (t :: Bool). Sing t -> Sing (Apply BanSym0 t :: Bool)
+    sBaz ::
+      forall (t :: Bool). Sing t -> Sing (Apply BazSym0 t :: Bool)
+    sBar ::
+      forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool)
+    sFoo ::
+      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)
+    sBan sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply BanSym0 x :: Bool)
+          lambda x
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy ($!$)) (%$!))
+                   (applySing
+                      (applySing
+                         (singFun3 (Proxy :: Proxy (:.$)) (%:.))
+                         (singFun1 (Proxy :: Proxy NotSym0) sNot))
+                      (applySing
+                         (applySing
+                            (singFun3 (Proxy :: Proxy (:.$)) (%:.))
+                            (singFun1 (Proxy :: Proxy NotSym0) sNot))
+                         (singFun1 (Proxy :: Proxy NotSym0) sNot))))
+                x
+        in lambda sX
+    sBaz sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply BazSym0 x :: Bool)
+          lambda x
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy ($!$)) (%$!))
+                   (singFun1 (Proxy :: Proxy NotSym0) sNot))
+                x
+        in lambda sX
+    sBar sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply BarSym0 x :: Bool)
+          lambda x
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy ($$)) (%$))
+                   (applySing
+                      (applySing
+                         (singFun3 (Proxy :: Proxy (:.$)) (%:.))
+                         (singFun1 (Proxy :: Proxy NotSym0) sNot))
+                      (applySing
+                         (applySing
+                            (singFun3 (Proxy :: Proxy (:.$)) (%:.))
+                            (singFun1 (Proxy :: Proxy NotSym0) sNot))
+                         (singFun1 (Proxy :: Proxy NotSym0) sNot))))
+                x
+        in lambda sX
+    sFoo sX
+      = let
+          lambda ::
+            forall x. t ~ x => Sing x -> Sing (Apply FooSym0 x :: Bool)
+          lambda x
+            = applySing
+                (applySing
+                   (singFun2 (Proxy :: Proxy ($$)) (%$))
+                   (singFun1 (Proxy :: Proxy NotSym0) sNot))
+                x
+        in lambda sX
diff --git a/tests/compile-and-dump/Singletons/T29.ghc78.template b/tests/compile-and-dump/Singletons/T29.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/T29.ghc78.template
+++ /dev/null
@@ -1,120 +0,0 @@
-Singletons/T29.hs:0:0: Splicing declarations
-    singletons
-      [d| foo :: Bool -> Bool
-          foo x = not $ x
-          bar :: Bool -> Bool
-          bar x = not . not . not $ x
-          baz :: Bool -> Bool
-          baz x = not $! x
-          ban :: Bool -> Bool
-          ban x = not . not . not $! x |]
-  ======>
-    Singletons/T29.hs:(0,0)-(0,0)
-    foo :: Bool -> Bool
-    foo x = (not $ x)
-    bar :: Bool -> Bool
-    bar x = ((not . (not . not)) $ x)
-    baz :: Bool -> Bool
-    baz x = (not $! x)
-    ban :: Bool -> Bool
-    ban x = ((not . (not . not)) $! x)
-    type BanSym1 (t :: Bool) = Ban t
-    instance SuppressUnusedWarnings BanSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BanSym0KindInference GHC.Tuple.())
-    data BanSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply BanSym0 arg) ~ KindOf (BanSym1 arg) =>
-        BanSym0KindInference
-    type instance Apply BanSym0 l = BanSym1 l
-    type BazSym1 (t :: Bool) = Baz t
-    instance SuppressUnusedWarnings BazSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.())
-    data BazSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>
-        BazSym0KindInference
-    type instance Apply BazSym0 l = BazSym1 l
-    type BarSym1 (t :: Bool) = Bar t
-    instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
-    data BarSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
-        BarSym0KindInference
-    type instance Apply BarSym0 l = BarSym1 l
-    type FooSym1 (t :: Bool) = Foo t
-    instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
-    data FooSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
-        FooSym0KindInference
-    type instance Apply FooSym0 l = FooSym1 l
-    type family Ban (a :: Bool) :: Bool where
-      Ban x = Apply (Apply ($!$) (Apply (Apply (:.$) NotSym0) (Apply (Apply (:.$) NotSym0) NotSym0))) x
-    type family Baz (a :: Bool) :: Bool where
-      Baz x = Apply (Apply ($!$) NotSym0) x
-    type family Bar (a :: Bool) :: Bool where
-      Bar x = Apply (Apply ($$) (Apply (Apply (:.$) NotSym0) (Apply (Apply (:.$) NotSym0) NotSym0))) x
-    type family Foo (a :: Bool) :: Bool where
-      Foo x = Apply (Apply ($$) NotSym0) x
-    sBan :: forall (t :: Bool). Sing t -> Sing (Apply BanSym0 t)
-    sBaz :: forall (t :: Bool). Sing t -> Sing (Apply BazSym0 t)
-    sBar :: forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t)
-    sFoo :: forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t)
-    sBan sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply BanSym0 x)
-          lambda x
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy ($!$)) (%$!))
-                   (applySing
-                      (applySing
-                         (singFun3 (Proxy :: Proxy (:.$)) (%:.))
-                         (singFun1 (Proxy :: Proxy NotSym0) sNot))
-                      (applySing
-                         (applySing
-                            (singFun3 (Proxy :: Proxy (:.$)) (%:.))
-                            (singFun1 (Proxy :: Proxy NotSym0) sNot))
-                         (singFun1 (Proxy :: Proxy NotSym0) sNot))))
-                x
-        in lambda sX
-    sBaz sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply BazSym0 x)
-          lambda x
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy ($!$)) (%$!))
-                   (singFun1 (Proxy :: Proxy NotSym0) sNot))
-                x
-        in lambda sX
-    sBar sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply BarSym0 x)
-          lambda x
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy ($$)) (%$))
-                   (applySing
-                      (applySing
-                         (singFun3 (Proxy :: Proxy (:.$)) (%:.))
-                         (singFun1 (Proxy :: Proxy NotSym0) sNot))
-                      (applySing
-                         (applySing
-                            (singFun3 (Proxy :: Proxy (:.$)) (%:.))
-                            (singFun1 (Proxy :: Proxy NotSym0) sNot))
-                         (singFun1 (Proxy :: Proxy NotSym0) sNot))))
-                x
-        in lambda sX
-    sFoo sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply FooSym0 x)
-          lambda x
-            = applySing
-                (applySing
-                   (singFun2 (Proxy :: Proxy ($$)) (%$))
-                   (singFun1 (Proxy :: Proxy NotSym0) sNot))
-                x
-        in lambda sX
diff --git a/tests/compile-and-dump/Singletons/T33.ghc710.template b/tests/compile-and-dump/Singletons/T33.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T33.ghc710.template
@@ -0,0 +1,35 @@
+Singletons/T33.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo :: (Bool, Bool) -> ()
+          foo ~(_, _) = () |]
+  ======>
+    foo :: (Bool, Bool) -> ()
+    foo ~(_, _) = GHC.Tuple.()
+    type FooSym1 (t :: (Bool, Bool)) = Foo t
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun (Bool, Bool) ())
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type family Foo (a :: (Bool, Bool)) :: () where
+      Foo '(_z_0123456789, _z_0123456789) = Tuple0Sym0
+    sFoo ::
+      forall (t :: (Bool, Bool)). Sing t -> Sing (Apply FooSym0 t :: ())
+    sFoo (STuple2 _s_z_0123456789 _s_z_0123456789)
+      = let
+          lambda ::
+            forall _z_0123456789
+                   _z_0123456789. t ~ Apply (Apply Tuple2Sym0 _z_0123456789) _z_0123456789 =>
+            Sing _z_0123456789
+            -> Sing _z_0123456789
+               -> Sing (Apply FooSym0 (Apply (Apply Tuple2Sym0 _z_0123456789) _z_0123456789) :: ())
+          lambda _z_0123456789 _z_0123456789 = STuple0
+        in lambda _s_z_0123456789 _s_z_0123456789
+
+Singletons/T33.hs:0:0: Warning:
+    Lazy pattern converted into regular pattern in promotion
+
+Singletons/T33.hs:0:0: Warning:
+    Lazy pattern converted into regular pattern during singleton generation.
diff --git a/tests/compile-and-dump/Singletons/T33.ghc78.template b/tests/compile-and-dump/Singletons/T33.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/T33.ghc78.template
+++ /dev/null
@@ -1,33 +0,0 @@
-Singletons/T33.hs:0:0: Splicing declarations
-    singletons
-      [d| foo :: (Bool, Bool) -> ()
-          foo ~(_, _) = () |]
-  ======>
-    Singletons/T33.hs:(0,0)-(0,0)
-    foo :: (Bool, Bool) -> ()
-    foo ~(_, _) = GHC.Tuple.()
-    type FooSym1 (t :: (Bool, Bool)) = Foo t
-    instance SuppressUnusedWarnings FooSym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
-    data FooSym0 (l :: TyFun (Bool, Bool) ())
-      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
-        FooSym0KindInference
-    type instance Apply FooSym0 l = FooSym1 l
-    type family Foo (a :: (Bool, Bool)) :: () where
-      Foo '(z, z) = Tuple0Sym0
-    sFoo ::
-      forall (t :: (Bool, Bool)). Sing t -> Sing (Apply FooSym0 t)
-    sFoo (STuple2 _ _)
-      = let
-          lambda ::
-            forall wild wild. t ~ Apply (Apply Tuple2Sym0 wild) wild =>
-            Sing (Apply FooSym0 (Apply (Apply Tuple2Sym0 wild) wild))
-          lambda = STuple0
-        in lambda
-
-Singletons/T33.hs:0:0: Warning:
-    Lazy pattern converted into regular pattern in promotion
-
-Singletons/T33.hs:0:0: Warning:
-    Lazy pattern converted into regular pattern during singleton generation.
diff --git a/tests/compile-and-dump/Singletons/T54.ghc710.template b/tests/compile-and-dump/Singletons/T54.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T54.ghc710.template
@@ -0,0 +1,59 @@
+Singletons/T54.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| g :: Bool -> Bool
+          g e = (case [not] of { [_] -> not }) e |]
+  ======>
+    g :: Bool -> Bool
+    g e = case [not] of { [_] -> not } e
+    type Let0123456789Scrutinee_0123456789Sym1 t =
+        Let0123456789Scrutinee_0123456789 t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
+      suppressUnusedWarnings _
+        = snd
+            (GHC.Tuple.(,)
+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
+    data Let0123456789Scrutinee_0123456789Sym0 l
+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
+        Let0123456789Scrutinee_0123456789Sym0KindInference
+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
+    type family Let0123456789Scrutinee_0123456789 e where
+      Let0123456789Scrutinee_0123456789 e = Apply (Apply (:$) NotSym0) '[]
+    type family Case_0123456789 e t where
+      Case_0123456789 e '[_z_0123456789] = NotSym0
+    type GSym1 (t :: Bool) = G t
+    instance SuppressUnusedWarnings GSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) GSym0KindInference GHC.Tuple.())
+    data GSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply GSym0 arg) ~ KindOf (GSym1 arg) =>
+        GSym0KindInference
+    type instance Apply GSym0 l = GSym1 l
+    type family G (a :: Bool) :: Bool where
+      G e = Apply (Case_0123456789 e (Let0123456789Scrutinee_0123456789Sym1 e)) e
+    sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool)
+    sG sE
+      = let
+          lambda :: forall e. t ~ e => Sing e -> Sing (Apply GSym0 e :: Bool)
+          lambda e
+            = applySing
+                (let
+                   sScrutinee_0123456789 ::
+                     Sing (Let0123456789Scrutinee_0123456789Sym1 e)
+                   sScrutinee_0123456789
+                     = applySing
+                         (applySing
+                            (singFun2 (Proxy :: Proxy (:$)) SCons)
+                            (singFun1 (Proxy :: Proxy NotSym0) sNot))
+                         SNil
+                 in  case sScrutinee_0123456789 of {
+                       SCons _s_z_0123456789 SNil
+                         -> let
+                              lambda ::
+                                forall _z_0123456789. Apply (Apply (:$) _z_0123456789) '[] ~ Let0123456789Scrutinee_0123456789Sym1 e =>
+                                Sing _z_0123456789
+                                -> Sing (Case_0123456789 e (Apply (Apply (:$) _z_0123456789) '[]))
+                              lambda _z_0123456789 = singFun1 (Proxy :: Proxy NotSym0) sNot
+                            in lambda _s_z_0123456789 } ::
+                       Sing (Case_0123456789 e (Let0123456789Scrutinee_0123456789Sym1 e)))
+                e
+        in lambda sE
diff --git a/tests/compile-and-dump/Singletons/T54.hs b/tests/compile-and-dump/Singletons/T54.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T54.hs
@@ -0,0 +1,12 @@
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
+
+module Singletons.T54 where
+
+import Data.Singletons.TH
+import Data.Singletons.Prelude
+
+$(singletons [d|
+  g :: Bool -> Bool
+  g e = (case [not] of
+            [_] -> not) e
+  |])
diff --git a/tests/compile-and-dump/Singletons/T78.ghc710.template b/tests/compile-and-dump/Singletons/T78.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T78.ghc710.template
@@ -0,0 +1,45 @@
+Singletons/T78.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo :: MaybeBool -> Bool
+          foo (Just False) = False
+          foo (Just True) = True
+          foo Nothing = False |]
+  ======>
+    foo :: MaybeBool -> Bool
+    foo (Just False) = False
+    foo (Just True) = True
+    foo Nothing = False
+    type FooSym1 (t :: Maybe Bool) = Foo t
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun (Maybe Bool) Bool)
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type family Foo (a :: Maybe Bool) :: Bool where
+      Foo (Just False) = FalseSym0
+      Foo (Just True) = TrueSym0
+      Foo Nothing = FalseSym0
+    sFoo ::
+      forall (t :: Maybe Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)
+    sFoo (SJust SFalse)
+      = let
+          lambda ::
+            t ~ Apply JustSym0 FalseSym0 =>
+            Sing (Apply FooSym0 (Apply JustSym0 FalseSym0) :: Bool)
+          lambda = SFalse
+        in lambda
+    sFoo (SJust STrue)
+      = let
+          lambda ::
+            t ~ Apply JustSym0 TrueSym0 =>
+            Sing (Apply FooSym0 (Apply JustSym0 TrueSym0) :: Bool)
+          lambda = STrue
+        in lambda
+    sFoo SNothing
+      = let
+          lambda ::
+            t ~ NothingSym0 => Sing (Apply FooSym0 NothingSym0 :: Bool)
+          lambda = SFalse
+        in lambda
diff --git a/tests/compile-and-dump/Singletons/T78.hs b/tests/compile-and-dump/Singletons/T78.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/T78.hs
@@ -0,0 +1,13 @@
+module Singletons.T78 where
+
+import Data.Singletons.TH
+import Data.Singletons.Prelude
+
+type MaybeBool = Maybe Bool
+
+$(singletons [d|
+  foo :: MaybeBool -> Bool
+  foo (Just False) = False
+  foo (Just True)  = True
+  foo Nothing      = False
+  |])
diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc710.template b/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc710.template
@@ -0,0 +1,404 @@
+Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| data Bool = False | True
+          data Foo = Bar Bool Bool |]
+  ======>
+    data Bool = False | True
+    data Foo = Bar Bool Bool
+    type FalseSym0 = False
+    type TrueSym0 = True
+    type BarSym2 (t :: Bool) (t :: Bool) = Bar t t
+    instance SuppressUnusedWarnings BarSym1 where
+      suppressUnusedWarnings _
+        = Data.Tuple.snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.())
+    data BarSym1 (l :: Bool) (l :: TyFun Bool Foo)
+      = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) =>
+        BarSym1KindInference
+    type instance Apply (BarSym1 l) l = BarSym2 l l
+    instance SuppressUnusedWarnings BarSym0 where
+      suppressUnusedWarnings _
+        = Data.Tuple.snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
+    data BarSym0 (l :: TyFun Bool (TyFun Bool Foo -> *))
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
+        BarSym0KindInference
+    type instance Apply BarSym0 l = BarSym1 l
+    data instance Sing (z :: Bool)
+      = z ~ False => SFalse | z ~ True => STrue
+    type SBool = (Sing :: Bool -> *)
+    instance SingKind (KProxy :: KProxy Bool) where
+      type DemoteRep (KProxy :: KProxy Bool) = Bool
+      fromSing SFalse = False
+      fromSing STrue = True
+      toSing False = SomeSing SFalse
+      toSing True = SomeSing STrue
+    data instance Sing (z :: Foo)
+      = forall (n :: Bool) (n :: Bool). z ~ Bar n n =>
+        SBar (Sing (n :: Bool)) (Sing (n :: Bool))
+    type SFoo = (Sing :: Foo -> *)
+    instance SingKind (KProxy :: KProxy Foo) where
+      type DemoteRep (KProxy :: KProxy Foo) = Foo
+      fromSing (SBar b b) = Bar (fromSing b) (fromSing b)
+      toSing (Bar b b)
+        = case
+              GHC.Tuple.(,)
+                (toSing b :: SomeSing (KProxy :: KProxy Bool))
+                (toSing b :: SomeSing (KProxy :: KProxy Bool))
+          of {
+            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SBar c c) }
+    instance SingI False where
+      sing = SFalse
+    instance SingI True where
+      sing = STrue
+    instance (SingI n, SingI n) =>
+             SingI (Bar (n :: Bool) (n :: Bool)) where
+      sing = SBar sing sing
+Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| otherwise :: Bool
+          otherwise = True
+          id :: a -> a
+          id x = x
+          not :: Bool -> Bool
+          not True = False
+          not False = True
+          false_ = False
+          f, g :: Bool -> Bool
+          [f, g] = [not, id]
+          h, i :: Bool -> Bool
+          (h, i) = (f, g)
+          j, k :: Bool
+          (Bar j k) = Bar True (h False)
+          l, m :: Bool
+          [l, m] = [not True, id False] |]
+  ======>
+    otherwise :: Bool
+    otherwise = True
+    id :: forall a. a -> a
+    id x = x
+    not :: Bool -> Bool
+    not True = False
+    not False = True
+    false_ = False
+    f :: Bool -> Bool
+    g :: Bool -> Bool
+    [f, g] = [not, id]
+    h :: Bool -> Bool
+    i :: Bool -> Bool
+    (h, i) = (f, g)
+    j :: Bool
+    k :: Bool
+    Bar j k = Bar True (h False)
+    l :: Bool
+    m :: Bool
+    [l, m] = [not True, id False]
+    type family Case_0123456789 a_0123456789 t where
+      Case_0123456789 a_0123456789 '[y_0123456789,
+                                     _z_0123456789] = y_0123456789
+    type family Case_0123456789 a_0123456789 t where
+      Case_0123456789 a_0123456789 '[_z_0123456789,
+                                     y_0123456789] = y_0123456789
+    type family Case_0123456789 a_0123456789 t where
+      Case_0123456789 a_0123456789 '(y_0123456789,
+                                     _z_0123456789) = y_0123456789
+    type family Case_0123456789 a_0123456789 t where
+      Case_0123456789 a_0123456789 '(_z_0123456789,
+                                     y_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 (Bar y_0123456789 _z_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 (Bar _z_0123456789 y_0123456789) = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 '[y_0123456789, _z_0123456789] = y_0123456789
+    type family Case_0123456789 t where
+      Case_0123456789 '[_z_0123456789, y_0123456789] = y_0123456789
+    type False_Sym0 = False_
+    type NotSym1 (t :: Bool) = Not t
+    instance SuppressUnusedWarnings NotSym0 where
+      suppressUnusedWarnings _
+        = Data.Tuple.snd (GHC.Tuple.(,) NotSym0KindInference GHC.Tuple.())
+    data NotSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply NotSym0 arg) ~ KindOf (NotSym1 arg) =>
+        NotSym0KindInference
+    type instance Apply NotSym0 l = NotSym1 l
+    type IdSym1 (t :: a) = Id t
+    instance SuppressUnusedWarnings IdSym0 where
+      suppressUnusedWarnings _
+        = Data.Tuple.snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.())
+    data IdSym0 (l :: TyFun a a)
+      = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) =>
+        IdSym0KindInference
+    type instance Apply IdSym0 l = IdSym1 l
+    type FSym1 (t :: Bool) = F t
+    instance SuppressUnusedWarnings FSym0 where
+      suppressUnusedWarnings _
+        = Data.Tuple.snd (GHC.Tuple.(,) FSym0KindInference GHC.Tuple.())
+    data FSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply FSym0 arg) ~ KindOf (FSym1 arg) =>
+        FSym0KindInference
+    type instance Apply FSym0 l = FSym1 l
+    type GSym1 (t :: Bool) = G t
+    instance SuppressUnusedWarnings GSym0 where
+      suppressUnusedWarnings _
+        = Data.Tuple.snd (GHC.Tuple.(,) GSym0KindInference GHC.Tuple.())
+    data GSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply GSym0 arg) ~ KindOf (GSym1 arg) =>
+        GSym0KindInference
+    type instance Apply GSym0 l = GSym1 l
+    type HSym1 (t :: Bool) = H t
+    instance SuppressUnusedWarnings HSym0 where
+      suppressUnusedWarnings _
+        = Data.Tuple.snd (GHC.Tuple.(,) HSym0KindInference GHC.Tuple.())
+    data HSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply HSym0 arg) ~ KindOf (HSym1 arg) =>
+        HSym0KindInference
+    type instance Apply HSym0 l = HSym1 l
+    type ISym1 (t :: Bool) = I t
+    instance SuppressUnusedWarnings ISym0 where
+      suppressUnusedWarnings _
+        = Data.Tuple.snd (GHC.Tuple.(,) ISym0KindInference GHC.Tuple.())
+    data ISym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply ISym0 arg) ~ KindOf (ISym1 arg) =>
+        ISym0KindInference
+    type instance Apply ISym0 l = ISym1 l
+    type JSym0 = J
+    type KSym0 = K
+    type LSym0 = L
+    type MSym0 = M
+    type OtherwiseSym0 = Otherwise
+    type X_0123456789Sym0 = X_0123456789
+    type X_0123456789Sym0 = X_0123456789
+    type X_0123456789Sym0 = X_0123456789
+    type X_0123456789Sym0 = X_0123456789
+    type family False_ where
+      False_ = FalseSym0
+    type family Not (a :: Bool) :: Bool where
+      Not True = FalseSym0
+      Not False = TrueSym0
+    type family Id (a :: a) :: a where
+      Id x = x
+    type family F (a :: Bool) :: Bool where
+      F a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789
+    type family G (a :: Bool) :: Bool where
+      G a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789
+    type family H (a :: Bool) :: Bool where
+      H a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789
+    type family I (a :: Bool) :: Bool where
+      I a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789
+    type family J :: Bool where
+      J = Case_0123456789 X_0123456789Sym0
+    type family K :: Bool where
+      K = Case_0123456789 X_0123456789Sym0
+    type family L :: Bool where
+      L = Case_0123456789 X_0123456789Sym0
+    type family M :: Bool where
+      M = Case_0123456789 X_0123456789Sym0
+    type family Otherwise :: Bool where
+      Otherwise = TrueSym0
+    type family X_0123456789 where
+      X_0123456789 = Apply (Apply (:$) NotSym0) (Apply (Apply (:$) IdSym0) '[])
+    type family X_0123456789 where
+      X_0123456789 = Apply (Apply Tuple2Sym0 FSym0) GSym0
+    type family X_0123456789 where
+      X_0123456789 = Apply (Apply BarSym0 TrueSym0) (Apply HSym0 FalseSym0)
+    type family X_0123456789 where
+      X_0123456789 = Apply (Apply (:$) (Apply NotSym0 TrueSym0)) (Apply (Apply (:$) (Apply IdSym0 FalseSym0)) '[])
+    sFalse_ :: Sing False_Sym0
+    sNot ::
+      forall (t :: Bool). Sing t -> Sing (Apply NotSym0 t :: Bool)
+    sId :: forall (t :: a). Sing t -> Sing (Apply IdSym0 t :: a)
+    sF :: forall (t :: Bool). Sing t -> Sing (Apply FSym0 t :: Bool)
+    sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool)
+    sH :: forall (t :: Bool). Sing t -> Sing (Apply HSym0 t :: Bool)
+    sI :: forall (t :: Bool). Sing t -> Sing (Apply ISym0 t :: Bool)
+    sJ :: Sing (JSym0 :: Bool)
+    sK :: Sing (KSym0 :: Bool)
+    sL :: Sing (LSym0 :: Bool)
+    sM :: Sing (MSym0 :: Bool)
+    sOtherwise :: Sing (OtherwiseSym0 :: Bool)
+    sX_0123456789 :: Sing X_0123456789Sym0
+    sX_0123456789 :: Sing X_0123456789Sym0
+    sX_0123456789 :: Sing X_0123456789Sym0
+    sX_0123456789 :: Sing X_0123456789Sym0
+    sFalse_ = SFalse
+    sNot STrue
+      = let
+          lambda :: t ~ TrueSym0 => Sing (Apply NotSym0 TrueSym0 :: Bool)
+          lambda = SFalse
+        in lambda
+    sNot SFalse
+      = let
+          lambda :: t ~ FalseSym0 => Sing (Apply NotSym0 FalseSym0 :: Bool)
+          lambda = STrue
+        in lambda
+    sId sX
+      = let
+          lambda :: forall x. t ~ x => Sing x -> Sing (Apply IdSym0 x :: a)
+          lambda x = x
+        in lambda sX
+    sF sA_0123456789
+      = let
+          lambda ::
+            forall a_0123456789. t ~ a_0123456789 =>
+            Sing a_0123456789 -> Sing (Apply FSym0 a_0123456789 :: Bool)
+          lambda a_0123456789
+            = applySing
+                (case sX_0123456789 of {
+                   SCons sY_0123456789 (SCons _s_z_0123456789 SNil)
+                     -> let
+                          lambda ::
+                            forall y_0123456789
+                                   _z_0123456789. Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) _z_0123456789) '[]) ~ X_0123456789Sym0 =>
+                            Sing y_0123456789
+                            -> Sing _z_0123456789
+                               -> Sing (Case_0123456789 a_0123456789 (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) _z_0123456789) '[])))
+                          lambda y_0123456789 _z_0123456789 = y_0123456789
+                        in lambda sY_0123456789 _s_z_0123456789 } ::
+                   Sing (Case_0123456789 a_0123456789 X_0123456789Sym0))
+                a_0123456789
+        in lambda sA_0123456789
+    sG sA_0123456789
+      = let
+          lambda ::
+            forall a_0123456789. t ~ a_0123456789 =>
+            Sing a_0123456789 -> Sing (Apply GSym0 a_0123456789 :: Bool)
+          lambda a_0123456789
+            = applySing
+                (case sX_0123456789 of {
+                   SCons _s_z_0123456789 (SCons sY_0123456789 SNil)
+                     -> let
+                          lambda ::
+                            forall _z_0123456789
+                                   y_0123456789. Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) '[]) ~ X_0123456789Sym0 =>
+                            Sing _z_0123456789
+                            -> Sing y_0123456789
+                               -> Sing (Case_0123456789 a_0123456789 (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) '[])))
+                          lambda _z_0123456789 y_0123456789 = y_0123456789
+                        in lambda _s_z_0123456789 sY_0123456789 } ::
+                   Sing (Case_0123456789 a_0123456789 X_0123456789Sym0))
+                a_0123456789
+        in lambda sA_0123456789
+    sH sA_0123456789
+      = let
+          lambda ::
+            forall a_0123456789. t ~ a_0123456789 =>
+            Sing a_0123456789 -> Sing (Apply HSym0 a_0123456789 :: Bool)
+          lambda a_0123456789
+            = applySing
+                (case sX_0123456789 of {
+                   STuple2 sY_0123456789 _s_z_0123456789
+                     -> let
+                          lambda ::
+                            forall y_0123456789
+                                   _z_0123456789. Apply (Apply Tuple2Sym0 y_0123456789) _z_0123456789 ~ X_0123456789Sym0 =>
+                            Sing y_0123456789
+                            -> Sing _z_0123456789
+                               -> Sing (Case_0123456789 a_0123456789 (Apply (Apply Tuple2Sym0 y_0123456789) _z_0123456789))
+                          lambda y_0123456789 _z_0123456789 = y_0123456789
+                        in lambda sY_0123456789 _s_z_0123456789 } ::
+                   Sing (Case_0123456789 a_0123456789 X_0123456789Sym0))
+                a_0123456789
+        in lambda sA_0123456789
+    sI sA_0123456789
+      = let
+          lambda ::
+            forall a_0123456789. t ~ a_0123456789 =>
+            Sing a_0123456789 -> Sing (Apply ISym0 a_0123456789 :: Bool)
+          lambda a_0123456789
+            = applySing
+                (case sX_0123456789 of {
+                   STuple2 _s_z_0123456789 sY_0123456789
+                     -> let
+                          lambda ::
+                            forall _z_0123456789
+                                   y_0123456789. Apply (Apply Tuple2Sym0 _z_0123456789) y_0123456789 ~ X_0123456789Sym0 =>
+                            Sing _z_0123456789
+                            -> Sing y_0123456789
+                               -> Sing (Case_0123456789 a_0123456789 (Apply (Apply Tuple2Sym0 _z_0123456789) y_0123456789))
+                          lambda _z_0123456789 y_0123456789 = y_0123456789
+                        in lambda _s_z_0123456789 sY_0123456789 } ::
+                   Sing (Case_0123456789 a_0123456789 X_0123456789Sym0))
+                a_0123456789
+        in lambda sA_0123456789
+    sJ
+      = case sX_0123456789 of {
+          SBar sY_0123456789 _s_z_0123456789
+            -> let
+                 lambda ::
+                   forall y_0123456789
+                          _z_0123456789. Apply (Apply BarSym0 y_0123456789) _z_0123456789 ~ X_0123456789Sym0 =>
+                   Sing y_0123456789
+                   -> Sing _z_0123456789
+                      -> Sing (Case_0123456789 (Apply (Apply BarSym0 y_0123456789) _z_0123456789))
+                 lambda y_0123456789 _z_0123456789 = y_0123456789
+               in lambda sY_0123456789 _s_z_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sK
+      = case sX_0123456789 of {
+          SBar _s_z_0123456789 sY_0123456789
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          y_0123456789. Apply (Apply BarSym0 _z_0123456789) y_0123456789 ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing y_0123456789
+                      -> Sing (Case_0123456789 (Apply (Apply BarSym0 _z_0123456789) y_0123456789))
+                 lambda _z_0123456789 y_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 sY_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sL
+      = case sX_0123456789 of {
+          SCons sY_0123456789 (SCons _s_z_0123456789 SNil)
+            -> let
+                 lambda ::
+                   forall y_0123456789
+                          _z_0123456789. Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) _z_0123456789) '[]) ~ X_0123456789Sym0 =>
+                   Sing y_0123456789
+                   -> Sing _z_0123456789
+                      -> Sing (Case_0123456789 (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) _z_0123456789) '[])))
+                 lambda y_0123456789 _z_0123456789 = y_0123456789
+               in lambda sY_0123456789 _s_z_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sM
+      = case sX_0123456789 of {
+          SCons _s_z_0123456789 (SCons sY_0123456789 SNil)
+            -> let
+                 lambda ::
+                   forall _z_0123456789
+                          y_0123456789. Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) '[]) ~ X_0123456789Sym0 =>
+                   Sing _z_0123456789
+                   -> Sing y_0123456789
+                      -> Sing (Case_0123456789 (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) '[])))
+                 lambda _z_0123456789 y_0123456789 = y_0123456789
+               in lambda _s_z_0123456789 sY_0123456789 } ::
+          Sing (Case_0123456789 X_0123456789Sym0)
+    sOtherwise = STrue
+    sX_0123456789
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy (:$)) SCons)
+             (singFun1 (Proxy :: Proxy NotSym0) sNot))
+          (applySing
+             (applySing
+                (singFun2 (Proxy :: Proxy (:$)) SCons)
+                (singFun1 (Proxy :: Proxy IdSym0) sId))
+             SNil)
+    sX_0123456789
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2)
+             (singFun1 (Proxy :: Proxy FSym0) sF))
+          (singFun1 (Proxy :: Proxy GSym0) sG)
+    sX_0123456789
+      = applySing
+          (applySing (singFun2 (Proxy :: Proxy BarSym0) SBar) STrue)
+          (applySing (singFun1 (Proxy :: Proxy HSym0) sH) SFalse)
+    sX_0123456789
+      = applySing
+          (applySing
+             (singFun2 (Proxy :: Proxy (:$)) SCons)
+             (applySing (singFun1 (Proxy :: Proxy NotSym0) sNot) STrue))
+          (applySing
+             (applySing
+                (singFun2 (Proxy :: Proxy (:$)) SCons)
+                (applySing (singFun1 (Proxy :: Proxy IdSym0) sId) SFalse))
+             SNil)
diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc78.template b/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc78.template
+++ /dev/null
@@ -1,121 +0,0 @@
-Singletons/TopLevelPatterns.hs:0:0: Splicing declarations
-    singletons
-      [d| data Bool = False | True
-          data Foo = Bar Bool Bool |]
-  ======>
-    Singletons/TopLevelPatterns.hs:(0,0)-(0,0)
-    data Bool = False | True
-    data Foo = Bar Bool Bool
-    type FalseSym0 = False
-    type TrueSym0 = True
-    type BarSym2 (t :: Bool) (t :: Bool) = Bar t t
-    instance SuppressUnusedWarnings BarSym1 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.())
-    data BarSym1 (l :: Bool) (l :: TyFun Bool Foo)
-      = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) =>
-        BarSym1KindInference
-    type instance Apply (BarSym1 l) l = BarSym2 l l
-    instance SuppressUnusedWarnings BarSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
-    data BarSym0 (l :: TyFun Bool (TyFun Bool Foo -> *))
-      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
-        BarSym0KindInference
-    type instance Apply BarSym0 l = BarSym1 l
-    data instance Sing (z :: Bool)
-      = z ~ False => SFalse | z ~ True => STrue
-    type SBool (z :: Bool) = Sing z
-    instance SingKind (KProxy :: KProxy Bool) where
-      type DemoteRep (KProxy :: KProxy Bool) = Bool
-      fromSing SFalse = False
-      fromSing STrue = True
-      toSing False = SomeSing SFalse
-      toSing True = SomeSing STrue
-    data instance Sing (z :: Foo)
-      = forall (n :: Bool) (n :: Bool). z ~ Bar n n =>
-        SBar (Sing n) (Sing n)
-    type SFoo (z :: Foo) = Sing z
-    instance SingKind (KProxy :: KProxy Foo) where
-      type DemoteRep (KProxy :: KProxy Foo) = Foo
-      fromSing (SBar b b) = Bar (fromSing b) (fromSing b)
-      toSing (Bar b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy Bool))
-                (toSing b :: SomeSing (KProxy :: KProxy Bool))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SBar c c) }
-    instance SingI False where
-      sing = SFalse
-    instance SingI True where
-      sing = STrue
-    instance (SingI n, SingI n) =>
-             SingI (Bar (n :: Bool) (n :: Bool)) where
-      sing = SBar sing sing
-Singletons/TopLevelPatterns.hs:0:0: Splicing declarations
-    singletons
-      [d| otherwise :: Bool
-          otherwise = True
-          id :: a -> a
-          id x = x
-          not :: Bool -> Bool
-          not True = False
-          not False = True
-          false_ = False |]
-  ======>
-    Singletons/TopLevelPatterns.hs:(0,0)-(0,0)
-    otherwise :: Bool
-    otherwise = True
-    id :: forall a. a -> a
-    id x = x
-    not :: Bool -> Bool
-    not True = False
-    not False = True
-    false_ = False
-    type False_Sym0 = False_
-    type NotSym1 (t :: Bool) = Not t
-    instance SuppressUnusedWarnings NotSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) NotSym0KindInference GHC.Tuple.())
-    data NotSym0 (l :: TyFun Bool Bool)
-      = forall arg. KindOf (Apply NotSym0 arg) ~ KindOf (NotSym1 arg) =>
-        NotSym0KindInference
-    type instance Apply NotSym0 l = NotSym1 l
-    type IdSym1 (t :: a) = Id t
-    instance SuppressUnusedWarnings IdSym0 where
-      suppressUnusedWarnings _
-        = Data.Tuple.snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.())
-    data IdSym0 (l :: TyFun a a)
-      = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) =>
-        IdSym0KindInference
-    type instance Apply IdSym0 l = IdSym1 l
-    type OtherwiseSym0 = Otherwise
-    type False_ = FalseSym0
-    type family Not (a :: Bool) :: Bool where
-      Not True = FalseSym0
-      Not False = TrueSym0
-    type family Id (a :: a) :: a where
-      Id x = x
-    type Otherwise = (TrueSym0 :: Bool)
-    sFalse_ :: Sing False_Sym0
-    sNot :: forall (t :: Bool). Sing t -> Sing (Apply NotSym0 t)
-    sId :: forall (t :: a). Sing t -> Sing (Apply IdSym0 t)
-    sOtherwise :: Sing OtherwiseSym0
-    sFalse_ = SFalse
-    sNot STrue
-      = let
-          lambda :: t ~ TrueSym0 => Sing (Apply NotSym0 TrueSym0)
-          lambda = SFalse
-        in lambda
-    sNot SFalse
-      = let
-          lambda :: t ~ FalseSym0 => Sing (Apply NotSym0 FalseSym0)
-          lambda = STrue
-        in lambda
-    sId sX
-      = let
-          lambda :: forall x. t ~ x => Sing x -> Sing (Apply IdSym0 x)
-          lambda x = x
-        in lambda sX
-    sOtherwise = STrue
diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.hs b/tests/compile-and-dump/Singletons/TopLevelPatterns.hs
--- a/tests/compile-and-dump/Singletons/TopLevelPatterns.hs
+++ b/tests/compile-and-dump/Singletons/TopLevelPatterns.hs
@@ -26,7 +26,6 @@
 
   false_ = False
 
-{- Commented out until #54 is fixed
   f,g :: Bool -> Bool
   [f,g] = [not, id]
 
@@ -38,5 +37,4 @@
 
   l,m :: Bool
   [l,m] = [not True, id False]
--}
  |])
diff --git a/tests/compile-and-dump/Singletons/Tuples.ghc78.template b/tests/compile-and-dump/Singletons/Tuples.ghc78.template
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Tuples.ghc78.template
+++ /dev/null
@@ -1,606 +0,0 @@
-Singletons/Tuples.hs:0:0: Splicing declarations
-    genSingletons
-      [''(), ''(,), ''(,,), ''(,,,), ''(,,,,), ''(,,,,,), ''(,,,,,,)]
-  ======>
-    Singletons/Tuples.hs:(0,0)-(0,0)
-    type Tuple0Sym0 = '()
-    data instance Sing (z :: ()) = z ~ '() => STuple0
-    type STuple0 (z :: ()) = Sing z
-    instance SingKind (KProxy :: KProxy ()) where
-      type DemoteRep (KProxy :: KProxy ()) = ()
-      fromSing STuple0 = GHC.Tuple.()
-      toSing GHC.Tuple.() = SomeSing STuple0
-    instance SingI '() where
-      sing = STuple0
-    type Tuple2Sym2 (t :: a) (t :: b) = '(t, t)
-    instance SuppressUnusedWarnings Tuple2Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple2Sym1KindInference GHC.Tuple.())
-    data Tuple2Sym1 (l :: a) (l :: TyFun b (a, b))
-      = forall arg. KindOf (Apply (Tuple2Sym1 l) arg) ~ KindOf (Tuple2Sym2 l arg) =>
-        Tuple2Sym1KindInference
-    type instance Apply (Tuple2Sym1 l) l = Tuple2Sym2 l l
-    instance SuppressUnusedWarnings Tuple2Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple2Sym0KindInference GHC.Tuple.())
-    data Tuple2Sym0 (l :: TyFun a (TyFun b (a, b) -> *))
-      = forall arg. KindOf (Apply Tuple2Sym0 arg) ~ KindOf (Tuple2Sym1 arg) =>
-        Tuple2Sym0KindInference
-    type instance Apply Tuple2Sym0 l = Tuple2Sym1 l
-    data instance Sing (z :: (a, b))
-      = forall (n :: a) (n :: b). z ~ '(n, n) =>
-        STuple2 (Sing n) (Sing n)
-    type STuple2 (z :: (a, b)) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b)) =>
-             SingKind (KProxy :: KProxy (a, b)) where
-      type DemoteRep (KProxy :: KProxy (a,
-                                        b)) = (DemoteRep (KProxy :: KProxy a),
-                                               DemoteRep (KProxy :: KProxy b))
-      fromSing (STuple2 b b) = GHC.Tuple.(,) (fromSing b) (fromSing b)
-      toSing (GHC.Tuple.(,) b b)
-        = case
-              GHC.Tuple.(,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-          of {
-            GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (STuple2 c c) }
-    instance (SingI n, SingI n) => SingI '((n :: a), (n :: b)) where
-      sing = STuple2 sing sing
-    type Tuple3Sym3 (t :: a) (t :: b) (t :: c) = '(t, t, t)
-    instance SuppressUnusedWarnings Tuple3Sym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple3Sym2KindInference GHC.Tuple.())
-    data Tuple3Sym2 (l :: a) (l :: b) (l :: TyFun c (a, b, c))
-      = forall arg. KindOf (Apply (Tuple3Sym2 l l) arg) ~ KindOf (Tuple3Sym3 l l arg) =>
-        Tuple3Sym2KindInference
-    type instance Apply (Tuple3Sym2 l l) l = Tuple3Sym3 l l l
-    instance SuppressUnusedWarnings Tuple3Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple3Sym1KindInference GHC.Tuple.())
-    data Tuple3Sym1 (l :: a) (l :: TyFun b (TyFun c (a, b, c) -> *))
-      = forall arg. KindOf (Apply (Tuple3Sym1 l) arg) ~ KindOf (Tuple3Sym2 l arg) =>
-        Tuple3Sym1KindInference
-    type instance Apply (Tuple3Sym1 l) l = Tuple3Sym2 l l
-    instance SuppressUnusedWarnings Tuple3Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple3Sym0KindInference GHC.Tuple.())
-    data Tuple3Sym0 (l :: TyFun a (TyFun b (TyFun c (a, b, c) -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply Tuple3Sym0 arg) ~ KindOf (Tuple3Sym1 arg) =>
-        Tuple3Sym0KindInference
-    type instance Apply Tuple3Sym0 l = Tuple3Sym1 l
-    data instance Sing (z :: (a, b, c))
-      = forall (n :: a) (n :: b) (n :: c). z ~ '(n, n, n) =>
-        STuple3 (Sing n) (Sing n) (Sing n)
-    type STuple3 (z :: (a, b, c)) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b),
-              SingKind (KProxy :: KProxy c)) =>
-             SingKind (KProxy :: KProxy (a, b, c)) where
-      type DemoteRep (KProxy :: KProxy (a,
-                                        b,
-                                        c)) = (DemoteRep (KProxy :: KProxy a),
-                                               DemoteRep (KProxy :: KProxy b),
-                                               DemoteRep (KProxy :: KProxy c))
-      fromSing (STuple3 b b b)
-        = GHC.Tuple.(,,) (fromSing b) (fromSing b) (fromSing b)
-      toSing (GHC.Tuple.(,,) b b b)
-        = case
-              GHC.Tuple.(,,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-                (toSing b :: SomeSing (KProxy :: KProxy c))
-          of {
-            GHC.Tuple.(,,) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing (STuple3 c c c) }
-    instance (SingI n, SingI n, SingI n) =>
-             SingI '((n :: a), (n :: b), (n :: c)) where
-      sing = STuple3 sing sing sing
-    type Tuple4Sym4 (t :: a) (t :: b) (t :: c) (t :: d) = '(t, t, t, t)
-    instance SuppressUnusedWarnings Tuple4Sym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple4Sym3KindInference GHC.Tuple.())
-    data Tuple4Sym3 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: TyFun d (a, b, c, d))
-      = forall arg. KindOf (Apply (Tuple4Sym3 l l l) arg) ~ KindOf (Tuple4Sym4 l l l arg) =>
-        Tuple4Sym3KindInference
-    type instance Apply (Tuple4Sym3 l l l) l = Tuple4Sym4 l l l l
-    instance SuppressUnusedWarnings Tuple4Sym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple4Sym2KindInference GHC.Tuple.())
-    data Tuple4Sym2 (l :: a)
-                    (l :: b)
-                    (l :: TyFun c (TyFun d (a, b, c, d) -> *))
-      = forall arg. KindOf (Apply (Tuple4Sym2 l l) arg) ~ KindOf (Tuple4Sym3 l l arg) =>
-        Tuple4Sym2KindInference
-    type instance Apply (Tuple4Sym2 l l) l = Tuple4Sym3 l l l
-    instance SuppressUnusedWarnings Tuple4Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple4Sym1KindInference GHC.Tuple.())
-    data Tuple4Sym1 (l :: a)
-                    (l :: TyFun b (TyFun c (TyFun d (a, b, c, d) -> *) -> *))
-      = forall arg. KindOf (Apply (Tuple4Sym1 l) arg) ~ KindOf (Tuple4Sym2 l arg) =>
-        Tuple4Sym1KindInference
-    type instance Apply (Tuple4Sym1 l) l = Tuple4Sym2 l l
-    instance SuppressUnusedWarnings Tuple4Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple4Sym0KindInference GHC.Tuple.())
-    data Tuple4Sym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (a,
-                                                              b,
-                                                              c,
-                                                              d)
-                                                     -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply Tuple4Sym0 arg) ~ KindOf (Tuple4Sym1 arg) =>
-        Tuple4Sym0KindInference
-    type instance Apply Tuple4Sym0 l = Tuple4Sym1 l
-    data instance Sing (z :: (a, b, c, d))
-      = forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ '(n, n, n, n) =>
-        STuple4 (Sing n) (Sing n) (Sing n) (Sing n)
-    type STuple4 (z :: (a, b, c, d)) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b),
-              SingKind (KProxy :: KProxy c),
-              SingKind (KProxy :: KProxy d)) =>
-             SingKind (KProxy :: KProxy (a, b, c, d)) where
-      type DemoteRep (KProxy :: KProxy (a,
-                                        b,
-                                        c,
-                                        d)) = (DemoteRep (KProxy :: KProxy a),
-                                               DemoteRep (KProxy :: KProxy b),
-                                               DemoteRep (KProxy :: KProxy c),
-                                               DemoteRep (KProxy :: KProxy d))
-      fromSing (STuple4 b b b b)
-        = GHC.Tuple.(,,,)
-            (fromSing b) (fromSing b) (fromSing b) (fromSing b)
-      toSing (GHC.Tuple.(,,,) b b b b)
-        = case
-              GHC.Tuple.(,,,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-                (toSing b :: SomeSing (KProxy :: KProxy c))
-                (toSing b :: SomeSing (KProxy :: KProxy d))
-          of {
-            GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)
-              -> SomeSing (STuple4 c c c c) }
-    instance (SingI n, SingI n, SingI n, SingI n) =>
-             SingI '((n :: a), (n :: b), (n :: c), (n :: d)) where
-      sing = STuple4 sing sing sing sing
-    type Tuple5Sym5 (t :: a) (t :: b) (t :: c) (t :: d) (t :: e) =
-        '(t, t, t, t, t)
-    instance SuppressUnusedWarnings Tuple5Sym4 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple5Sym4KindInference GHC.Tuple.())
-    data Tuple5Sym4 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: d)
-                    (l :: TyFun e (a, b, c, d, e))
-      = forall arg. KindOf (Apply (Tuple5Sym4 l l l l) arg) ~ KindOf (Tuple5Sym5 l l l l arg) =>
-        Tuple5Sym4KindInference
-    type instance Apply (Tuple5Sym4 l l l l) l = Tuple5Sym5 l l l l l
-    instance SuppressUnusedWarnings Tuple5Sym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple5Sym3KindInference GHC.Tuple.())
-    data Tuple5Sym3 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: TyFun d (TyFun e (a, b, c, d, e) -> *))
-      = forall arg. KindOf (Apply (Tuple5Sym3 l l l) arg) ~ KindOf (Tuple5Sym4 l l l arg) =>
-        Tuple5Sym3KindInference
-    type instance Apply (Tuple5Sym3 l l l) l = Tuple5Sym4 l l l l
-    instance SuppressUnusedWarnings Tuple5Sym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple5Sym2KindInference GHC.Tuple.())
-    data Tuple5Sym2 (l :: a)
-                    (l :: b)
-                    (l :: TyFun c (TyFun d (TyFun e (a, b, c, d, e) -> *) -> *))
-      = forall arg. KindOf (Apply (Tuple5Sym2 l l) arg) ~ KindOf (Tuple5Sym3 l l arg) =>
-        Tuple5Sym2KindInference
-    type instance Apply (Tuple5Sym2 l l) l = Tuple5Sym3 l l l
-    instance SuppressUnusedWarnings Tuple5Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple5Sym1KindInference GHC.Tuple.())
-    data Tuple5Sym1 (l :: a)
-                    (l :: TyFun b (TyFun c (TyFun d (TyFun e (a, b, c, d, e) -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply (Tuple5Sym1 l) arg) ~ KindOf (Tuple5Sym2 l arg) =>
-        Tuple5Sym1KindInference
-    type instance Apply (Tuple5Sym1 l) l = Tuple5Sym2 l l
-    instance SuppressUnusedWarnings Tuple5Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple5Sym0KindInference GHC.Tuple.())
-    data Tuple5Sym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (TyFun e (a,
-                                                                       b,
-                                                                       c,
-                                                                       d,
-                                                                       e)
-                                                              -> *)
-                                                     -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply Tuple5Sym0 arg) ~ KindOf (Tuple5Sym1 arg) =>
-        Tuple5Sym0KindInference
-    type instance Apply Tuple5Sym0 l = Tuple5Sym1 l
-    data instance Sing (z :: (a, b, c, d, e))
-      = forall (n :: a) (n :: b) (n :: c) (n :: d) (n :: e). z ~ '(n,
-                                                                   n,
-                                                                   n,
-                                                                   n,
-                                                                   n) =>
-        STuple5 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
-    type STuple5 (z :: (a, b, c, d, e)) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b),
-              SingKind (KProxy :: KProxy c),
-              SingKind (KProxy :: KProxy d),
-              SingKind (KProxy :: KProxy e)) =>
-             SingKind (KProxy :: KProxy (a, b, c, d, e)) where
-      type DemoteRep (KProxy :: KProxy (a,
-                                        b,
-                                        c,
-                                        d,
-                                        e)) = (DemoteRep (KProxy :: KProxy a),
-                                               DemoteRep (KProxy :: KProxy b),
-                                               DemoteRep (KProxy :: KProxy c),
-                                               DemoteRep (KProxy :: KProxy d),
-                                               DemoteRep (KProxy :: KProxy e))
-      fromSing (STuple5 b b b b b)
-        = GHC.Tuple.(,,,,)
-            (fromSing b) (fromSing b) (fromSing b) (fromSing b) (fromSing b)
-      toSing (GHC.Tuple.(,,,,) b b b b b)
-        = case
-              GHC.Tuple.(,,,,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-                (toSing b :: SomeSing (KProxy :: KProxy c))
-                (toSing b :: SomeSing (KProxy :: KProxy d))
-                (toSing b :: SomeSing (KProxy :: KProxy e))
-          of {
-            GHC.Tuple.(,,,,) (SomeSing c)
-                             (SomeSing c)
-                             (SomeSing c)
-                             (SomeSing c)
-                             (SomeSing c)
-              -> SomeSing (STuple5 c c c c c) }
-    instance (SingI n, SingI n, SingI n, SingI n, SingI n) =>
-             SingI '((n :: a), (n :: b), (n :: c), (n :: d), (n :: e)) where
-      sing = STuple5 sing sing sing sing sing
-    type Tuple6Sym6 (t :: a)
-                    (t :: b)
-                    (t :: c)
-                    (t :: d)
-                    (t :: e)
-                    (t :: f) =
-        '(t, t, t, t, t, t)
-    instance SuppressUnusedWarnings Tuple6Sym5 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple6Sym5KindInference GHC.Tuple.())
-    data Tuple6Sym5 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: d)
-                    (l :: e)
-                    (l :: TyFun f (a, b, c, d, e, f))
-      = forall arg. KindOf (Apply (Tuple6Sym5 l l l l l) arg) ~ KindOf (Tuple6Sym6 l l l l l arg) =>
-        Tuple6Sym5KindInference
-    type instance Apply (Tuple6Sym5 l l l l l) l = Tuple6Sym6 l l l l l l
-    instance SuppressUnusedWarnings Tuple6Sym4 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple6Sym4KindInference GHC.Tuple.())
-    data Tuple6Sym4 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: d)
-                    (l :: TyFun e (TyFun f (a, b, c, d, e, f) -> *))
-      = forall arg. KindOf (Apply (Tuple6Sym4 l l l l) arg) ~ KindOf (Tuple6Sym5 l l l l arg) =>
-        Tuple6Sym4KindInference
-    type instance Apply (Tuple6Sym4 l l l l) l = Tuple6Sym5 l l l l l
-    instance SuppressUnusedWarnings Tuple6Sym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple6Sym3KindInference GHC.Tuple.())
-    data Tuple6Sym3 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: TyFun d (TyFun e (TyFun f (a, b, c, d, e, f) -> *) -> *))
-      = forall arg. KindOf (Apply (Tuple6Sym3 l l l) arg) ~ KindOf (Tuple6Sym4 l l l arg) =>
-        Tuple6Sym3KindInference
-    type instance Apply (Tuple6Sym3 l l l) l = Tuple6Sym4 l l l l
-    instance SuppressUnusedWarnings Tuple6Sym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple6Sym2KindInference GHC.Tuple.())
-    data Tuple6Sym2 (l :: a)
-                    (l :: b)
-                    (l :: TyFun c (TyFun d (TyFun e (TyFun f (a, b, c, d, e, f) -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply (Tuple6Sym2 l l) arg) ~ KindOf (Tuple6Sym3 l l arg) =>
-        Tuple6Sym2KindInference
-    type instance Apply (Tuple6Sym2 l l) l = Tuple6Sym3 l l l
-    instance SuppressUnusedWarnings Tuple6Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple6Sym1KindInference GHC.Tuple.())
-    data Tuple6Sym1 (l :: a)
-                    (l :: TyFun b (TyFun c (TyFun d (TyFun e (TyFun f (a,
-                                                                       b,
-                                                                       c,
-                                                                       d,
-                                                                       e,
-                                                                       f)
-                                                              -> *)
-                                                     -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply (Tuple6Sym1 l) arg) ~ KindOf (Tuple6Sym2 l arg) =>
-        Tuple6Sym1KindInference
-    type instance Apply (Tuple6Sym1 l) l = Tuple6Sym2 l l
-    instance SuppressUnusedWarnings Tuple6Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple6Sym0KindInference GHC.Tuple.())
-    data Tuple6Sym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (TyFun e (TyFun f (a,
-                                                                                b,
-                                                                                c,
-                                                                                d,
-                                                                                e,
-                                                                                f)
-                                                                       -> *)
-                                                              -> *)
-                                                     -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply Tuple6Sym0 arg) ~ KindOf (Tuple6Sym1 arg) =>
-        Tuple6Sym0KindInference
-    type instance Apply Tuple6Sym0 l = Tuple6Sym1 l
-    data instance Sing (z :: (a, b, c, d, e, f))
-      = forall (n :: a)
-               (n :: b)
-               (n :: c)
-               (n :: d)
-               (n :: e)
-               (n :: f). z ~ '(n, n, n, n, n, n) =>
-        STuple6 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
-    type STuple6 (z :: (a, b, c, d, e, f)) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b),
-              SingKind (KProxy :: KProxy c),
-              SingKind (KProxy :: KProxy d),
-              SingKind (KProxy :: KProxy e),
-              SingKind (KProxy :: KProxy f)) =>
-             SingKind (KProxy :: KProxy (a, b, c, d, e, f)) where
-      type DemoteRep (KProxy :: KProxy (a,
-                                        b,
-                                        c,
-                                        d,
-                                        e,
-                                        f)) = (DemoteRep (KProxy :: KProxy a),
-                                               DemoteRep (KProxy :: KProxy b),
-                                               DemoteRep (KProxy :: KProxy c),
-                                               DemoteRep (KProxy :: KProxy d),
-                                               DemoteRep (KProxy :: KProxy e),
-                                               DemoteRep (KProxy :: KProxy f))
-      fromSing (STuple6 b b b b b b)
-        = GHC.Tuple.(,,,,,)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-      toSing (GHC.Tuple.(,,,,,) b b b b b b)
-        = case
-              GHC.Tuple.(,,,,,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-                (toSing b :: SomeSing (KProxy :: KProxy c))
-                (toSing b :: SomeSing (KProxy :: KProxy d))
-                (toSing b :: SomeSing (KProxy :: KProxy e))
-                (toSing b :: SomeSing (KProxy :: KProxy f))
-          of {
-            GHC.Tuple.(,,,,,) (SomeSing c)
-                              (SomeSing c)
-                              (SomeSing c)
-                              (SomeSing c)
-                              (SomeSing c)
-                              (SomeSing c)
-              -> SomeSing (STuple6 c c c c c c) }
-    instance (SingI n, SingI n, SingI n, SingI n, SingI n, SingI n) =>
-             SingI '((n :: a),
-                     (n :: b),
-                     (n :: c),
-                     (n :: d),
-                     (n :: e),
-                     (n :: f)) where
-      sing = STuple6 sing sing sing sing sing sing
-    type Tuple7Sym7 (t :: a)
-                    (t :: b)
-                    (t :: c)
-                    (t :: d)
-                    (t :: e)
-                    (t :: f)
-                    (t :: g) =
-        '(t, t, t, t, t, t, t)
-    instance SuppressUnusedWarnings Tuple7Sym6 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple7Sym6KindInference GHC.Tuple.())
-    data Tuple7Sym6 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: d)
-                    (l :: e)
-                    (l :: f)
-                    (l :: TyFun g (a, b, c, d, e, f, g))
-      = forall arg. KindOf (Apply (Tuple7Sym6 l l l l l l) arg) ~ KindOf (Tuple7Sym7 l l l l l l arg) =>
-        Tuple7Sym6KindInference
-    type instance Apply (Tuple7Sym6 l l l l l l) l = Tuple7Sym7 l l l l l l l
-    instance SuppressUnusedWarnings Tuple7Sym5 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple7Sym5KindInference GHC.Tuple.())
-    data Tuple7Sym5 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: d)
-                    (l :: e)
-                    (l :: TyFun f (TyFun g (a, b, c, d, e, f, g) -> *))
-      = forall arg. KindOf (Apply (Tuple7Sym5 l l l l l) arg) ~ KindOf (Tuple7Sym6 l l l l l arg) =>
-        Tuple7Sym5KindInference
-    type instance Apply (Tuple7Sym5 l l l l l) l = Tuple7Sym6 l l l l l l
-    instance SuppressUnusedWarnings Tuple7Sym4 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple7Sym4KindInference GHC.Tuple.())
-    data Tuple7Sym4 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: d)
-                    (l :: TyFun e (TyFun f (TyFun g (a, b, c, d, e, f, g) -> *) -> *))
-      = forall arg. KindOf (Apply (Tuple7Sym4 l l l l) arg) ~ KindOf (Tuple7Sym5 l l l l arg) =>
-        Tuple7Sym4KindInference
-    type instance Apply (Tuple7Sym4 l l l l) l = Tuple7Sym5 l l l l l
-    instance SuppressUnusedWarnings Tuple7Sym3 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple7Sym3KindInference GHC.Tuple.())
-    data Tuple7Sym3 (l :: a)
-                    (l :: b)
-                    (l :: c)
-                    (l :: TyFun d (TyFun e (TyFun f (TyFun g (a, b, c, d, e, f, g)
-                                                     -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply (Tuple7Sym3 l l l) arg) ~ KindOf (Tuple7Sym4 l l l arg) =>
-        Tuple7Sym3KindInference
-    type instance Apply (Tuple7Sym3 l l l) l = Tuple7Sym4 l l l l
-    instance SuppressUnusedWarnings Tuple7Sym2 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple7Sym2KindInference GHC.Tuple.())
-    data Tuple7Sym2 (l :: a)
-                    (l :: b)
-                    (l :: TyFun c (TyFun d (TyFun e (TyFun f (TyFun g (a,
-                                                                       b,
-                                                                       c,
-                                                                       d,
-                                                                       e,
-                                                                       f,
-                                                                       g)
-                                                              -> *)
-                                                     -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply (Tuple7Sym2 l l) arg) ~ KindOf (Tuple7Sym3 l l arg) =>
-        Tuple7Sym2KindInference
-    type instance Apply (Tuple7Sym2 l l) l = Tuple7Sym3 l l l
-    instance SuppressUnusedWarnings Tuple7Sym1 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple7Sym1KindInference GHC.Tuple.())
-    data Tuple7Sym1 (l :: a)
-                    (l :: TyFun b (TyFun c (TyFun d (TyFun e (TyFun f (TyFun g (a,
-                                                                                b,
-                                                                                c,
-                                                                                d,
-                                                                                e,
-                                                                                f,
-                                                                                g)
-                                                                       -> *)
-                                                              -> *)
-                                                     -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply (Tuple7Sym1 l) arg) ~ KindOf (Tuple7Sym2 l arg) =>
-        Tuple7Sym1KindInference
-    type instance Apply (Tuple7Sym1 l) l = Tuple7Sym2 l l
-    instance SuppressUnusedWarnings Tuple7Sym0 where
-      suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Tuple7Sym0KindInference GHC.Tuple.())
-    data Tuple7Sym0 (l :: TyFun a (TyFun b (TyFun c (TyFun d (TyFun e (TyFun f (TyFun g (a,
-                                                                                         b,
-                                                                                         c,
-                                                                                         d,
-                                                                                         e,
-                                                                                         f,
-                                                                                         g)
-                                                                                -> *)
-                                                                       -> *)
-                                                              -> *)
-                                                     -> *)
-                                            -> *)
-                                   -> *))
-      = forall arg. KindOf (Apply Tuple7Sym0 arg) ~ KindOf (Tuple7Sym1 arg) =>
-        Tuple7Sym0KindInference
-    type instance Apply Tuple7Sym0 l = Tuple7Sym1 l
-    data instance Sing (z :: (a, b, c, d, e, f, g))
-      = forall (n :: a)
-               (n :: b)
-               (n :: c)
-               (n :: d)
-               (n :: e)
-               (n :: f)
-               (n :: g). z ~ '(n, n, n, n, n, n, n) =>
-        STuple7 (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n) (Sing n)
-    type STuple7 (z :: (a, b, c, d, e, f, g)) = Sing z
-    instance (SingKind (KProxy :: KProxy a),
-              SingKind (KProxy :: KProxy b),
-              SingKind (KProxy :: KProxy c),
-              SingKind (KProxy :: KProxy d),
-              SingKind (KProxy :: KProxy e),
-              SingKind (KProxy :: KProxy f),
-              SingKind (KProxy :: KProxy g)) =>
-             SingKind (KProxy :: KProxy (a, b, c, d, e, f, g)) where
-      type DemoteRep (KProxy :: KProxy (a,
-                                        b,
-                                        c,
-                                        d,
-                                        e,
-                                        f,
-                                        g)) = (DemoteRep (KProxy :: KProxy a),
-                                               DemoteRep (KProxy :: KProxy b),
-                                               DemoteRep (KProxy :: KProxy c),
-                                               DemoteRep (KProxy :: KProxy d),
-                                               DemoteRep (KProxy :: KProxy e),
-                                               DemoteRep (KProxy :: KProxy f),
-                                               DemoteRep (KProxy :: KProxy g))
-      fromSing (STuple7 b b b b b b b)
-        = GHC.Tuple.(,,,,,,)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-            (fromSing b)
-      toSing (GHC.Tuple.(,,,,,,) b b b b b b b)
-        = case
-              GHC.Tuple.(,,,,,,)
-                (toSing b :: SomeSing (KProxy :: KProxy a))
-                (toSing b :: SomeSing (KProxy :: KProxy b))
-                (toSing b :: SomeSing (KProxy :: KProxy c))
-                (toSing b :: SomeSing (KProxy :: KProxy d))
-                (toSing b :: SomeSing (KProxy :: KProxy e))
-                (toSing b :: SomeSing (KProxy :: KProxy f))
-                (toSing b :: SomeSing (KProxy :: KProxy g))
-          of {
-            GHC.Tuple.(,,,,,,) (SomeSing c)
-                               (SomeSing c)
-                               (SomeSing c)
-                               (SomeSing c)
-                               (SomeSing c)
-                               (SomeSing c)
-                               (SomeSing c)
-              -> SomeSing (STuple7 c c c c c c c) }
-    instance (SingI n,
-              SingI n,
-              SingI n,
-              SingI n,
-              SingI n,
-              SingI n,
-              SingI n) =>
-             SingI '((n :: a),
-                     (n :: b),
-                     (n :: c),
-                     (n :: d),
-                     (n :: e),
-                     (n :: f),
-                     (n :: g)) where
-      sing = STuple7 sing sing sing sing sing sing sing
diff --git a/tests/compile-and-dump/Singletons/Tuples.hs b/tests/compile-and-dump/Singletons/Tuples.hs
deleted file mode 100644
--- a/tests/compile-and-dump/Singletons/Tuples.hs
+++ /dev/null
@@ -1,15 +0,0 @@
-module Singletons.Tuples where
-
-import Data.Singletons
-import Data.Singletons.Single
-import Data.Singletons.SuppressUnusedWarnings
-import Data.Singletons.Types
-
-$(genSingletons [ ''()
-                , ''(,)
-                , ''(,,)
-                , ''(,,,)
-                , ''(,,,,)
-                , ''(,,,,,)
-                , ''(,,,,,,)
-                ])
diff --git a/tests/compile-and-dump/Singletons/Undef.ghc710.template b/tests/compile-and-dump/Singletons/Undef.ghc710.template
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Undef.ghc710.template
@@ -0,0 +1,49 @@
+Singletons/Undef.hs:(0,0)-(0,0): Splicing declarations
+    singletons
+      [d| foo :: Bool -> Bool
+          foo = undefined
+          bar :: Bool -> Bool
+          bar = error "urk" |]
+  ======>
+    foo :: Bool -> Bool
+    foo = undefined
+    bar :: Bool -> Bool
+    bar = error "urk"
+    type BarSym1 (t :: Bool) = Bar t
+    instance SuppressUnusedWarnings BarSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
+    data BarSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
+        BarSym0KindInference
+    type instance Apply BarSym0 l = BarSym1 l
+    type FooSym1 (t :: Bool) = Foo t
+    instance SuppressUnusedWarnings FooSym0 where
+      suppressUnusedWarnings _
+        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
+    data FooSym0 (l :: TyFun Bool Bool)
+      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
+        FooSym0KindInference
+    type instance Apply FooSym0 l = FooSym1 l
+    type family Bar (a :: Bool) :: Bool where
+      Bar a_0123456789 = Apply (Apply ErrorSym0 "urk") a_0123456789
+    type family Foo (a :: Bool) :: Bool where
+      Foo a_0123456789 = Apply Any a_0123456789
+    sBar ::
+      forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool)
+    sFoo ::
+      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)
+    sBar sA_0123456789
+      = let
+          lambda ::
+            forall a_0123456789. t ~ a_0123456789 =>
+            Sing a_0123456789 -> Sing (Apply BarSym0 a_0123456789 :: Bool)
+          lambda a_0123456789 = sError (sing :: Sing "urk")
+        in lambda sA_0123456789
+    sFoo sA_0123456789
+      = let
+          lambda ::
+            forall a_0123456789. t ~ a_0123456789 =>
+            Sing a_0123456789 -> Sing (Apply FooSym0 a_0123456789 :: Bool)
+          lambda a_0123456789 = undefined
+        in lambda sA_0123456789
diff --git a/tests/compile-and-dump/Singletons/Undef.hs b/tests/compile-and-dump/Singletons/Undef.hs
new file mode 100644
--- /dev/null
+++ b/tests/compile-and-dump/Singletons/Undef.hs
@@ -0,0 +1,12 @@
+module Singletons.Undef where
+
+import Data.Singletons.TH
+import Data.Singletons.Prelude
+
+$(singletons [d|
+  foo :: Bool -> Bool
+  foo = undefined
+
+  bar :: Bool -> Bool
+  bar = error "urk"
+  |])