diff --git a/CHANGES.md b/CHANGES.md
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,12 @@
 Changelog for singletons project
 ================================
 
+1.1.2.1
+-------
+
+Fix bug #116, thus allowing locally-declared symbols to be used in GHC 7.10.
+
+
 1.1.2
 -----
 
diff --git a/singletons.cabal b/singletons.cabal
--- a/singletons.cabal
+++ b/singletons.cabal
@@ -1,5 +1,5 @@
 name:           singletons
-version:        1.1.2
+version:        1.1.2.1
                 -- Remember to bump version in the Makefile as well
 cabal-version:  >= 1.10
 synopsis:       A framework for generating singleton types
@@ -38,7 +38,7 @@
 source-repository this
   type:     git
   location: https://github.com/goldfirere/singletons.git
-  tag:      v1.1.2
+  tag:      v1.1.2.1
 
 library
   hs-source-dirs:     src
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
@@ -3,7 +3,7 @@
 (c) Richard Eisenberg 2014
 eir@cis.upenn.edu
 
-Defining names and maniuplations on names for use in promotion and singling.
+Defining names and manipulations on names for use in promotion and singling.
 -}
 
 {-# LANGUAGE CPP, TemplateHaskell #-}
@@ -99,8 +99,8 @@
 promoteValNameLhs = upcase
 
 -- like promoteValNameLhs, but adds a prefix to the promoted name
-promoteValNameLhsPrefix :: String -> Name -> Name
-promoteValNameLhsPrefix prefix = mkName . (prefix ++) . toUpcaseStr
+promoteValNameLhsPrefix :: (String, String) -> Name -> Name
+promoteValNameLhsPrefix pres n = mkName $ toUpcaseStr pres n
 
 -- used when a value name appears in an expression context
 -- works for both variables and datacons
@@ -132,7 +132,7 @@
     = mkName $ "Tuple" ++ show degree ++ "Sym" ++ (show sat)
 
     | otherwise
-    = let capped = toUpcaseStr name in
+    = let capped = toUpcaseStr noPrefix name in
       if isHsLetter (head capped)
       then mkName (capped ++ "Sym" ++ (show sat))
       else mkName (capped ++ (replicate (sat + 1) '$'))
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
@@ -198,22 +198,19 @@
       concatMapM (getRecordSelectors arg_ty) cons
 
 -- curious about ALetDecEnv? See the LetDecEnv module for an explanation.
-promoteLetDecs :: String -- prefix to use on all new definitions
+promoteLetDecs :: (String, String) -- (alpha, symb) prefixes to use
                -> [DLetDec] -> PrM ([LetBind], ALetDecEnv)
-promoteLetDecs prefix decls = do
+promoteLetDecs prefixes decls = do
   let_dec_env <- buildLetDecEnv decls
   all_locals <- allLocals
   let binds = [ (name, foldType (DConT sym) (map DVarT all_locals))
               | name <- Map.keys $ lde_defns let_dec_env
-              , let proName = promoteValNameLhsPrefix prefix name
+              , let proName = promoteValNameLhsPrefix prefixes name
                     sym = promoteTySym proName (length all_locals) ]
-  (decs, let_dec_env') <- letBind binds $ promoteLetDecEnv prefix let_dec_env
+  (decs, let_dec_env') <- letBind binds $ promoteLetDecEnv prefixes let_dec_env
   emitDecs decs
   return (binds, let_dec_env' { lde_proms = Map.fromList binds })
 
-noPrefix :: String
-noPrefix = ""
-
 -- Promotion of data types to kinds is automatic (see "Ginving Haskell a
 -- Promotion" paper for more details). Here we "plug into" the promotion
 -- mechanism to add some extra stuff to the promotion:
@@ -417,17 +414,17 @@
     apply_ki = DSigT
 
 
-promoteLetDecEnv :: String -> ULetDecEnv -> PrM ([DDec], ALetDecEnv)
-promoteLetDecEnv prefix (LetDecEnv { lde_defns = value_env
-                                   , lde_types = type_env
-                                   , lde_infix = infix_decls }) = do
+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
   (payloads, defun_decss, ann_rhss)
-    <- fmap unzip3 $ zipWithM (promoteLetDecRHS type_env prefix) names rhss
+    <- fmap unzip3 $ zipWithM (promoteLetDecRHS type_env prefixes) names rhss
 
   emitDecs $ concat defun_decss
   let decs = map payload_to_dec payloads
@@ -454,7 +451,7 @@
 -- let bindings. Thus, it can't quite do all the work locally and returns
 -- an unwiedly intermediate structure. Perhaps a better design is available.
 promoteLetDecRHS :: Map Name DType       -- local type env't
-                 -> String               -- let-binding prefix
+                 -> (String, String)     -- let-binding prefixes
                  -> Name                 -- name of the thing being promoted
                  -> ULetDecRHS           -- body of the thing
                  -> PrM ( Either
@@ -463,7 +460,7 @@
                                                         -- "type family"
                         , [DDec]        -- defunctionalization
                         , ALetDecRHS )  -- annotated RHS
-promoteLetDecRHS type_env prefix name (UValue exp) = do
+promoteLetDecRHS type_env prefixes name (UValue exp) = do
   (res_kind, mk_rhs, num_arrows)
     <- case Map.lookup name type_env of
          Nothing -> return (Nothing, id, 0)
@@ -474,7 +471,7 @@
     0 -> do
       all_locals <- allLocals
       (exp', ann_exp) <- promoteExp exp
-      let proName = promoteValNameLhsPrefix prefix name
+      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')
              , defuns
@@ -484,10 +481,10 @@
       names <- replicateM num_arrows (newUniqueName "a")
       let pats    = map DVarPa names
           newArgs = map DVarE  names
-      promoteLetDecRHS type_env prefix name
+      promoteLetDecRHS type_env prefixes name
                        (UFunction [DClause pats (foldExp exp newArgs)])
 
-promoteLetDecRHS type_env prefix name (UFunction clauses) = do
+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
@@ -508,7 +505,7 @@
       -- invariant: countArgs ty == length argKs
       return (map Just argKs, Just resultK, length argKs)
 
-  let proName = promoteValNameLhsPrefix prefix name
+  let proName = promoteValNameLhsPrefix prefixes name
   all_locals <- allLocals
   defun_decs <- defunctionalize proName
                 (map (const Nothing) all_locals ++ m_argKs) m_resK
@@ -624,8 +621,9 @@
   return ( prom_case `DAppT` exp'
          , ADCaseE ann_exp ann_matches )
 promoteExp (DLetE decs exp) = do
-  letPrefix <- fmap nameBase $ newUniqueName "Let"
-  (binds, ann_env) <- promoteLetDecs letPrefix decs
+  unique <- qNewUnique
+  let letPrefixes = uniquePrefixes "Let" ":<<<" unique
+  (binds, ann_env) <- promoteLetDecs letPrefixes decs
   (exp', ann_exp) <- letBind binds $ promoteExp exp
   return (exp', ADLetE ann_env ann_exp)
 promoteExp (DSigE exp ty) = do
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
@@ -28,6 +28,7 @@
 
 #if __GLASGOW_HASKELL__ < 709
 import Control.Applicative
+import GHC.Exts ( Int(I#) )
 #endif
 
 -- The list of types that singletons processes by default
@@ -57,6 +58,18 @@
 qReportError :: DsMonad q => String -> q ()
 qReportError = qReport True
 
+-- | Generate a new Unique
+qNewUnique :: DsMonad q => q Int
+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 names =
   when (any ((== "Rep") . nameBase) names)
@@ -86,22 +99,34 @@
 
 -- make an identifier uppercase
 upcase :: Name -> Name
-upcase = mkName . toUpcaseStr
+upcase = mkName . toUpcaseStr noPrefix
 
 -- make an identifier uppercase and return it as a String
-toUpcaseStr :: Name -> String
-toUpcaseStr n
-  |  isUpcase n
-  || head (nameBase n) == '$'   -- special case to avoid name clashes. See #29
-  = nameBase n
+toUpcaseStr :: (String, String)  -- (alpha, symb) prefixes to prepend
+            -> Name -> String
+toUpcaseStr (alpha, symb) n
+  | isHsLetter first
+  = upcase_alpha
 
   | otherwise
-  = let str   = nameBase n
-        first = head str
-    in if isHsLetter first
-       then (toUpper first) : tail str
-       else ':' : str
+  = upcase_symb
 
+  where
+    str   = nameBase n
+    first = head str
+
+    upcase_alpha = alpha ++ (toUpper first) : tail str
+
+    upcase_symb
+      |  first == ':'
+      || first == '$' -- special case to avoid name clashes. See #29
+      = symb ++ str
+      | otherwise
+      = symb ++ ':' : str
+
+noPrefix :: (String, String)
+noPrefix = ("", "")
+
 -- make an identifier lowercase
 locase :: Name -> Name
 locase n =
@@ -135,6 +160,31 @@
   if isHsLetter first
   then mkName (str ++ ident)
   else mkName (str ++ symb)
+
+-- convert a number into both alphanumeric and symoblic forms
+uniquePrefixes :: String   -- alphanumeric prefix
+               -> String   -- symbolic prefix
+               -> Int
+               -> (String, String)  -- (alphanum, symbolic)
+uniquePrefixes alpha symb n = (alpha ++ n_str, symb ++ convert n_str)
+  where
+    n_str = show n
+
+    convert [] = []
+    convert (d : ds) =
+      let d' = case d of
+                 '0' -> '!'
+                 '1' -> '#'
+                 '2' -> '$'
+                 '3' -> '%'
+                 '4' -> '&'
+                 '5' -> '*'
+                 '6' -> '+'
+                 '7' -> '.'
+                 '8' -> '/'
+                 '9' -> '>'
+                 _   -> error "non-digit in show #"
+      in d' : convert ds
 
 -- extract the kind from a TyVarBndr. Returns '*' by default.
 extractTvbKind :: DTyVarBndr -> Maybe DKind
diff --git a/tests/SingletonsTestSuiteUtils.hs b/tests/SingletonsTestSuiteUtils.hs
--- a/tests/SingletonsTestSuiteUtils.hs
+++ b/tests/SingletonsTestSuiteUtils.hs
@@ -215,6 +215,7 @@
   , "-e", "'s/:[0-9][0-9]*:[0-9][0-9]*/:0:0/g'"
   , "-e", "'s/:[0-9]*:[0-9]*-[0-9]*/:0:0:/g'"
   , "-e", "'s/[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/0123456789/g'"
+  , "-e", "'s/[!#$%&*+./>]\\{10\\}/%%%%%%%%%%/g'"
   , file
   ]
 
diff --git a/tests/compile-and-dump/GradingClient/Database.ghc78.template b/tests/compile-and-dump/GradingClient/Database.ghc78.template
--- a/tests/compile-and-dump/GradingClient/Database.ghc78.template
+++ b/tests/compile-and-dump/GradingClient/Database.ghc78.template
@@ -278,45 +278,45 @@
       = forall arg. KindOf (Apply SchSym0 arg) ~ KindOf (SchSym1 arg) =>
         SchSym0KindInference
     type instance Apply SchSym0 l = SchSym1 l
-    type Let_0123456789Scrutinee_0123456789Sym4 t t t t =
-        Let_0123456789Scrutinee_0123456789 t t t t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym3 where
+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
+        Let0123456789Scrutinee_0123456789 t t t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
       suppressUnusedWarnings _
         = snd
             (GHC.Tuple.(,)
-               Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym3KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym2KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 name name' u attrs =
+               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
@@ -398,7 +398,7 @@
     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 (Let_0123456789Scrutinee_0123456789Sym4 name name' u attrs)
+      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))
@@ -445,7 +445,7 @@
           lambda name name' u attrs
             = let
                 sScrutinee_0123456789 ::
-                  Sing (Let_0123456789Scrutinee_0123456789Sym4 name name' u attrs)
+                  Sing (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs)
                 sScrutinee_0123456789
                   = applySing
                       (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) name) name'
diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template
--- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template
+++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template
@@ -57,36 +57,36 @@
     insertionSort :: [Nat] -> [Nat]
     insertionSort GHC.Types.[] = []
     insertionSort (h GHC.Types.: t) = insert h (insertionSort t)
-    type Let_0123456789Scrutinee_0123456789Sym3 t t t =
-        Let_0123456789Scrutinee_0123456789 t t t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where
+    type Let0123456789Scrutinee_0123456789Sym3 t t t =
+        Let0123456789Scrutinee_0123456789 t t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where
       suppressUnusedWarnings _
         = snd
             (GHC.Tuple.(,)
-               Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym2KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 n h t =
+               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)
@@ -135,7 +135,7 @@
       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 (Let_0123456789Scrutinee_0123456789Sym3 n h t)
+      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)
@@ -192,7 +192,7 @@
           lambda n h t
             = let
                 sScrutinee_0123456789 ::
-                  Sing (Let_0123456789Scrutinee_0123456789Sym3 n h t)
+                  Sing (Let0123456789Scrutinee_0123456789Sym3 n h t)
                 sScrutinee_0123456789
                   = applySing
                       (applySing (singFun2 (Proxy :: Proxy LeqSym0) sLeq) n) h
diff --git a/tests/compile-and-dump/Singletons/AsPattern.ghc78.template b/tests/compile-and-dump/Singletons/AsPattern.ghc78.template
--- a/tests/compile-and-dump/Singletons/AsPattern.ghc78.template
+++ b/tests/compile-and-dump/Singletons/AsPattern.ghc78.template
@@ -57,92 +57,92 @@
       = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>
         BazSym0KindInference
     type instance Apply BazSym0 l = BazSym1 l
-    type Let_0123456789PSym0 = Let_0123456789P
-    type Let_0123456789P = '[]
-    type Let_0123456789PSym1 t = Let_0123456789P t
-    instance SuppressUnusedWarnings Let_0123456789PSym0 where
+    type Let0123456789PSym0 = Let0123456789P
+    type Let0123456789P = '[]
+    type Let0123456789PSym1 t = Let0123456789P t
+    instance SuppressUnusedWarnings Let0123456789PSym0 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())
-    data Let_0123456789PSym0 l
-      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>
-        Let_0123456789PSym0KindInference
-    type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l
-    type Let_0123456789P wild_0123456789 =
+        = 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 Let_0123456789PSym2 t t = Let_0123456789P t t
-    instance SuppressUnusedWarnings Let_0123456789PSym1 where
+    type Let0123456789PSym2 t t = Let0123456789P t t
+    instance SuppressUnusedWarnings Let0123456789PSym1 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789PSym1KindInference GHC.Tuple.())
-    data Let_0123456789PSym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>
-        Let_0123456789PSym1KindInference
-    type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789PSym0 where
+        = 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.(,) Let_0123456789PSym0KindInference GHC.Tuple.())
-    data Let_0123456789PSym0 l
-      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>
-        Let_0123456789PSym0KindInference
-    type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l
-    type Let_0123456789P wild_0123456789 wild_0123456789 =
+        = 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 Let_0123456789PSym2 t t = Let_0123456789P t t
-    instance SuppressUnusedWarnings Let_0123456789PSym1 where
+    type Let0123456789PSym2 t t = Let0123456789P t t
+    instance SuppressUnusedWarnings Let0123456789PSym1 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789PSym1KindInference GHC.Tuple.())
-    data Let_0123456789PSym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>
-        Let_0123456789PSym1KindInference
-    type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789PSym0 where
+        = 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.(,) Let_0123456789PSym0KindInference GHC.Tuple.())
-    data Let_0123456789PSym0 l
-      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>
-        Let_0123456789PSym0KindInference
-    type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l
-    type Let_0123456789P wild_0123456789 wild_0123456789 =
+        = 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 Let_0123456789PSym0 = Let_0123456789P
-    type Let_0123456789P = NothingSym0
-    type Let_0123456789PSym3 t t t = Let_0123456789P t t t
-    instance SuppressUnusedWarnings Let_0123456789PSym2 where
+    type Let0123456789PSym0 = Let0123456789P
+    type Let0123456789P = NothingSym0
+    type Let0123456789PSym3 t t t = Let0123456789P t t t
+    instance SuppressUnusedWarnings Let0123456789PSym2 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789PSym2KindInference GHC.Tuple.())
-    data Let_0123456789PSym2 l l l
-      = forall arg. KindOf (Apply (Let_0123456789PSym2 l l) arg) ~ KindOf (Let_0123456789PSym3 l l arg) =>
-        Let_0123456789PSym2KindInference
-    type instance Apply (Let_0123456789PSym2 l l) l = Let_0123456789PSym3 l l l
-    instance SuppressUnusedWarnings Let_0123456789PSym1 where
+        = 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.(,) Let_0123456789PSym1KindInference GHC.Tuple.())
-    data Let_0123456789PSym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>
-        Let_0123456789PSym1KindInference
-    type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789PSym0 where
+        = 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.(,) Let_0123456789PSym0KindInference GHC.Tuple.())
-    data Let_0123456789PSym0 l
-      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>
-        Let_0123456789PSym0KindInference
-    type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l
-    type Let_0123456789P wild_0123456789
+        = 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 Let_0123456789XSym1 t = Let_0123456789X t
-    instance SuppressUnusedWarnings Let_0123456789XSym0 where
+    type Let0123456789XSym1 t = Let0123456789X t
+    instance SuppressUnusedWarnings Let0123456789XSym0 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789XSym0KindInference GHC.Tuple.())
-    data Let_0123456789XSym0 l
-      = forall arg. KindOf (Apply Let_0123456789XSym0 arg) ~ KindOf (Let_0123456789XSym1 arg) =>
-        Let_0123456789XSym0KindInference
-    type instance Apply Let_0123456789XSym0 l = Let_0123456789XSym1 l
-    type Let_0123456789X wild_0123456789 =
+        = 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 Let_0123456789PSym0 = Let_0123456789P
-    type Let_0123456789P = NothingSym0
+    type Let0123456789PSym0 = Let0123456789P
+    type Let0123456789P = NothingSym0
     type FooSym1 (t :: [Nat]) = Foo t
     instance SuppressUnusedWarnings FooSym0 where
       suppressUnusedWarnings _
@@ -184,21 +184,21 @@
         MaybePlusSym0KindInference
     type instance Apply MaybePlusSym0 l = MaybePlusSym1 l
     type family Foo (a :: [Nat]) :: [Nat] where
-      Foo '[] = Let_0123456789PSym0
-      Foo '[wild_0123456789] = Let_0123456789PSym1 wild_0123456789
-      Foo ((:) wild_0123456789 wild_0123456789) = Let_0123456789PSym2 wild_0123456789 wild_0123456789
+      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) = Let_0123456789PSym2 wild_0123456789 wild_0123456789
+            wild_0123456789) = Let0123456789PSym2 wild_0123456789 wild_0123456789
     type family Baz_ (a :: Maybe Baz) :: Maybe Baz where
-      Baz_ Nothing = Let_0123456789PSym0
-      Baz_ (Just (Baz wild_0123456789 wild_0123456789 wild_0123456789)) = Let_0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789
+      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) = Let_0123456789XSym1 wild_0123456789
+      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 = Let_0123456789PSym0
+      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)
@@ -210,7 +210,7 @@
           lambda :: t ~ '[] => Sing (Apply FooSym0 '[])
           lambda
             = let
-                sP :: Sing Let_0123456789PSym0
+                sP :: Sing Let0123456789PSym0
                 sP = SNil
               in sP
         in lambda
@@ -222,7 +222,7 @@
             -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) '[]))
           lambda wild_0123456789
             = let
-                sP :: Sing (Let_0123456789PSym1 wild_0123456789)
+                sP :: Sing (Let0123456789PSym1 wild_0123456789)
                 sP
                   = applySing
                       (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)
@@ -239,7 +239,7 @@
                -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) wild_0123456789))
           lambda wild_0123456789 wild_0123456789
             = let
-                sP :: Sing (Let_0123456789PSym2 wild_0123456789 wild_0123456789)
+                sP :: Sing (Let0123456789PSym2 wild_0123456789 wild_0123456789)
                 sP
                   = applySing
                       (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)
@@ -256,7 +256,7 @@
                -> Sing (Apply TupSym0 (Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789))
           lambda wild_0123456789 wild_0123456789
             = let
-                sP :: Sing (Let_0123456789PSym2 wild_0123456789 wild_0123456789)
+                sP :: Sing (Let0123456789PSym2 wild_0123456789 wild_0123456789)
                 sP
                   = applySing
                       (applySing
@@ -269,7 +269,7 @@
           lambda :: t ~ NothingSym0 => Sing (Apply Baz_Sym0 NothingSym0)
           lambda
             = let
-                sP :: Sing Let_0123456789PSym0
+                sP :: Sing Let0123456789PSym0
                 sP = SNothing
               in sP
         in lambda
@@ -287,7 +287,7 @@
           lambda wild_0123456789 wild_0123456789 wild_0123456789
             = let
                 sP ::
-                  Sing (Let_0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789)
+                  Sing (Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789)
                 sP
                   = applySing
                       (singFun1 (Proxy :: Proxy JustSym0) SJust)
@@ -307,7 +307,7 @@
             -> Sing (Apply BarSym0 (Apply JustSym0 wild_0123456789))
           lambda wild_0123456789
             = let
-                sX :: Sing (Let_0123456789XSym1 wild_0123456789)
+                sX :: Sing (Let0123456789XSym1 wild_0123456789)
                 sX
                   = applySing
                       (singFun1 (Proxy :: Proxy JustSym0) SJust) wild_0123456789
@@ -337,7 +337,7 @@
           lambda :: t ~ NothingSym0 => Sing (Apply MaybePlusSym0 NothingSym0)
           lambda
             = let
-                sP :: Sing Let_0123456789PSym0
+                sP :: Sing Let0123456789PSym0
                 sP = SNothing
               in sP
         in lambda
diff --git a/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template b/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template
--- a/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template
+++ b/tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template
@@ -38,18 +38,18 @@
                in z }
     foo5 :: forall a. a -> a
     foo5 x = case x of { y -> \ _ -> x y }
-    type Let_0123456789Scrutinee_0123456789Sym1 t =
-        Let_0123456789Scrutinee_0123456789 t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+    type Let0123456789Scrutinee_0123456789Sym1 t =
+        Let0123456789Scrutinee_0123456789 t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
       suppressUnusedWarnings _
         = snd
             (GHC.Tuple.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 x = x
+               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
@@ -81,95 +81,95 @@
     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 Let_0123456789Scrutinee_0123456789Sym1 t =
-        Let_0123456789Scrutinee_0123456789 t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+    type Let0123456789Scrutinee_0123456789Sym1 t =
+        Let0123456789Scrutinee_0123456789 t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
       suppressUnusedWarnings _
         = snd
             (GHC.Tuple.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 x = x
-    type Let_0123456789ZSym2 t t = Let_0123456789Z t t
-    instance SuppressUnusedWarnings Let_0123456789ZSym1 where
+               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.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())
-    data Let_0123456789ZSym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>
-        Let_0123456789ZSym1KindInference
-    type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where
+        = 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.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
-    data Let_0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
-        Let_0123456789ZSym0KindInference
-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
-    type Let_0123456789Z x y = (y :: a)
+        = 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 = Let_0123456789ZSym2 x y
-    type Let_0123456789Scrutinee_0123456789Sym2 t t =
-        Let_0123456789Scrutinee_0123456789 t t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 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.(,)
-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 a b =
+               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 Let_0123456789Scrutinee_0123456789Sym1 t =
-        Let_0123456789Scrutinee_0123456789 t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+    type Let0123456789Scrutinee_0123456789Sym1 t =
+        Let0123456789Scrutinee_0123456789 t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
       suppressUnusedWarnings _
         = snd
             (GHC.Tuple.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 d = Apply JustSym0 d
+               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 Let_0123456789Scrutinee_0123456789Sym2 t t =
-        Let_0123456789Scrutinee_0123456789 t t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
+    type Let0123456789Scrutinee_0123456789Sym2 t t =
+        Let0123456789Scrutinee_0123456789 t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where
       suppressUnusedWarnings _
         = snd
             (GHC.Tuple.(,)
-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 d x = x
+               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
@@ -235,15 +235,15 @@
         Foo1Sym0KindInference
     type instance Apply Foo1Sym0 l = Foo1Sym1 l
     type family Foo5 (a :: a) :: a where
-      Foo5 x = Case_0123456789 x (Let_0123456789Scrutinee_0123456789Sym1 x)
+      Foo5 x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)
     type family Foo4 (a :: a) :: a where
-      Foo4 x = Case_0123456789 x (Let_0123456789Scrutinee_0123456789Sym1 x)
+      Foo4 x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)
     type family Foo3 (a :: a) (a :: b) :: a where
-      Foo3 a b = Case_0123456789 a b (Let_0123456789Scrutinee_0123456789Sym2 a b)
+      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 (Let_0123456789Scrutinee_0123456789Sym1 d)
+      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 (Let_0123456789Scrutinee_0123456789Sym2 d x)
+      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 ::
@@ -261,7 +261,7 @@
           lambda x
             = let
                 sScrutinee_0123456789 ::
-                  Sing (Let_0123456789Scrutinee_0123456789Sym1 x)
+                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)
                 sScrutinee_0123456789 = x
               in
                 case sScrutinee_0123456789 of {
@@ -296,7 +296,7 @@
           lambda x
             = let
                 sScrutinee_0123456789 ::
-                  Sing (Let_0123456789Scrutinee_0123456789Sym1 x)
+                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)
                 sScrutinee_0123456789 = x
               in
                 case sScrutinee_0123456789 of {
@@ -305,7 +305,7 @@
                          lambda :: forall y. Sing y -> Sing (Case_0123456789 x y)
                          lambda y
                            = let
-                               sZ :: Sing (Let_0123456789ZSym2 x y)
+                               sZ :: Sing (Let0123456789ZSym2 x y)
                                sZ = y
                              in sZ
                        in lambda sY }
@@ -318,7 +318,7 @@
           lambda a b
             = let
                 sScrutinee_0123456789 ::
-                  Sing (Let_0123456789Scrutinee_0123456789Sym2 a b)
+                  Sing (Let0123456789Scrutinee_0123456789Sym2 a b)
                 sScrutinee_0123456789
                   = applySing
                       (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) a) b
@@ -341,7 +341,7 @@
           lambda d
             = let
                 sScrutinee_0123456789 ::
-                  Sing (Let_0123456789Scrutinee_0123456789Sym1 d)
+                  Sing (Let0123456789Scrutinee_0123456789Sym1 d)
                 sScrutinee_0123456789
                   = applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) d
               in
@@ -361,7 +361,7 @@
           lambda d x
             = let
                 sScrutinee_0123456789 ::
-                  Sing (Let_0123456789Scrutinee_0123456789Sym2 d x)
+                  Sing (Let0123456789Scrutinee_0123456789Sym2 d x)
                 sScrutinee_0123456789 = x
               in
                 case sScrutinee_0123456789 of {
diff --git a/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template b/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template
--- a/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template
+++ b/tests/compile-and-dump/Singletons/HigherOrder.ghc78.template
@@ -58,50 +58,50 @@
       = forall arg. KindOf (Apply RightSym0 arg) ~ KindOf (RightSym1 arg) =>
         RightSym0KindInference
     type instance Apply RightSym0 l = RightSym1 l
-    type Let_0123456789Scrutinee_0123456789Sym4 t t t t =
-        Let_0123456789Scrutinee_0123456789 t t t t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym3 where
+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
+        Let0123456789Scrutinee_0123456789 t t t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
       suppressUnusedWarnings _
         = snd
             (GHC.Tuple.(,)
-               Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym3KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym2KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 ns bs n b = b
+               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 (Let_0123456789Scrutinee_0123456789Sym4 ns bs n b)
+      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 _
@@ -135,45 +135,45 @@
       = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789Sym4 t t t t =
-        Let_0123456789Scrutinee_0123456789 t t t t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym3 where
+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =
+        Let0123456789Scrutinee_0123456789 t t t t
+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where
       suppressUnusedWarnings _
         = snd
             (GHC.Tuple.(,)
-               Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym3 l l l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym3KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym2 l l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym2KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 n
+               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 =
@@ -182,7 +182,7 @@
       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 (Let_0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)
+      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 _
@@ -459,7 +459,7 @@
                                  lambda n b
                                    = let
                                        sScrutinee_0123456789 ::
-                                         Sing (Let_0123456789Scrutinee_0123456789Sym4 ns bs n b)
+                                         Sing (Let0123456789Scrutinee_0123456789Sym4 ns bs n b)
                                        sScrutinee_0123456789 = b
                                      in
                                        case sScrutinee_0123456789 of {
@@ -508,7 +508,7 @@
                                  lambda n b
                                    = let
                                        sScrutinee_0123456789 ::
-                                         Sing (Let_0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)
+                                         Sing (Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)
                                        sScrutinee_0123456789 = b
                                      in
                                        case sScrutinee_0123456789 of {
diff --git a/tests/compile-and-dump/Singletons/LetStatements.ghc78.template b/tests/compile-and-dump/Singletons/LetStatements.ghc78.template
--- a/tests/compile-and-dump/Singletons/LetStatements.ghc78.template
+++ b/tests/compile-and-dump/Singletons/LetStatements.ghc78.template
@@ -194,145 +194,135 @@
       Case_0123456789 x '(y_0123456789, z) = y_0123456789
     type family Case_0123456789 x t where
       Case_0123456789 x '(z, y_0123456789) = y_0123456789
-    type Let_0123456789YSym1 t = Let_0123456789Y t
-    instance SuppressUnusedWarnings Let_0123456789YSym0 where
+    type Let0123456789YSym1 t = Let0123456789Y t
+    instance SuppressUnusedWarnings Let0123456789YSym0 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789YSym0KindInference GHC.Tuple.())
-    data Let_0123456789YSym0 l
-      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>
-        Let_0123456789YSym0KindInference
-    type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l
-    type Let_0123456789ZSym1 t = Let_0123456789Z t
-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where
+        = 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.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
-    data Let_0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
-        Let_0123456789ZSym0KindInference
-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
-    type Let_0123456789X_0123456789Sym1 t =
-        Let_0123456789X_0123456789 t
-    instance SuppressUnusedWarnings Let_0123456789X_0123456789Sym0 where
+        = 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.(,)
-               Let_0123456789X_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789X_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789X_0123456789Sym0 arg) ~ KindOf (Let_0123456789X_0123456789Sym1 arg) =>
-        Let_0123456789X_0123456789Sym0KindInference
-    type instance Apply Let_0123456789X_0123456789Sym0 l = Let_0123456789X_0123456789Sym1 l
-    type Let_0123456789Y x =
-        Case_0123456789 x (Let_0123456789X_0123456789Sym1 x)
-    type Let_0123456789Z x =
-        Case_0123456789 x (Let_0123456789X_0123456789Sym1 x)
-    type Let_0123456789X_0123456789 x =
+               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 Let_0123456789BarSym1 t = Let_0123456789Bar t
-    instance SuppressUnusedWarnings Let_0123456789BarSym0 where
+    type Let0123456789BarSym1 t = Let0123456789Bar t
+    instance SuppressUnusedWarnings Let0123456789BarSym0 where
       suppressUnusedWarnings _
         = snd
-            (GHC.Tuple.(,) Let_0123456789BarSym0KindInference GHC.Tuple.())
-    data Let_0123456789BarSym0 l
-      = forall arg. KindOf (Apply Let_0123456789BarSym0 arg) ~ KindOf (Let_0123456789BarSym1 arg) =>
-        Let_0123456789BarSym0KindInference
-    type instance Apply Let_0123456789BarSym0 l = Let_0123456789BarSym1 l
-    type Let_0123456789Bar x = (x :: a)
-    type Let_0123456789:+Sym3 t (t :: Nat) (t :: Nat) =
-        Let_0123456789:+ t t t
-    instance SuppressUnusedWarnings Let_0123456789:+Sym2 where
+            (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.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>
-        Let_0123456789:+Sym2KindInference
-    type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l
-    instance SuppressUnusedWarnings Let_0123456789:+Sym1 where
+        = 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.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>
-        Let_0123456789:+Sym1KindInference
-    type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789:+Sym0 where
+        = 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.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>
-        Let_0123456789:+Sym0KindInference
-    type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l
-    type family Let_0123456789:+ x (a :: Nat) (a :: Nat) :: Nat where
-      Let_0123456789:+ x Zero m = m
-      Let_0123456789:+ x (Succ n) m = Apply SuccSym0 (Apply (Apply (Let_0123456789:+Sym1 x) n) x)
-    type Let_0123456789ZSym1 t = Let_0123456789Z t
-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where
+        = 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.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
-    data Let_0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
-        Let_0123456789ZSym0KindInference
-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
-    type Let_0123456789:+Sym3 t (t :: Nat) (t :: Nat) =
-        Let_0123456789:+ t t t
-    instance SuppressUnusedWarnings Let_0123456789:+Sym2 where
+        = 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.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>
-        Let_0123456789:+Sym2KindInference
-    type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l
-    instance SuppressUnusedWarnings Let_0123456789:+Sym1 where
+        = 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.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>
-        Let_0123456789:+Sym1KindInference
-    type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789:+Sym0 where
+        = 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.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>
-        Let_0123456789:+Sym0KindInference
-    type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l
-    type Let_0123456789Z x = (x :: Nat)
-    type family Let_0123456789:+ x (a :: Nat) (a :: Nat) :: Nat where
-      Let_0123456789:+ x Zero m = m
-      Let_0123456789:+ x (Succ n) m = Apply SuccSym0 (Apply (Apply (Let_0123456789:+Sym1 x) n) m)
-    type Let_0123456789:+Sym3 t (t :: Nat) (t :: Nat) =
-        Let_0123456789:+ t t t
-    instance SuppressUnusedWarnings Let_0123456789:+Sym2 where
+        = 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.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>
-        Let_0123456789:+Sym2KindInference
-    type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l
-    instance SuppressUnusedWarnings Let_0123456789:+Sym1 where
+        = 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.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))
-      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>
-        Let_0123456789:+Sym1KindInference
-    type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789:+Sym0 where
+        = 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.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())
-    data Let_0123456789:+Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>
-        Let_0123456789:+Sym0KindInference
-    type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l
-    type family Let_0123456789:+ x (a :: Nat) (a :: Nat) :: Nat where
-      Let_0123456789:+ x Zero m = m
-      Let_0123456789:+ x (Succ n) m = Apply SuccSym0 (Apply (Apply (Let_0123456789:+Sym1 x) n) m)
+        = 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
@@ -360,23 +350,23 @@
       = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type Let_0123456789ZSym2 t (t :: Nat) = Let_0123456789Z t t
-    instance SuppressUnusedWarnings Let_0123456789ZSym1 where
+    type Let0123456789ZSym2 t (t :: Nat) = Let0123456789Z t t
+    instance SuppressUnusedWarnings Let0123456789ZSym1 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())
-    data Let_0123456789ZSym1 l (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>
-        Let_0123456789ZSym1KindInference
-    type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where
+        = 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.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
-    data Let_0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
-        Let_0123456789ZSym0KindInference
-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
-    type family Let_0123456789Z x (a :: Nat) :: Nat where
-      Let_0123456789Z x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789
+        = 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
@@ -396,123 +386,123 @@
       = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>
         Lambda_0123456789Sym0KindInference
     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l
-    type Let_0123456789ZSym1 t = Let_0123456789Z t
-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where
+    type Let0123456789ZSym1 t = Let0123456789Z t
+    instance SuppressUnusedWarnings Let0123456789ZSym0 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
-    data Let_0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
-        Let_0123456789ZSym0KindInference
-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
-    type Let_0123456789Z x =
+        = 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 Let_0123456789XSym1 t = Let_0123456789X t
-    instance SuppressUnusedWarnings Let_0123456789XSym0 where
+    type Let0123456789XSym1 t = Let0123456789X t
+    instance SuppressUnusedWarnings Let0123456789XSym0 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789XSym0KindInference GHC.Tuple.())
-    data Let_0123456789XSym0 l
-      = forall arg. KindOf (Apply Let_0123456789XSym0 arg) ~ KindOf (Let_0123456789XSym1 arg) =>
-        Let_0123456789XSym0KindInference
-    type instance Apply Let_0123456789XSym0 l = Let_0123456789XSym1 l
-    type Let_0123456789X x = (ZeroSym0 :: Nat)
-    type Let_0123456789FSym2 t (t :: Nat) = Let_0123456789F t t
-    instance SuppressUnusedWarnings Let_0123456789FSym1 where
+        = 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.(,) Let_0123456789FSym1KindInference GHC.Tuple.())
-    data Let_0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>
-        Let_0123456789FSym1KindInference
-    type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789FSym0 where
+        = 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.(,) Let_0123456789FSym0KindInference GHC.Tuple.())
-    data Let_0123456789FSym0 l
-      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>
-        Let_0123456789FSym0KindInference
-    type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l
-    type family Let_0123456789F x (a :: Nat) :: Nat where
-      Let_0123456789F x y = Apply SuccSym0 y
-    type Let_0123456789ZSym1 t = Let_0123456789Z t
-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where
+        = 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.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
-    data Let_0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
-        Let_0123456789ZSym0KindInference
-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
-    type Let_0123456789Z x = (Apply (Let_0123456789FSym1 x) x :: Nat)
-    type Let_0123456789ZSym2 t t = Let_0123456789Z t t
-    instance SuppressUnusedWarnings Let_0123456789ZSym1 where
+        = 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.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())
-    data Let_0123456789ZSym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>
-        Let_0123456789ZSym1KindInference
-    type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where
+        = 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.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())
-    data Let_0123456789ZSym0 l
-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>
-        Let_0123456789ZSym0KindInference
-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l
-    type Let_0123456789Z x y = (Apply SuccSym0 y :: Nat)
-    type Let_0123456789FSym2 t (t :: Nat) = Let_0123456789F t t
-    instance SuppressUnusedWarnings Let_0123456789FSym1 where
+        = 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.(,) Let_0123456789FSym1KindInference GHC.Tuple.())
-    data Let_0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>
-        Let_0123456789FSym1KindInference
-    type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789FSym0 where
+        = 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.(,) Let_0123456789FSym0KindInference GHC.Tuple.())
-    data Let_0123456789FSym0 l
-      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>
-        Let_0123456789FSym0KindInference
-    type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l
-    type family Let_0123456789F x (a :: Nat) :: Nat where
-      Let_0123456789F x y = Apply SuccSym0 (Let_0123456789ZSym2 x y)
-    type Let_0123456789FSym2 t (t :: Nat) = Let_0123456789F t t
-    instance SuppressUnusedWarnings Let_0123456789FSym1 where
+        = 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.(,) Let_0123456789FSym1KindInference GHC.Tuple.())
-    data Let_0123456789FSym1 l (l :: TyFun Nat Nat)
-      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>
-        Let_0123456789FSym1KindInference
-    type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789FSym0 where
+        = 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.(,) Let_0123456789FSym0KindInference GHC.Tuple.())
-    data Let_0123456789FSym0 l
-      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>
-        Let_0123456789FSym0KindInference
-    type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l
-    type family Let_0123456789F x (a :: Nat) :: Nat where
-      Let_0123456789F x y = Apply SuccSym0 y
-    type Let_0123456789YSym1 t = Let_0123456789Y t
-    instance SuppressUnusedWarnings Let_0123456789YSym0 where
+        = 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.(,) Let_0123456789YSym0KindInference GHC.Tuple.())
-    data Let_0123456789YSym0 l
-      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>
-        Let_0123456789YSym0KindInference
-    type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l
-    type Let_0123456789Y x = (Apply SuccSym0 x :: Nat)
-    type Let_0123456789YSym0 = Let_0123456789Y
-    type Let_0123456789ZSym0 = Let_0123456789Z
-    type Let_0123456789Y = Apply SuccSym0 ZeroSym0
-    type Let_0123456789Z = Apply SuccSym0 Let_0123456789YSym0
-    type Let_0123456789YSym1 t = Let_0123456789Y t
-    instance SuppressUnusedWarnings Let_0123456789YSym0 where
+        = 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.(,) Let_0123456789YSym0KindInference GHC.Tuple.())
-    data Let_0123456789YSym0 l
-      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>
-        Let_0123456789YSym0KindInference
-    type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l
-    type Let_0123456789Y x = (Apply SuccSym0 ZeroSym0 :: Nat)
+        = 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 _
@@ -627,34 +617,34 @@
         Foo1Sym0KindInference
     type instance Apply Foo1Sym0 l = Foo1Sym1 l
     type family Foo14 (a :: Nat) :: (Nat, Nat) where
-      Foo14 x = Apply (Apply Tuple2Sym0 (Let_0123456789ZSym1 x)) (Let_0123456789YSym1 x)
+      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 (Let_0123456789BarSym1 x)
+      Foo13 x = Apply Foo13_Sym0 (Let0123456789BarSym1 x)
     type family Foo12 (a :: Nat) :: Nat where
-      Foo12 x = Apply (Apply (Let_0123456789:+Sym1 x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))
+      Foo12 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))
     type family Foo11 (a :: Nat) :: Nat where
-      Foo11 x = Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 ZeroSym0)) (Let_0123456789ZSym1 x)
+      Foo11 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789ZSym1 x)
     type family Foo10 (a :: Nat) :: Nat where
-      Foo10 x = Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 ZeroSym0)) x
+      Foo10 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) x
     type family Foo9 (a :: Nat) :: Nat where
-      Foo9 x = Apply (Let_0123456789ZSym1 x) x
+      Foo9 x = Apply (Let0123456789ZSym1 x) x
     type family Foo8 (a :: Nat) :: Nat where
-      Foo8 x = Let_0123456789ZSym1 x
+      Foo8 x = Let0123456789ZSym1 x
     type family Foo7 (a :: Nat) :: Nat where
-      Foo7 x = Let_0123456789XSym1 x
+      Foo7 x = Let0123456789XSym1 x
     type family Foo6 (a :: Nat) :: Nat where
-      Foo6 x = Let_0123456789ZSym1 x
+      Foo6 x = Let0123456789ZSym1 x
     type family Foo5 (a :: Nat) :: Nat where
-      Foo5 x = Apply (Let_0123456789FSym1 x) x
+      Foo5 x = Apply (Let0123456789FSym1 x) x
     type family Foo4 (a :: Nat) :: Nat where
-      Foo4 x = Apply (Let_0123456789FSym1 x) x
+      Foo4 x = Apply (Let0123456789FSym1 x) x
     type family Foo3 (a :: Nat) :: Nat where
-      Foo3 x = Let_0123456789YSym1 x
-    type Foo2 = (Let_0123456789ZSym0 :: Nat)
+      Foo3 x = Let0123456789YSym1 x
+    type Foo2 = (Let0123456789ZSym0 :: Nat)
     type family Foo1 (a :: Nat) :: Nat where
-      Foo1 x = Let_0123456789YSym1 x
+      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)
@@ -675,9 +665,9 @@
           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo14Sym0 x)
           lambda x
             = let
-                sY :: Sing (Let_0123456789YSym1 x)
-                sZ :: Sing (Let_0123456789ZSym1 x)
-                sX_0123456789 :: Sing (Let_0123456789X_0123456789Sym1 x)
+                sY :: Sing (Let0123456789YSym1 x)
+                sZ :: Sing (Let0123456789ZSym1 x)
+                sX_0123456789 :: Sing (Let0123456789X_0123456789Sym1 x)
                 sY
                   = case sX_0123456789 of {
                       STuple2 sY_0123456789 _
@@ -718,7 +708,7 @@
           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo13Sym0 x)
           lambda x
             = let
-                sBar :: Sing (Let_0123456789BarSym1 x)
+                sBar :: Sing (Let0123456789BarSym1 x)
                 sBar = x
               in applySing (singFun1 (Proxy :: Proxy Foo13_Sym0) sFoo13_) sBar
         in lambda sX
@@ -730,12 +720,12 @@
                 (%:+) ::
                   forall t t.
                   Sing t
-                  -> Sing t -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) t) t)
+                  -> Sing t -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t)
                 (%:+) SZero sM
                   = let
                       lambda ::
                         forall m. (t ~ ZeroSym0, t ~ m) =>
-                        Sing m -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) ZeroSym0) m)
+                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)
                       lambda m = m
                     in lambda sM
                 (%:+) (SSucc sN) sM
@@ -744,19 +734,19 @@
                         forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
                         Sing n
                         -> Sing m
-                           -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)
+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)
                       lambda n m
                         = applySing
                             (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
                             (applySing
                                (applySing
-                                  (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+)) n)
+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
                                x)
                     in lambda sN sM
               in
                 applySing
                   (applySing
-                     (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+)) x)
+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) x)
                   (applySing
                      (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
@@ -766,17 +756,17 @@
           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo11Sym0 x)
           lambda x
             = let
-                sZ :: Sing (Let_0123456789ZSym1 x)
+                sZ :: Sing (Let0123456789ZSym1 x)
                 (%:+) ::
                   forall t t.
                   Sing t
-                  -> Sing t -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) t) 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 (Let_0123456789:+Sym1 x) ZeroSym0) m)
+                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)
                       lambda m = m
                     in lambda sM
                 (%:+) (SSucc sN) sM
@@ -785,19 +775,19 @@
                         forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
                         Sing n
                         -> Sing m
-                           -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)
+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)
                       lambda n m
                         = applySing
                             (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
                             (applySing
                                (applySing
-                                  (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+)) n)
+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
                                m)
                     in lambda sN sM
               in
                 applySing
                   (applySing
-                     (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+))
+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+))
                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
                   sZ
         in lambda sX
@@ -809,12 +799,12 @@
                 (%:+) ::
                   forall t t.
                   Sing t
-                  -> Sing t -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) t) t)
+                  -> Sing t -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t)
                 (%:+) SZero sM
                   = let
                       lambda ::
                         forall m. (t ~ ZeroSym0, t ~ m) =>
-                        Sing m -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) ZeroSym0) m)
+                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)
                       lambda m = m
                     in lambda sM
                 (%:+) (SSucc sN) sM
@@ -823,19 +813,19 @@
                         forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>
                         Sing n
                         -> Sing m
-                           -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)
+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)
                       lambda n m
                         = applySing
                             (singFun1 (Proxy :: Proxy SuccSym0) SSucc)
                             (applySing
                                (applySing
-                                  (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+)) n)
+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)
                                m)
                     in lambda sN sM
               in
                 applySing
                   (applySing
-                     (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+))
+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+))
                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))
                   x
         in lambda sX
@@ -844,13 +834,13 @@
           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo9Sym0 x)
           lambda x
             = let
-                sZ :: forall t. Sing t -> Sing (Apply (Let_0123456789ZSym1 x) t)
+                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 (Let_0123456789ZSym1 x) a_0123456789)
+                        -> Sing (Apply (Let0123456789ZSym1 x) a_0123456789)
                       lambda a_0123456789
                         = applySing
                             (singFun1
@@ -867,14 +857,14 @@
                             a_0123456789
                     in lambda sA_0123456789
               in
-                applySing (singFun1 (Proxy :: Proxy (Let_0123456789ZSym1 x)) sZ) x
+                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 (Let_0123456789ZSym1 x)
+                sZ :: Sing (Let0123456789ZSym1 x)
                 sZ
                   = applySing
                       (singFun1
@@ -894,7 +884,7 @@
           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo7Sym0 x)
           lambda x
             = let
-                sX :: Sing (Let_0123456789XSym1 x)
+                sX :: Sing (Let0123456789XSym1 x)
                 sX = SZero
               in sX
         in lambda sX
@@ -903,18 +893,17 @@
           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo6Sym0 x)
           lambda x
             = let
-                sF :: forall t. Sing t -> Sing (Apply (Let_0123456789FSym1 x) t)
+                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)
                 sF sY
                   = let
                       lambda ::
-                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
+                        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 (Let_0123456789ZSym1 x)
+                sZ :: Sing (Let0123456789ZSym1 x)
                 sZ
-                  = applySing
-                      (singFun1 (Proxy :: Proxy (Let_0123456789FSym1 x)) sF) x
+                  = applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x
               in sZ
         in lambda sX
     sFoo5 sX
@@ -922,48 +911,48 @@
           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 x)
           lambda x
             = let
-                sF :: forall t. Sing t -> Sing (Apply (Let_0123456789FSym1 x) t)
+                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)
                 sF sY
                   = let
                       lambda ::
-                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
+                        forall y. t ~ y => Sing y -> Sing (Apply (Let0123456789FSym1 x) y)
                       lambda y
                         = let
-                            sZ :: Sing (Let_0123456789ZSym2 x y)
+                            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 (Let_0123456789FSym1 x)) sF) x
+                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 (Let_0123456789FSym1 x) t)
+                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)
                 sF sY
                   = let
                       lambda ::
-                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)
+                        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 (Let_0123456789FSym1 x)) sF) x
+                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 (Let_0123456789YSym1 x)
+                sY :: Sing (Let0123456789YSym1 x)
                 sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) x
               in sY
         in lambda sX
     sFoo2
       = let
-          sY :: Sing Let_0123456789YSym0
-          sZ :: Sing Let_0123456789ZSym0
+          sY :: Sing Let0123456789YSym0
+          sZ :: Sing Let0123456789ZSym0
           sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero
           sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sY
         in sZ
@@ -972,7 +961,7 @@
           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo1Sym0 x)
           lambda x
             = let
-                sY :: Sing (Let_0123456789YSym1 x)
+                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/PatternMatching.ghc78.template b/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template
--- a/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template
+++ b/tests/compile-and-dump/Singletons/PatternMatching.ghc78.template
@@ -126,44 +126,43 @@
     foo1 (x, y) = \ _ -> x y
     foo2 :: forall a b. (# a, b #) -> a
     foo2 t@(# x, y #) = case t of { (# a, b #) -> \ _ -> a b }
-    type Let_0123456789TSym2 t t = Let_0123456789T t t
-    instance SuppressUnusedWarnings Let_0123456789TSym1 where
+    type Let0123456789TSym2 t t = Let0123456789T t t
+    instance SuppressUnusedWarnings Let0123456789TSym1 where
       suppressUnusedWarnings _
-        = snd (GHC.Tuple.(,) Let_0123456789TSym1KindInference GHC.Tuple.())
-    data Let_0123456789TSym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789TSym1 l) arg) ~ KindOf (Let_0123456789TSym2 l arg) =>
-        Let_0123456789TSym1KindInference
-    type instance Apply (Let_0123456789TSym1 l) l = Let_0123456789TSym2 l l
-    instance SuppressUnusedWarnings Let_0123456789TSym0 where
+        = 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.(,) Let_0123456789TSym0KindInference GHC.Tuple.())
-    data Let_0123456789TSym0 l
-      = forall arg. KindOf (Apply Let_0123456789TSym0 arg) ~ KindOf (Let_0123456789TSym1 arg) =>
-        Let_0123456789TSym0KindInference
-    type instance Apply Let_0123456789TSym0 l = Let_0123456789TSym1 l
-    type Let_0123456789T x y = Apply (Apply Tuple2Sym0 x) y
-    type Let_0123456789Scrutinee_0123456789Sym2 t t =
-        Let_0123456789Scrutinee_0123456789 t t
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where
+        = 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.(,)
-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym1 l l
-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>
-        Let_0123456789Scrutinee_0123456789Sym1KindInference
-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l
-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where
+               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.(,)
-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
-    data Let_0123456789Scrutinee_0123456789Sym0 l
-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>
-        Let_0123456789Scrutinee_0123456789Sym0KindInference
-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l
-    type Let_0123456789Scrutinee_0123456789 x y =
-        Let_0123456789TSym2 x y
+               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
@@ -293,7 +292,7 @@
     type X_0123456789Sym0 = X_0123456789
     type family Foo2 (a :: (a, b)) :: a where
       Foo2 '(x,
-             y) = Case_0123456789 x y (Let_0123456789Scrutinee_0123456789Sym2 x y)
+             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)
@@ -334,13 +333,13 @@
             -> Sing y -> Sing (Apply Foo2Sym0 (Apply (Apply Tuple2Sym0 x) y))
           lambda x y
             = let
-                sT :: Sing (Let_0123456789TSym2 x y)
+                sT :: Sing (Let0123456789TSym2 x y)
                 sT
                   = applySing
                       (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) x) y in
               let
                 sScrutinee_0123456789 ::
-                  Sing (Let_0123456789Scrutinee_0123456789Sym2 x y)
+                  Sing (Let0123456789Scrutinee_0123456789Sym2 x y)
                 sScrutinee_0123456789 = sT
               in
                 case sScrutinee_0123456789 of {