Inline wrappers earlier

This patch has a single significant change:

  strictness wrapper functions are inlined earlier,
  in phase 2 rather than phase 0.

As shown by Trac #15056, this gives a better chance for RULEs to fire.
Before this change, a function that would have inlined early without
strictness analyss was instead inlining late. Result: applying
"optimisation" made the program worse.

This does not make too much difference in nofib, but I've stumbled
over the problem more than once, so even a "no-change" result would be
quite acceptable.  Here are the headlines:

--------------------------------------------------------------------------------
        Program           Size    Allocs   Runtime   Elapsed  TotalMem
--------------------------------------------------------------------------------
      cacheprof          -0.5%     -0.5%     +2.5%     +2.5%      0.0%
         fulsom          -1.0%     +2.6%     -0.1%     -0.1%      0.0%
           mate          -0.6%     +2.4%     -0.9%     -0.9%      0.0%
        veritas          -0.7%    -23.2%     0.002     0.002      0.0%
--------------------------------------------------------------------------------
            Min          -1.4%    -23.2%    -12.5%    -15.3%      0.0%
            Max          +0.6%     +2.6%     +4.4%     +4.3%    +19.0%
 Geometric Mean          -0.7%     -0.2%     -1.4%     -1.7%     +0.2%

* A worthwhile reduction in binary size.

* Runtimes are not to be trusted much but look as if they
  are moving the right way.

* A really big win in veritas, described in comment:1 of
  Trac #15056; more fusion rules fired.

* I investigated the losses in 'mate' and 'fulsom'; see #15056.

13 files changed, 323 insertions, 265 deletions

diff --git a/compiler/stranal/WorkWrap.hs b/compiler/stranal/WorkWrap.hs
index ac8798e56e..9557cecdfe 100644
--- a/compiler/stranal/WorkWrap.hs
+++ b/compiler/stranal/WorkWrap.hs
@@ -242,8 +242,8 @@ NOINLINE pragma to the worker.
 
 (See Trac #13143 for a real-world example.)
 
-Note [Activation for workers]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Note [Worker activation]
+~~~~~~~~~~~~~~~~~~~~~~~~
 Follows on from Note [Worker-wrapper for INLINABLE functions]
 
 It is *vital* that if the worker gets an INLINABLE pragma (from the
@@ -260,7 +260,9 @@ original activation. Consider
 
   f y = let z = expensive y in ...
 
-If expensive's worker inherits the wrapper's activation, we'll get
+If expensive's worker inherits the wrapper's activation,
+we'll get this (because of the compromise in point (2) of
+Note [Wrapper activation])
 
   {-# NOINLINE[0] $wexpensive #-}
   $wexpensive x = x + 1
@@ -346,40 +348,63 @@ call:
 
 Note [Wrapper activation]
 ~~~~~~~~~~~~~~~~~~~~~~~~~
-When should the wrapper inlining be active?  It must not be active
-earlier than the current Activation of the Id (eg it might have a
-NOINLINE pragma).  But in fact strictness analysis happens fairly
-late in the pipeline, and we want to prioritise specialisations over
-strictness.  Eg if we have
-  module Foo where
-    f :: Num a => a -> Int -> a
-    f n 0 = n              -- Strict in the Int, hence wrapper
-    f n x = f (n+n) (x-1)
-
-    g :: Int -> Int
-    g x = f x x            -- Provokes a specialisation for f
-
-  module Bar where
-    import Foo
-
-    h :: Int -> Int
-    h x = f 3 x
-
-Then we want the specialisation for 'f' to kick in before the wrapper does.
-
-Now in fact the 'gentle' simplification pass encourages this, by
-having rules on, but inlinings off.  But that's kind of lucky. It seems
-more robust to give the wrapper an Activation of (ActiveAfter 0),
-so that it becomes active in an importing module at the same time that
-it appears in the first place in the defining module.
-
-At one stage I tried making the wrapper inlining always-active, and
-that had a very bad effect on nofib/imaginary/x2n1; a wrapper was
-inlined before the specialisation fired.
-
-The use an inl_inline of NoUserInline to distinguish this pragma from one
-that was given by the user. In particular, CSE will not happen if there is a
-user-specified pragma, but should happen for w/w’ed things (#14186).
+When should the wrapper inlining be active?
+
+1. It must not be active earlier than the current Activation of the
+   Id
+
+2. It should be active at some point, despite (1) because of
+   Note [Worker-wrapper for NOINLINE functions]
+
+3. For ordinary functions with no pragmas we want to inline the
+   wrapper as early as possible (Trac #15056).  Suppose another module
+   defines    f x = g x x
+   and suppose there is some RULE for (g True True).  Then if we have
+   a call (f True), we'd expect to inline 'f' and the RULE will fire.
+   But if f is w/w'd (which it might be), we want the inlining to
+   occur just as if it hadn't been.
+
+   (This only matters if f's RHS is big enough to w/w, but small
+   enough to inline given the call site, but that can happen.)
+
+4. We do not want to inline the wrapper before specialisation.
+         module Foo where
+           f :: Num a => a -> Int -> a
+           f n 0 = n              -- Strict in the Int, hence wrapper
+           f n x = f (n+n) (x-1)
+
+           g :: Int -> Int
+           g x = f x x            -- Provokes a specialisation for f
+
+         module Bar where
+           import Foo
+
+           h :: Int -> Int
+           h x = f 3 x
+
+   In module Bar we want to give specialisations a chance to fire
+   before inlining f's wrapper.
+
+Reminder: Note [Don't w/w INLINE things], so we don't need to worry
+          about INLINE things here.
+
+Conclusion:
+  - If the user said NOINLINE[n], respect that
+  - If the user said NOINLINE, inline the wrapper as late as
+    poss (phase 0). This is a compromise driven by (2) above
+  - Otherwise inline wrapper in phase 2.  That allows the
+    'gentle' simplification pass to apply specialisation rules
+
+Historical note: At one stage I tried making the wrapper inlining
+always-active, and that had a very bad effect on nofib/imaginary/x2n1;
+a wrapper was inlined before the specialisation fired.
+
+Note [Wrapper NoUserInline]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The use an inl_inline of NoUserInline on the wrapper distinguishes
+this pragma from one that was given by the user. In particular, CSE
+will not happen if there is a user-specified pragma, but should happen
+for w/w’ed things (#14186).
 -}
 
 tryWW   :: DynFlags
@@ -475,23 +500,24 @@ splitFun dflags fam_envs fn_id fn_info wrap_dmds res_info rhs
       Just (work_demands, join_arity, wrap_fn, work_fn) -> do
         work_uniq <- getUniqueM
         let work_rhs = work_fn rhs
-            work_inline = inl_inline inl_prag
-            work_act = case work_inline of
-              -- See Note [Activation for workers]
-              NoInline -> inl_act inl_prag
-              _        -> wrap_act
+            work_act = case fn_inline_spec of  -- See Note [Worker activation]
+                          NoInline -> fn_act
+                          _        -> wrap_act
+
             work_prag = InlinePragma { inl_src = SourceText "{-# INLINE"
-                                     , inl_inline = work_inline
+                                     , inl_inline = fn_inline_spec
                                      , inl_sat    = Nothing
                                      , inl_act    = work_act
                                      , inl_rule   = FunLike }
-              -- idl_inline: copy from fn_id; see Note [Worker-wrapper for INLINABLE functions]
-              -- idl_act: see Note [Activation for workers]
-              -- inl_rule: it does not make sense for workers to be constructorlike.
+              -- inl_inline: copy from fn_id; see Note [Worker-wrapper for INLINABLE functions]
+              -- inl_act:    see Note [Worker activation]
+              -- inl_rule:   it does not make sense for workers to be constructorlike.
+
             work_join_arity | isJoinId fn_id = Just join_arity
                             | otherwise      = Nothing
               -- worker is join point iff wrapper is join point
               -- (see Note [Don't CPR join points])
+
             work_id  = mkWorkerId work_uniq fn_id (exprType work_rhs)
                         `setIdOccInfo` occInfo fn_info
                                 -- Copy over occurrence info from parent
@@ -523,16 +549,19 @@ splitFun dflags fam_envs fn_id fn_info wrap_dmds res_info rhs
             worker_demand | single_call = mkWorkerDemand work_arity
                           | otherwise   = topDmd
 
-
-            wrap_act  = ActiveAfter NoSourceText 0
             wrap_rhs  = wrap_fn work_id
-            wrap_prag = InlinePragma { inl_src = SourceText "{-# INLINE"
+            wrap_act  = case fn_act of  -- See Note [Wrapper activation]
+                           ActiveAfter {} -> fn_act
+                           NeverActive    -> ActiveAfter NoSourceText 0
+                           _              -> ActiveAfter NoSourceText 2
+            wrap_prag = InlinePragma { inl_src    = SourceText "{-# INLINE"
                                      , inl_inline = NoUserInline
                                      , inl_sat    = Nothing
                                      , inl_act    = wrap_act
                                      , inl_rule   = rule_match_info }
-                -- See Note [Wrapper activation]
-                -- The RuleMatchInfo is (and must be) unaffected
+                -- inl_act:    see Note [Wrapper activation]
+                -- inl_inline: see Note [Wrapper NoUserInline]
+                -- inl_rule:   RuleMatchInfo is (and must be) unaffected
 
             wrap_id   = fn_id `setIdUnfolding`  mkWwInlineRule wrap_rhs arity
                               `setInlinePragma` wrap_prag
@@ -550,8 +579,10 @@ splitFun dflags fam_envs fn_id fn_info wrap_dmds res_info rhs
     mb_join_arity   = isJoinId_maybe fn_id
     rhs_fvs         = exprFreeVars rhs
     fun_ty          = idType fn_id
-    inl_prag        = inlinePragInfo fn_info
-    rule_match_info = inlinePragmaRuleMatchInfo inl_prag
+    fn_inl_prag     = inlinePragInfo fn_info
+    fn_inline_spec  = inl_inline fn_inl_prag
+    fn_act          = inl_act fn_inl_prag
+    rule_match_info = inlinePragmaRuleMatchInfo fn_inl_prag
     arity           = arityInfo fn_info
                     -- The arity is set by the simplifier using exprEtaExpandArity
                     -- So it may be more than the number of top-level-visible lambdas
diff --git a/testsuite/tests/simplCore/should_compile/T13143.stderr b/testsuite/tests/simplCore/should_compile/T13143.stderr
index 01cb771e20..160a4a2c93 100644
--- a/testsuite/tests/simplCore/should_compile/T13143.stderr
+++ b/testsuite/tests/simplCore/should_compile/T13143.stderr
@@ -74,7 +74,7 @@ lvl = T13143.$wf @ Int GHC.Prim.void#
 
 Rec {
 -- RHS size: {terms: 28, types: 7, coercions: 0, joins: 0/0}
-T13143.$wg [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
+T13143.$wg [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker]
   :: Bool -> Bool -> GHC.Prim.Int# -> GHC.Prim.Int#
 [GblId, Arity=3, Str=<S,1*U><S,1*U><S,U>, Unf=OtherCon []]
 T13143.$wg
@@ -94,7 +94,7 @@ T13143.$wg
 end Rec }
 
 -- RHS size: {terms: 14, types: 6, coercions: 0, joins: 0/0}
-g [InlPrag=NOUSERINLINE[0]] :: Bool -> Bool -> Int -> Int
+g [InlPrag=NOUSERINLINE[2]] :: Bool -> Bool -> Int -> Int
 [GblId,
  Arity=3,
  Str=<S,1*U><S,1*U><S(S),1*U(U)>m,
diff --git a/testsuite/tests/simplCore/should_compile/T15056.hs b/testsuite/tests/simplCore/should_compile/T15056.hs
new file mode 100644
index 0000000000..e65f73a3cf
--- /dev/null
+++ b/testsuite/tests/simplCore/should_compile/T15056.hs
@@ -0,0 +1,6 @@
+module T15056 where
+
+import T15056a
+
+blam x = foo 3 [1..x]
+-- We expect fold/build to fire
diff --git a/testsuite/tests/simplCore/should_compile/T15056.stderr b/testsuite/tests/simplCore/should_compile/T15056.stderr
new file mode 100644
index 0000000000..1b8c0c8101
--- /dev/null
+++ b/testsuite/tests/simplCore/should_compile/T15056.stderr
@@ -0,0 +1,9 @@
+Rule fired: Class op - (BUILTIN)
+Rule fired: Class op + (BUILTIN)
+Rule fired: Class op + (BUILTIN)
+Rule fired: Class op enumFromTo (BUILTIN)
+Rule fired: Class op foldr (BUILTIN)
+Rule fired: Class op foldr (BUILTIN)
+Rule fired: +# (BUILTIN)
+Rule fired: Class op foldr (BUILTIN)
+Rule fired: fold/build (GHC.Base)
diff --git a/testsuite/tests/simplCore/should_compile/T15056a.hs b/testsuite/tests/simplCore/should_compile/T15056a.hs
new file mode 100644
index 0000000000..6883a90e4b
--- /dev/null
+++ b/testsuite/tests/simplCore/should_compile/T15056a.hs
@@ -0,0 +1,11 @@
+module T15056a where
+
+test :: Int -> Bool
+test 0 = True
+test n = test (n-1)
+
+foo :: Foldable t => Int -> t Int -> Int
+foo n xs | test n
+         = foldr (+) n xs
+         | otherwise
+         = n+7
diff --git a/testsuite/tests/simplCore/should_compile/T3717.stderr b/testsuite/tests/simplCore/should_compile/T3717.stderr
index c32dffddd8..a271850abf 100644
--- a/testsuite/tests/simplCore/should_compile/T3717.stderr
+++ b/testsuite/tests/simplCore/should_compile/T3717.stderr
@@ -49,7 +49,7 @@ T3717.$trModule
 
 Rec {
 -- RHS size: {terms: 10, types: 2, coercions: 0, joins: 0/0}
-T3717.$wfoo [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
+T3717.$wfoo [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker]
   :: GHC.Prim.Int# -> GHC.Prim.Int#
 [GblId, Arity=1, Caf=NoCafRefs, Str=<S,1*U>, Unf=OtherCon []]
 T3717.$wfoo
@@ -61,7 +61,7 @@ T3717.$wfoo
 end Rec }
 
 -- RHS size: {terms: 10, types: 4, coercions: 0, joins: 0/0}
-foo [InlPrag=NOUSERINLINE[0]] :: Int -> Int
+foo [InlPrag=NOUSERINLINE[2]] :: Int -> Int
 [GblId,
  Arity=1,
  Caf=NoCafRefs,
diff --git a/testsuite/tests/simplCore/should_compile/T4908.stderr b/testsuite/tests/simplCore/should_compile/T4908.stderr
index 41b2d5d20d..62f300e962 100644
--- a/testsuite/tests/simplCore/should_compile/T4908.stderr
+++ b/testsuite/tests/simplCore/should_compile/T4908.stderr
@@ -68,7 +68,7 @@ T4908.f_$s$wf
 end Rec }
 
 -- RHS size: {terms: 24, types: 13, coercions: 0, joins: 0/0}
-T4908.$wf [InlPrag=NOUSERINLINE[0]] :: Int# -> (Int, Int) -> Bool
+T4908.$wf [InlPrag=NOUSERINLINE[2]] :: Int# -> (Int, Int) -> Bool
 [GblId,
  Arity=2,
  Caf=NoCafRefs,
@@ -91,7 +91,7 @@ T4908.$wf
       }
 
 -- RHS size: {terms: 8, types: 6, coercions: 0, joins: 0/0}
-f [InlPrag=NOUSERINLINE[0]] :: Int -> (Int, Int) -> Bool
+f [InlPrag=NOUSERINLINE[2]] :: Int -> (Int, Int) -> Bool
 [GblId,
  Arity=2,
  Caf=NoCafRefs,
@@ -106,7 +106,7 @@ f = \ (w :: Int) (w1 :: (Int, Int)) ->
 
 
 ------ Local rules for imported ids --------
-"SC:$wf0" [0]
+"SC:$wf0" [2]
     forall (sc :: Int) (sc1 :: Int#) (sc2 :: Int#).
       T4908.$wf sc2 (sc, GHC.Types.I# sc1)
       = T4908.f_$s$wf sc sc1 sc2
diff --git a/testsuite/tests/simplCore/should_compile/T4930.stderr b/testsuite/tests/simplCore/should_compile/T4930.stderr
index 2c63c279ba..02e8a6c65e 100644
--- a/testsuite/tests/simplCore/should_compile/T4930.stderr
+++ b/testsuite/tests/simplCore/should_compile/T4930.stderr
@@ -49,7 +49,7 @@ T4930.$trModule
 
 Rec {
 -- RHS size: {terms: 17, types: 3, coercions: 0, joins: 0/0}
-T4930.$wfoo [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
+T4930.$wfoo [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker]
   :: GHC.Prim.Int# -> GHC.Prim.Int#
 [GblId, Arity=1, Caf=NoCafRefs, Str=<S,U>, Unf=OtherCon []]
 T4930.$wfoo
@@ -61,7 +61,7 @@ T4930.$wfoo
 end Rec }
 
 -- RHS size: {terms: 10, types: 4, coercions: 0, joins: 0/0}
-foo [InlPrag=NOUSERINLINE[0]] :: Int -> Int
+foo [InlPrag=NOUSERINLINE[2]] :: Int -> Int
 [GblId,
  Arity=1,
  Caf=NoCafRefs,
diff --git a/testsuite/tests/simplCore/should_compile/T6056.stderr b/testsuite/tests/simplCore/should_compile/T6056.stderr
index a1f022e914..e1c8aab26c 100644
--- a/testsuite/tests/simplCore/should_compile/T6056.stderr
+++ b/testsuite/tests/simplCore/should_compile/T6056.stderr
@@ -1,5 +1,5 @@
 Rule fired: SPEC/T6056 $wsmallerAndRest @ Int (T6056)
-Rule fired: Class op < (BUILTIN)
 Rule fired: SPEC/T6056 $wsmallerAndRest @ Int (T6056)
+Rule fired: Class op < (BUILTIN)
 Rule fired: SPEC/T6056 $wsmallerAndRest @ Int (T6056)
 Rule fired: SPEC/T6056 $wsmallerAndRest @ Int (T6056)
diff --git a/testsuite/tests/simplCore/should_compile/all.T b/testsuite/tests/simplCore/should_compile/all.T
index bdab09962f..71743bc654 100644
--- a/testsuite/tests/simplCore/should_compile/all.T
+++ b/testsuite/tests/simplCore/should_compile/all.T
@@ -303,3 +303,4 @@ test('T14978',
      ['$MAKE -s --no-print-directory T14978'])
 test('T15002', [ req_profiling ], compile, ['-O -fprof-auto -prof'])
 test('T15005', normal, compile, ['-O'])
+test('T15056', [extra_files(['T15056a.hs'])], multimod_compile, ['T15056', '-O -v0 -ddump-rule-firings'])
diff --git a/testsuite/tests/simplCore/should_compile/spec-inline.stderr b/testsuite/tests/simplCore/should_compile/spec-inline.stderr
index 13b1a9b1de..0b0c79695a 100644
--- a/testsuite/tests/simplCore/should_compile/spec-inline.stderr
+++ b/testsuite/tests/simplCore/should_compile/spec-inline.stderr
@@ -90,7 +90,7 @@ Roman.foo_$s$wgo
 end Rec }
 
 -- RHS size: {terms: 71, types: 19, coercions: 0, joins: 0/1}
-Roman.$wgo [InlPrag=NOUSERINLINE[0]]
+Roman.$wgo [InlPrag=NOUSERINLINE[2]]
   :: Maybe Int -> Maybe Int -> GHC.Prim.Int#
 [GblId,
  Arity=2,
@@ -135,7 +135,7 @@ Roman.$wgo
       }
 
 -- RHS size: {terms: 9, types: 5, coercions: 0, joins: 0/0}
-Roman.foo_go [InlPrag=NOUSERINLINE[0]]
+Roman.foo_go [InlPrag=NOUSERINLINE[2]]
   :: Maybe Int -> Maybe Int -> Int
 [GblId,
  Arity=2,
@@ -188,7 +188,7 @@ foo
 
 
 ------ Local rules for imported ids --------
-"SC:$wgo0" [0]
+"SC:$wgo0" [2]
     forall (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#).
       Roman.$wgo (GHC.Base.Just @ Int (GHC.Types.I# sc1))
                  (GHC.Base.Just @ Int (GHC.Types.I# sc))
diff --git a/testsuite/tests/stranal/should_compile/T10482.stderr b/testsuite/tests/stranal/should_compile/T10482.stderr
index 7900f0d5fc..47e8e102c4 100644
--- a/testsuite/tests/stranal/should_compile/T10482.stderr
+++ b/testsuite/tests/stranal/should_compile/T10482.stderr
@@ -10,13 +10,13 @@ T10482.$WFooPair [InlPrag=INLINE[2]] :: forall a b. Foo a -> Foo b -> Foo (a, b)
  Str=<S,U><S,U>m,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (@ a_aWY) (@ b_aWZ) (dt_a2p0 [Occ=Once] :: Foo a_aWY[sk:1]) (dt_a2p1 [Occ=Once] :: Foo b_aWZ[sk:1]) ->
-                 (case dt_a2p0 of dt_X2p5 { __DEFAULT -> case dt_a2p1 of dt_X2p7 { __DEFAULT -> T10482.FooPair @ a_aWY @ b_aWZ dt_X2p5 dt_X2p7 } })
-                 `cast` (Sym (T10482.D:R:Foo(,)0[0] <a_aWY>_N <b_aWZ>_N) :: (T10482.R:Foo(,) a_aWY b_aWZ :: *) ~R# (Foo (a_aWY, b_aWZ) :: *))}]
+         Tmpl= \ (@ a_aX9) (@ b_aXa) (dt_a2pg [Occ=Once] :: Foo a_aX9[sk:2]) (dt_a2ph [Occ=Once] :: Foo b_aXa[sk:2]) ->
+                 (case dt_a2pg of dt_X2pl { __DEFAULT -> case dt_a2ph of dt_X2pn { __DEFAULT -> T10482.FooPair @ a_aX9 @ b_aXa dt_X2pl dt_X2pn } })
+                 `cast` (Sym (T10482.D:R:Foo(,)0[0] <a_aX9>_N <b_aXa>_N) :: (T10482.R:Foo(,) a_aX9 b_aXa :: *) ~R# (Foo (a_aX9, b_aXa) :: *))}]
 T10482.$WFooPair
-  = \ (@ a_aWY) (@ b_aWZ) (dt_a2p0 [Occ=Once] :: Foo a_aWY[sk:1]) (dt_a2p1 [Occ=Once] :: Foo b_aWZ[sk:1]) ->
-      (case dt_a2p0 of dt_X2p5 { __DEFAULT -> case dt_a2p1 of dt_X2p7 { __DEFAULT -> T10482.FooPair @ a_aWY @ b_aWZ dt_X2p5 dt_X2p7 } })
-      `cast` (Sym (T10482.D:R:Foo(,)0[0] <a_aWY>_N <b_aWZ>_N) :: (T10482.R:Foo(,) a_aWY b_aWZ :: *) ~R# (Foo (a_aWY, b_aWZ) :: *))
+  = \ (@ a_aX9) (@ b_aXa) (dt_a2pg [Occ=Once] :: Foo a_aX9[sk:2]) (dt_a2ph [Occ=Once] :: Foo b_aXa[sk:2]) ->
+      (case dt_a2pg of dt_X2pl { __DEFAULT -> case dt_a2ph of dt_X2pn { __DEFAULT -> T10482.FooPair @ a_aX9 @ b_aXa dt_X2pl dt_X2pn } })
+      `cast` (Sym (T10482.D:R:Foo(,)0[0] <a_aX9>_N <b_aXa>_N) :: (T10482.R:Foo(,) a_aX9 b_aXa :: *) ~R# (Foo (a_aX9, b_aXa) :: *))
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 T10482.$trModule4 :: GHC.Prim.Addr#
@@ -57,34 +57,34 @@ T10482.$trModule :: GHC.Types.Module
 T10482.$trModule = GHC.Types.Module T10482.$trModule3 T10482.$trModule1
 
 -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
-$krep_r2Pm :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep_r2Pm = GHC.Types.KindRepTyConApp GHC.Types.$tcInt (GHC.Types.[] @ GHC.Types.KindRep)
+$krep_r2Q4 :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep_r2Q4 = GHC.Types.KindRepTyConApp GHC.Types.$tcInt (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
-$krep1_r2Pn :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep1_r2Pn = GHC.Types.KindRepVar 1#
+$krep1_r2Q5 :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep1_r2Q5 = GHC.Types.KindRepVar 1#
 
 -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
-$krep2_r2Po :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep2_r2Po = GHC.Types.KindRepVar 0#
+$krep2_r2Q6 :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep2_r2Q6 = GHC.Types.KindRepVar 0#
 
 -- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
-$krep3_r2Pp :: [GHC.Types.KindRep]
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep3_r2Pp = GHC.Types.: @ GHC.Types.KindRep $krep1_r2Pn (GHC.Types.[] @ GHC.Types.KindRep)
+$krep3_r2Q7 :: [GHC.Types.KindRep]
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep3_r2Q7 = GHC.Types.: @ GHC.Types.KindRep $krep1_r2Q5 (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
-$krep4_r2Pq :: [GHC.Types.KindRep]
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep4_r2Pq = GHC.Types.: @ GHC.Types.KindRep $krep2_r2Po $krep3_r2Pp
+$krep4_r2Q8 :: [GHC.Types.KindRep]
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep4_r2Q8 = GHC.Types.: @ GHC.Types.KindRep $krep2_r2Q6 $krep3_r2Q7
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep5_r2Pr :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep5_r2Pr = GHC.Types.KindRepTyConApp GHC.Tuple.$tc(,) $krep4_r2Pq
+$krep5_r2Q9 :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep5_r2Q9 = GHC.Types.KindRepTyConApp GHC.Tuple.$tc(,) $krep4_r2Q8
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 T10482.$tcFoo2 :: GHC.Prim.Addr#
@@ -110,54 +110,54 @@ T10482.$tcFoo :: GHC.Types.TyCon
 T10482.$tcFoo = GHC.Types.TyCon 3311038889639791302## 7944995683507700778## T10482.$trModule T10482.$tcFoo1 0# GHC.Types.krep$*Arr*
 
 -- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
-$krep6_r2Ps :: [GHC.Types.KindRep]
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep6_r2Ps = GHC.Types.: @ GHC.Types.KindRep $krep2_r2Po (GHC.Types.[] @ GHC.Types.KindRep)
+$krep6_r2Qa :: [GHC.Types.KindRep]
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep6_r2Qa = GHC.Types.: @ GHC.Types.KindRep $krep2_r2Q6 (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep7_r2Pt :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep7_r2Pt = GHC.Types.KindRepTyConApp T10482.$tcFoo $krep6_r2Ps
+$krep7_r2Qb :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep7_r2Qb = GHC.Types.KindRepTyConApp T10482.$tcFoo $krep6_r2Qa
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep8_r2Pu :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep8_r2Pu = GHC.Types.KindRepTyConApp T10482.$tcFoo $krep3_r2Pp
+$krep8_r2Qc :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep8_r2Qc = GHC.Types.KindRepTyConApp T10482.$tcFoo $krep3_r2Q7
 
 -- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
-$krep9_r2Pv :: [GHC.Types.KindRep]
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep9_r2Pv = GHC.Types.: @ GHC.Types.KindRep $krep5_r2Pr (GHC.Types.[] @ GHC.Types.KindRep)
+$krep9_r2Qd :: [GHC.Types.KindRep]
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep9_r2Qd = GHC.Types.: @ GHC.Types.KindRep $krep5_r2Q9 (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep10_r2Pw :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep10_r2Pw = GHC.Types.KindRepTyConApp T10482.$tcFoo $krep9_r2Pv
+$krep10_r2Qe :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep10_r2Qe = GHC.Types.KindRepTyConApp T10482.$tcFoo $krep9_r2Qd
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep11_r2Px :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-$krep11_r2Px = GHC.Types.KindRepFun $krep8_r2Pu $krep10_r2Pw
+$krep11_r2Qf :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+$krep11_r2Qf = GHC.Types.KindRepFun $krep8_r2Qc $krep10_r2Qe
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
 T10482.$tc'FooPair1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-T10482.$tc'FooPair1 = GHC.Types.KindRepFun $krep7_r2Pt $krep11_r2Px
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+T10482.$tc'FooPair1 = GHC.Types.KindRepFun $krep7_r2Qb $krep11_r2Qf
 
 -- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
-$krep12_r2Py :: [GHC.Types.KindRep]
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep12_r2Py = GHC.Types.: @ GHC.Types.KindRep $krep_r2Pm (GHC.Types.[] @ GHC.Types.KindRep)
+$krep12_r2Qg :: [GHC.Types.KindRep]
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep12_r2Qg = GHC.Types.: @ GHC.Types.KindRep $krep_r2Q4 (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep13_r2Pz :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep13_r2Pz = GHC.Types.KindRepTyConApp T10482.$tcFoo $krep12_r2Py
+$krep13_r2Qh :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep13_r2Qh = GHC.Types.KindRepTyConApp T10482.$tcFoo $krep12_r2Qg
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
 T10482.$tc'Foo1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-T10482.$tc'Foo1 = GHC.Types.KindRepFun $krep_r2Pm $krep13_r2Pz
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+T10482.$tc'Foo1 = GHC.Types.KindRepFun $krep_r2Q4 $krep13_r2Qh
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 T10482.$tc'FooPair3 :: GHC.Prim.Addr#
@@ -208,53 +208,53 @@ T10482.$tc'Foo = GHC.Types.TyCon 5096937192618987042## 15136671864408054946## T1
 
 Rec {
 -- RHS size: {terms: 19, types: 4, coercions: 0, joins: 0/0}
-T10482.$wfoo [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
-[GblId, Arity=2, Caf=NoCafRefs, Str=<L,1*U><S,1*U>]
+T10482.$wfoo [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
+[GblId, Arity=2, Caf=NoCafRefs, Str=<L,1*U><S,1*U>, Unf=OtherCon []]
 T10482.$wfoo
-  = \ (ww_s2NS :: GHC.Prim.Int#) (ww1_s2O0 :: GHC.Prim.Int#) ->
-      case ww1_s2O0 of wild_X1r {
+  = \ (ww_s2OA :: GHC.Prim.Int#) (ww1_s2OI :: GHC.Prim.Int#) ->
+      case ww1_s2OI of wild_X1r {
         __DEFAULT ->
           case GHC.Prim.remInt# wild_X1r 2# of {
-            __DEFAULT -> ww_s2NS;
-            0# -> T10482.$wfoo ww_s2NS (GHC.Prim.-# wild_X1r 1#)
+            __DEFAULT -> ww_s2OA;
+            0# -> T10482.$wfoo ww_s2OA (GHC.Prim.-# wild_X1r 1#)
           };
         0# -> 0#
       }
 end Rec }
 
 -- RHS size: {terms: 21, types: 30, coercions: 11, joins: 0/0}
-foo [InlPrag=NOUSERINLINE[0]] :: Foo ((Int, Int), Int) -> Int -> Int
+foo [InlPrag=NOUSERINLINE[2]] :: Foo ((Int, Int), Int) -> Int -> Int
 [GblId,
  Arity=2,
  Caf=NoCafRefs,
  Str=<S(S(S(S)L)L),1*U(U(U(1*U),A),A)><S(S),1*U(1*U)>m,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (w_s2NI [Occ=Once] :: Foo ((Int, Int), Int)) (w1_s2NJ [Occ=Once!] :: Int) ->
-                 case w_s2NI
+         Tmpl= \ (w_s2Oq [Occ=Once] :: Foo ((Int, Int), Int)) (w1_s2Or [Occ=Once!] :: Int) ->
+                 case w_s2Oq
                       `cast` (T10482.D:R:Foo(,)0[0] <(Int, Int)>_N <Int>_N :: (Foo ((Int, Int), Int) :: *) ~R# (T10482.R:Foo(,) (Int, Int) Int :: *))
                  of
-                 { FooPair ww1_s2NM [Occ=Once] _ [Occ=Dead] ->
-                 case ww1_s2NM `cast` (T10482.D:R:Foo(,)0[0] <Int>_N <Int>_N :: (Foo (Int, Int) :: *) ~R# (T10482.R:Foo(,) Int Int :: *)) of
-                 { FooPair ww4_s2NP [Occ=Once] _ [Occ=Dead] ->
-                 case ww4_s2NP `cast` (T10482.D:R:FooInt0[0] ; T10482.N:R:FooInt[0] :: (Foo Int :: *) ~R# (Int :: *)) of
-                 { GHC.Types.I# ww7_s2NS [Occ=Once] ->
-                 case w1_s2NJ of { GHC.Types.I# ww9_s2O0 [Occ=Once] ->
-                 case T10482.$wfoo ww7_s2NS ww9_s2O0 of ww10_s2O4 { __DEFAULT -> GHC.Types.I# ww10_s2O4 }
+                 { FooPair ww1_s2Ou [Occ=Once] _ [Occ=Dead] ->
+                 case ww1_s2Ou `cast` (T10482.D:R:Foo(,)0[0] <Int>_N <Int>_N :: (Foo (Int, Int) :: *) ~R# (T10482.R:Foo(,) Int Int :: *)) of
+                 { FooPair ww4_s2Ox [Occ=Once] _ [Occ=Dead] ->
+                 case ww4_s2Ox `cast` (T10482.D:R:FooInt0[0] ; T10482.N:R:FooInt[0] :: (Foo Int :: *) ~R# (Int :: *)) of
+                 { GHC.Types.I# ww7_s2OA [Occ=Once] ->
+                 case w1_s2Or of { GHC.Types.I# ww9_s2OI [Occ=Once] ->
+                 case T10482.$wfoo ww7_s2OA ww9_s2OI of ww10_s2OM { __DEFAULT -> GHC.Types.I# ww10_s2OM }
                  }
                  }
                  }
                  }}]
 foo
-  = \ (w_s2NI :: Foo ((Int, Int), Int)) (w1_s2NJ :: Int) ->
-      case w_s2NI
+  = \ (w_s2Oq :: Foo ((Int, Int), Int)) (w1_s2Or :: Int) ->
+      case w_s2Oq
            `cast` (T10482.D:R:Foo(,)0[0] <(Int, Int)>_N <Int>_N :: (Foo ((Int, Int), Int) :: *) ~R# (T10482.R:Foo(,) (Int, Int) Int :: *))
       of
-      { FooPair ww1_s2NM ww2_s2NW ->
-      case ww1_s2NM `cast` (T10482.D:R:Foo(,)0[0] <Int>_N <Int>_N :: (Foo (Int, Int) :: *) ~R# (T10482.R:Foo(,) Int Int :: *)) of
-      { FooPair ww4_s2OE ww5_s2OF ->
-      case ww4_s2OE `cast` (T10482.D:R:FooInt0[0] ; T10482.N:R:FooInt[0] :: (Foo Int :: *) ~R# (Int :: *)) of { GHC.Types.I# ww7_s2OI ->
-      case w1_s2NJ of { GHC.Types.I# ww9_s2O0 -> case T10482.$wfoo ww7_s2OI ww9_s2O0 of ww10_s2O4 { __DEFAULT -> GHC.Types.I# ww10_s2O4 } }
+      { FooPair ww1_s2Ou ww2_s2OE ->
+      case ww1_s2Ou `cast` (T10482.D:R:Foo(,)0[0] <Int>_N <Int>_N :: (Foo (Int, Int) :: *) ~R# (T10482.R:Foo(,) Int Int :: *)) of
+      { FooPair ww4_s2Pm ww5_s2Pn ->
+      case ww4_s2Pm `cast` (T10482.D:R:FooInt0[0] ; T10482.N:R:FooInt[0] :: (Foo Int :: *) ~R# (Int :: *)) of { GHC.Types.I# ww7_s2Pq ->
+      case w1_s2Or of { GHC.Types.I# ww9_s2OI -> case T10482.$wfoo ww7_s2Pq ww9_s2OI of ww10_s2OM { __DEFAULT -> GHC.Types.I# ww10_s2OM } }
       }
       }
       }
diff --git a/testsuite/tests/stranal/should_compile/T10482a.stderr b/testsuite/tests/stranal/should_compile/T10482a.stderr
index 341fe67258..6fa4f00d75 100644
--- a/testsuite/tests/stranal/should_compile/T10482a.stderr
+++ b/testsuite/tests/stranal/should_compile/T10482a.stderr
@@ -10,11 +10,11 @@ Foo.$WMkT4 [InlPrag=INLINE[2]] :: forall a. Foo a -> Int -> T4 a
  Str=<S,U><L,U>m,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (@ a_atD) (dt_a21t [Occ=Once] :: Foo a_atD[sk:1]) (dt_a21u [Occ=Once] :: Int) ->
-                 case dt_a21t of dt_X21x { __DEFAULT -> Foo.MkT4 @ a_atD dt_X21x dt_a21u }}]
+         Tmpl= \ (@ a_atA) (dt_a21M [Occ=Once] :: Foo a_atA[sk:1]) (dt_a21N [Occ=Once] :: Int) ->
+                 case dt_a21M of dt_X21Q { __DEFAULT -> Foo.MkT4 @ a_atA dt_X21Q dt_a21N }}]
 Foo.$WMkT4
-  = \ (@ a_atD) (dt_a21t [Occ=Once] :: Foo a_atD[sk:1]) (dt_a21u [Occ=Once] :: Int) ->
-      case dt_a21t of dt_X21x { __DEFAULT -> Foo.MkT4 @ a_atD dt_X21x dt_a21u }
+  = \ (@ a_atA) (dt_a21M [Occ=Once] :: Foo a_atA[sk:1]) (dt_a21N [Occ=Once] :: Int) ->
+      case dt_a21M of dt_X21Q { __DEFAULT -> Foo.MkT4 @ a_atA dt_X21Q dt_a21N }
 
 -- RHS size: {terms: 8, types: 3, coercions: 0, joins: 0/0}
 Foo.$WMkT2 [InlPrag=INLINE[2]] :: Int -> Int -> T2
@@ -24,10 +24,10 @@ Foo.$WMkT2 [InlPrag=INLINE[2]] :: Int -> Int -> T2
  Str=<S,U><L,U>m,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (dt_a20k [Occ=Once] :: Int) (dt_a20l [Occ=Once] :: Int) ->
-                 case dt_a20k of dt_X20n { __DEFAULT -> Foo.MkT2 dt_X20n dt_a20l }}]
+         Tmpl= \ (dt_a20w [Occ=Once] :: Int) (dt_a20x [Occ=Once] :: Int) ->
+                 case dt_a20w of dt_X20z { __DEFAULT -> Foo.MkT2 dt_X20z dt_a20x }}]
 Foo.$WMkT2
-  = \ (dt_a20k [Occ=Once] :: Int) (dt_a20l [Occ=Once] :: Int) -> case dt_a20k of dt_X20n { __DEFAULT -> Foo.MkT2 dt_X20n dt_a20l }
+  = \ (dt_a20w [Occ=Once] :: Int) (dt_a20x [Occ=Once] :: Int) -> case dt_a20w of dt_X20z { __DEFAULT -> Foo.MkT2 dt_X20z dt_a20x }
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 Foo.$trModule4 :: GHC.Prim.Addr#
@@ -68,14 +68,14 @@ Foo.$trModule :: GHC.Types.Module
 Foo.$trModule = GHC.Types.Module Foo.$trModule3 Foo.$trModule1
 
 -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
-$krep_r2nI :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep_r2nI = GHC.Types.KindRepTyConApp GHC.Types.$tcInt (GHC.Types.[] @ GHC.Types.KindRep)
+$krep_r2oJ :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep_r2oJ = GHC.Types.KindRepTyConApp GHC.Types.$tcInt (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
-$krep1_r2nJ :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep1_r2nJ = GHC.Types.KindRepVar 0#
+$krep1_r2oK :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep1_r2oK = GHC.Types.KindRepVar 0#
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 Foo.$tcT5 :: GHC.Prim.Addr#
@@ -101,19 +101,19 @@ Foo.$tcT2 :: GHC.Types.TyCon
 Foo.$tcT2 = GHC.Types.TyCon 12492463661685256209## 1082997131366389398## Foo.$trModule Foo.$tcT1 0# GHC.Types.krep$*
 
 -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
-$krep2_r2nK :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep2_r2nK = GHC.Types.KindRepTyConApp Foo.$tcT2 (GHC.Types.[] @ GHC.Types.KindRep)
+$krep2_r2oL :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep2_r2oL = GHC.Types.KindRepTyConApp Foo.$tcT2 (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep3_r2nL :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-$krep3_r2nL = GHC.Types.KindRepFun $krep_r2nI $krep2_r2nK
+$krep3_r2oM :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+$krep3_r2oM = GHC.Types.KindRepFun $krep_r2oJ $krep2_r2oL
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
 Foo.$tc'MkT1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-Foo.$tc'MkT1 = GHC.Types.KindRepFun $krep_r2nI $krep3_r2nL
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+Foo.$tc'MkT1 = GHC.Types.KindRepFun $krep_r2oJ $krep3_r2oM
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 Foo.$tc'MkT6 :: GHC.Prim.Addr#
@@ -162,19 +162,19 @@ Foo.$tcT3 :: GHC.Types.TyCon
 Foo.$tcT3 = GHC.Types.TyCon 8915518733037212359## 16476420519216613869## Foo.$trModule Foo.$tcT6 0# GHC.Types.krep$*
 
 -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
-$krep4_r2nM :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep4_r2nM = GHC.Types.KindRepTyConApp Foo.$tcT3 (GHC.Types.[] @ GHC.Types.KindRep)
+$krep4_r2oN :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep4_r2oN = GHC.Types.KindRepTyConApp Foo.$tcT3 (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep5_r2nN :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-$krep5_r2nN = GHC.Types.KindRepFun $krep_r2nI $krep4_r2nM
+$krep5_r2oO :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+$krep5_r2oO = GHC.Types.KindRepFun $krep_r2oJ $krep4_r2oN
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
 Foo.$tc'MkT7 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-Foo.$tc'MkT7 = GHC.Types.KindRepFun $krep_r2nI $krep5_r2nN
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+Foo.$tc'MkT7 = GHC.Types.KindRepFun $krep_r2oJ $krep5_r2oO
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 Foo.$tc'MkT9 :: GHC.Prim.Addr#
@@ -208,29 +208,29 @@ Foo.$tcFoo :: GHC.Types.TyCon
 Foo.$tcFoo = GHC.Types.TyCon 11236787750777559483## 2472662601374496863## Foo.$trModule Foo.$trModule1 0# GHC.Types.krep$*Arr*
 
 -- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
-$krep6_r2nO :: [GHC.Types.KindRep]
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep6_r2nO = GHC.Types.: @ GHC.Types.KindRep $krep1_r2nJ (GHC.Types.[] @ GHC.Types.KindRep)
+$krep6_r2oP :: [GHC.Types.KindRep]
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep6_r2oP = GHC.Types.: @ GHC.Types.KindRep $krep1_r2oK (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep7_r2nP :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep7_r2nP = GHC.Types.KindRepTyConApp Foo.$tcFoo $krep6_r2nO
+$krep7_r2oQ :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep7_r2oQ = GHC.Types.KindRepTyConApp Foo.$tcFoo $krep6_r2oP
 
 -- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
-$krep8_r2nQ :: [GHC.Types.KindRep]
-[GblId, Caf=NoCafRefs, Str=m2]
-$krep8_r2nQ = GHC.Types.: @ GHC.Types.KindRep $krep_r2nI (GHC.Types.[] @ GHC.Types.KindRep)
+$krep8_r2oR :: [GHC.Types.KindRep]
+[GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []]
+$krep8_r2oR = GHC.Types.: @ GHC.Types.KindRep $krep_r2oJ (GHC.Types.[] @ GHC.Types.KindRep)
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep9_r2nR :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep9_r2nR = GHC.Types.KindRepTyConApp Foo.$tcFoo $krep8_r2nQ
+$krep9_r2oS :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep9_r2oS = GHC.Types.KindRepTyConApp Foo.$tcFoo $krep8_r2oR
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
 Foo.$tc'Foo1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-Foo.$tc'Foo1 = GHC.Types.KindRepFun $krep_r2nI $krep9_r2nR
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+Foo.$tc'Foo1 = GHC.Types.KindRepFun $krep_r2oJ $krep9_r2oS
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 Foo.$tc'Foo3 :: GHC.Prim.Addr#
@@ -279,19 +279,19 @@ Foo.$tcT4 :: GHC.Types.TyCon
 Foo.$tcT4 = GHC.Types.TyCon 15961711399118996930## 13694522307176382499## Foo.$trModule Foo.$tcT8 0# GHC.Types.krep$*Arr*
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep10_r2nS :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m1]
-$krep10_r2nS = GHC.Types.KindRepTyConApp Foo.$tcT4 $krep6_r2nO
+$krep10_r2oT :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []]
+$krep10_r2oT = GHC.Types.KindRepTyConApp Foo.$tcT4 $krep6_r2oP
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
-$krep11_r2nT :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-$krep11_r2nT = GHC.Types.KindRepFun $krep_r2nI $krep10_r2nS
+$krep11_r2oU :: GHC.Types.KindRep
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+$krep11_r2oU = GHC.Types.KindRepFun $krep_r2oJ $krep10_r2oT
 
 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
 Foo.$tc'MkT10 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
-[GblId, Caf=NoCafRefs, Str=m4]
-Foo.$tc'MkT10 = GHC.Types.KindRepFun $krep7_r2nP $krep11_r2nT
+[GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []]
+Foo.$tc'MkT10 = GHC.Types.KindRepFun $krep7_r2oQ $krep11_r2oU
 
 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
 Foo.$tc'MkT12 :: GHC.Prim.Addr#
@@ -318,167 +318,167 @@ Foo.$tc'MkT4 = GHC.Types.TyCon 6077781708614236332## 14823286043222481570## Foo.
 
 Rec {
 -- RHS size: {terms: 14, types: 3, coercions: 0, joins: 0/0}
-Foo.$wf4 [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
-[GblId, Arity=2, Caf=NoCafRefs, Str=<S,1*U><S,U>]
+Foo.$wf4 [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
+[GblId, Arity=2, Caf=NoCafRefs, Str=<S,1*U><S,U>, Unf=OtherCon []]
 Foo.$wf4
-  = \ (ww_s2iK :: GHC.Prim.Int#) (ww1_s2iP :: GHC.Prim.Int#) ->
-      case GHC.Prim.># ww1_s2iP 0# of {
-        __DEFAULT -> ww_s2iK;
-        1# -> Foo.$wf4 ww_s2iK (GHC.Prim.-# ww1_s2iP 1#)
+  = \ (ww_s2jL :: GHC.Prim.Int#) (ww1_s2jQ :: GHC.Prim.Int#) ->
+      case GHC.Prim.># ww1_s2jQ 0# of {
+        __DEFAULT -> ww_s2jL;
+        1# -> Foo.$wf4 ww_s2jL (GHC.Prim.-# ww1_s2jQ 1#)
       }
 end Rec }
 
 -- RHS size: {terms: 17, types: 12, coercions: 3, joins: 0/0}
-f4 [InlPrag=NOUSERINLINE[0]] :: T4 Int -> Int
+f4 [InlPrag=NOUSERINLINE[2]] :: T4 Int -> Int
 [GblId,
  Arity=1,
  Caf=NoCafRefs,
  Str=<S(S(S)S(S)),1*U(U(1*U),1*U(U))>m,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (w_s2iE [Occ=Once!] :: T4 Int) ->
-                 case w_s2iE of { MkT4 ww1_s2iH [Occ=Once] ww2_s2iM [Occ=Once!] ->
-                 case ww1_s2iH `cast` (Foo.D:R:FooInt0[0] ; Foo.N:R:FooInt[0] :: (Foo Int :: *) ~R# (Int :: *)) of
-                 { GHC.Types.I# ww4_s2iK [Occ=Once] ->
-                 case ww2_s2iM of { GHC.Types.I# ww6_s2iP [Occ=Once] ->
-                 case Foo.$wf4 ww4_s2iK ww6_s2iP of ww7_s2iU { __DEFAULT -> GHC.Types.I# ww7_s2iU }
+         Tmpl= \ (w_s2jF [Occ=Once!] :: T4 Int) ->
+                 case w_s2jF of { MkT4 ww1_s2jI [Occ=Once] ww2_s2jN [Occ=Once!] ->
+                 case ww1_s2jI `cast` (Foo.D:R:FooInt0[0] ; Foo.N:R:FooInt[0] :: (Foo Int :: *) ~R# (Int :: *)) of
+                 { GHC.Types.I# ww4_s2jL [Occ=Once] ->
+                 case ww2_s2jN of { GHC.Types.I# ww6_s2jQ [Occ=Once] ->
+                 case Foo.$wf4 ww4_s2jL ww6_s2jQ of ww7_s2jV { __DEFAULT -> GHC.Types.I# ww7_s2jV }
                  }
                  }
                  }}]
 f4
-  = \ (w_s2iE :: T4 Int) ->
-      case w_s2iE of { MkT4 ww1_s2iH ww2_s2iM ->
-      case ww1_s2iH `cast` (Foo.D:R:FooInt0[0] ; Foo.N:R:FooInt[0] :: (Foo Int :: *) ~R# (Int :: *)) of { GHC.Types.I# ww4_s2lV ->
-      case ww2_s2iM of { GHC.Types.I# ww6_s2iP -> case Foo.$wf4 ww4_s2lV ww6_s2iP of ww7_s2iU { __DEFAULT -> GHC.Types.I# ww7_s2iU } }
+  = \ (w_s2jF :: T4 Int) ->
+      case w_s2jF of { MkT4 ww1_s2jI ww2_s2jN ->
+      case ww1_s2jI `cast` (Foo.D:R:FooInt0[0] ; Foo.N:R:FooInt[0] :: (Foo Int :: *) ~R# (Int :: *)) of { GHC.Types.I# ww4_s2mW ->
+      case ww2_s2jN of { GHC.Types.I# ww6_s2jQ -> case Foo.$wf4 ww4_s2mW ww6_s2jQ of ww7_s2jV { __DEFAULT -> GHC.Types.I# ww7_s2jV } }
       }
       }
 
 Rec {
 -- RHS size: {terms: 21, types: 4, coercions: 0, joins: 0/0}
-Foo.$wf2 [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
-[GblId, Arity=2, Caf=NoCafRefs, Str=<L,1*U><S,U>]
+Foo.$wf2 [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
+[GblId, Arity=2, Caf=NoCafRefs, Str=<L,1*U><S,U>, Unf=OtherCon []]
 Foo.$wf2
-  = \ (ww_s2j2 :: GHC.Prim.Int#) (ww1_s2j7 :: GHC.Prim.Int#) ->
-      case GHC.Prim.># ww1_s2j7 0# of {
+  = \ (ww_s2k3 :: GHC.Prim.Int#) (ww1_s2k8 :: GHC.Prim.Int#) ->
+      case GHC.Prim.># ww1_s2k8 0# of {
         __DEFAULT ->
-          case GHC.Prim.># ww1_s2j7 1# of {
-            __DEFAULT -> ww_s2j2;
+          case GHC.Prim.># ww1_s2k8 1# of {
+            __DEFAULT -> ww_s2k3;
             1# -> 1#
           };
-        1# -> Foo.$wf2 ww_s2j2 (GHC.Prim.-# ww1_s2j7 1#)
+        1# -> Foo.$wf2 ww_s2k3 (GHC.Prim.-# ww1_s2k8 1#)
       }
 end Rec }
 
 -- RHS size: {terms: 17, types: 9, coercions: 0, joins: 0/0}
-f2 [InlPrag=NOUSERINLINE[0]] :: T2 -> Int
+f2 [InlPrag=NOUSERINLINE[2]] :: T2 -> Int
 [GblId,
  Arity=1,
  Caf=NoCafRefs,
  Str=<S(S(S)S(S)),1*U(U(1*U),1*U(U))>m,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (w_s2iW [Occ=Once!] :: T2) ->
-                 case w_s2iW of { MkT2 ww1_s2iZ [Occ=Once!] ww2_s2j4 [Occ=Once!] ->
-                 case ww1_s2iZ of { GHC.Types.I# ww4_s2j2 [Occ=Once] ->
-                 case ww2_s2j4 of { GHC.Types.I# ww6_s2j7 [Occ=Once] ->
-                 case Foo.$wf2 ww4_s2j2 ww6_s2j7 of ww7_s2jc { __DEFAULT -> GHC.Types.I# ww7_s2jc }
+         Tmpl= \ (w_s2jX [Occ=Once!] :: T2) ->
+                 case w_s2jX of { MkT2 ww1_s2k0 [Occ=Once!] ww2_s2k5 [Occ=Once!] ->
+                 case ww1_s2k0 of { GHC.Types.I# ww4_s2k3 [Occ=Once] ->
+                 case ww2_s2k5 of { GHC.Types.I# ww6_s2k8 [Occ=Once] ->
+                 case Foo.$wf2 ww4_s2k3 ww6_s2k8 of ww7_s2kd { __DEFAULT -> GHC.Types.I# ww7_s2kd }
                  }
                  }
                  }}]
 f2
-  = \ (w_s2iW :: T2) ->
-      case w_s2iW of { MkT2 ww1_s2iZ ww2_s2j4 ->
-      case ww1_s2iZ of { GHC.Types.I# ww4_s2lY ->
-      case ww2_s2j4 of { GHC.Types.I# ww6_s2j7 -> case Foo.$wf2 ww4_s2lY ww6_s2j7 of ww7_s2jc { __DEFAULT -> GHC.Types.I# ww7_s2jc } }
+  = \ (w_s2jX :: T2) ->
+      case w_s2jX of { MkT2 ww1_s2k0 ww2_s2k5 ->
+      case ww1_s2k0 of { GHC.Types.I# ww4_s2mZ ->
+      case ww2_s2k5 of { GHC.Types.I# ww6_s2k8 -> case Foo.$wf2 ww4_s2mZ ww6_s2k8 of ww7_s2kd { __DEFAULT -> GHC.Types.I# ww7_s2kd } }
       }
       }
 
 Rec {
 -- RHS size: {terms: 15, types: 4, coercions: 0, joins: 0/0}
-Foo.$wh [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> Bool
-[GblId, Arity=2, Caf=NoCafRefs, Str=<S,1*U><S,U>]
+Foo.$wh [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> Bool
+[GblId, Arity=2, Caf=NoCafRefs, Str=<S,1*U><S,U>, Unf=OtherCon []]
 Foo.$wh
-  = \ (ww_s2ji :: GHC.Prim.Int#) (ww1_s2jm :: GHC.Prim.Int#) ->
-      case ww_s2ji of ds_X2fq {
-        __DEFAULT -> Foo.$wh (GHC.Prim.-# ds_X2fq 1#) ww1_s2jm;
-        0# -> GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># ww1_s2jm 0#)
+  = \ (ww_s2kj :: GHC.Prim.Int#) (ww1_s2kn :: GHC.Prim.Int#) ->
+      case ww_s2kj of ds_X2gt {
+        __DEFAULT -> Foo.$wh (GHC.Prim.-# ds_X2gt 1#) ww1_s2kn;
+        0# -> GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># ww1_s2kn 0#)
       }
 end Rec }
 
 -- RHS size: {terms: 11, types: 6, coercions: 0, joins: 0/0}
-h [InlPrag=NOUSERINLINE[0]] :: Int -> Int -> Bool
+h [InlPrag=NOUSERINLINE[2]] :: Int -> Int -> Bool
 [GblId,
  Arity=2,
  Caf=NoCafRefs,
  Str=<S(S),1*U(1*U)><S(S),1*U(U)>,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (w_s2je [Occ=Once!] :: Int) (w1_s2jf [Occ=Once!] :: Int) ->
-                 case w_s2je of { GHC.Types.I# ww1_s2ji [Occ=Once] ->
-                 case w1_s2jf of { GHC.Types.I# ww3_s2jm [Occ=Once] -> Foo.$wh ww1_s2ji ww3_s2jm }
+         Tmpl= \ (w_s2kf [Occ=Once!] :: Int) (w1_s2kg [Occ=Once!] :: Int) ->
+                 case w_s2kf of { GHC.Types.I# ww1_s2kj [Occ=Once] ->
+                 case w1_s2kg of { GHC.Types.I# ww3_s2kn [Occ=Once] -> Foo.$wh ww1_s2kj ww3_s2kn }
                  }}]
-h = \ (w_s2je :: Int) (w1_s2jf :: Int) ->
-      case w_s2je of { GHC.Types.I# ww1_s2ji -> case w1_s2jf of { GHC.Types.I# ww3_s2jm -> Foo.$wh ww1_s2ji ww3_s2jm } }
+h = \ (w_s2kf :: Int) (w1_s2kg :: Int) ->
+      case w_s2kf of { GHC.Types.I# ww1_s2kj -> case w1_s2kg of { GHC.Types.I# ww3_s2kn -> Foo.$wh ww1_s2kj ww3_s2kn } }
 
 Rec {
 -- RHS size: {terms: 12, types: 2, coercions: 0, joins: 0/0}
-Foo.$wf1 [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int#
-[GblId, Arity=1, Caf=NoCafRefs, Str=<S,U>]
+Foo.$wf1 [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int#
+[GblId, Arity=1, Caf=NoCafRefs, Str=<S,U>, Unf=OtherCon []]
 Foo.$wf1
-  = \ (ww_s2js :: GHC.Prim.Int#) ->
-      case Foo.$wh ww_s2js ww_s2js of {
-        False -> Foo.$wf1 (GHC.Prim.-# ww_s2js 1#);
-        True -> ww_s2js
+  = \ (ww_s2kt :: GHC.Prim.Int#) ->
+      case Foo.$wh ww_s2kt ww_s2kt of {
+        False -> Foo.$wf1 (GHC.Prim.-# ww_s2kt 1#);
+        True -> ww_s2kt
       }
 end Rec }
 
 -- RHS size: {terms: 10, types: 4, coercions: 0, joins: 0/0}
-f1 [InlPrag=NOUSERINLINE[0]] :: Int -> Int
+f1 [InlPrag=NOUSERINLINE[2]] :: Int -> Int
 [GblId,
  Arity=1,
  Caf=NoCafRefs,
  Str=<S(S),1*U(U)>m,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (w_s2jp [Occ=Once!] :: Int) ->
-                 case w_s2jp of { GHC.Types.I# ww1_s2js [Occ=Once] -> case Foo.$wf1 ww1_s2js of ww2_s2jw { __DEFAULT -> GHC.Types.I# ww2_s2jw } }}]
+         Tmpl= \ (w_s2kq [Occ=Once!] :: Int) ->
+                 case w_s2kq of { GHC.Types.I# ww1_s2kt [Occ=Once] -> case Foo.$wf1 ww1_s2kt of ww2_s2kx { __DEFAULT -> GHC.Types.I# ww2_s2kx } }}]
 f1
-  = \ (w_s2jp :: Int) ->
-      case w_s2jp of { GHC.Types.I# ww1_s2js -> case Foo.$wf1 ww1_s2js of ww2_s2jw { __DEFAULT -> GHC.Types.I# ww2_s2jw } }
+  = \ (w_s2kq :: Int) ->
+      case w_s2kq of { GHC.Types.I# ww1_s2kt -> case Foo.$wf1 ww1_s2kt of ww2_s2kx { __DEFAULT -> GHC.Types.I# ww2_s2kx } }
 
 Rec {
 -- RHS size: {terms: 14, types: 3, coercions: 0, joins: 0/0}
-Foo.$wf3 [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
-[GblId, Arity=2, Caf=NoCafRefs, Str=<S,U><S,U>]
+Foo.$wf3 [InlPrag=NOUSERINLINE[2], Occ=LoopBreaker] :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
+[GblId, Arity=2, Caf=NoCafRefs, Str=<S,U><S,U>, Unf=OtherCon []]
 Foo.$wf3
-  = \ (ww_s2jE :: GHC.Prim.Int#) (ww1_s2jJ :: GHC.Prim.Int#) ->
-      case Foo.$wh ww_s2jE ww1_s2jJ of {
-        False -> ww_s2jE;
-        True -> Foo.$wf3 ww_s2jE (GHC.Prim.-# ww1_s2jJ 1#)
+  = \ (ww_s2kF :: GHC.Prim.Int#) (ww1_s2kK :: GHC.Prim.Int#) ->
+      case Foo.$wh ww_s2kF ww1_s2kK of {
+        False -> ww_s2kF;
+        True -> Foo.$wf3 ww_s2kF (GHC.Prim.-# ww1_s2kK 1#)
       }
 end Rec }
 
 -- RHS size: {terms: 17, types: 9, coercions: 0, joins: 0/0}
-f3 [InlPrag=NOUSERINLINE[0]] :: T3 -> Int
+f3 [InlPrag=NOUSERINLINE[2]] :: T3 -> Int
 [GblId,
  Arity=1,
  Caf=NoCafRefs,
  Str=<S(S(S)S(S)),1*U(1*U(U),1*U(U))>m,
  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True,
          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (w_s2jy [Occ=Once!] :: T3) ->
-                 case w_s2jy of { MkT3 ww1_s2jB [Occ=Once!] ww2_s2jG [Occ=Once!] ->
-                 case ww1_s2jB of { GHC.Types.I# ww4_s2jE [Occ=Once] ->
-                 case ww2_s2jG of { GHC.Types.I# ww6_s2jJ [Occ=Once] ->
-                 case Foo.$wf3 ww4_s2jE ww6_s2jJ of ww7_s2jO { __DEFAULT -> GHC.Types.I# ww7_s2jO }
+         Tmpl= \ (w_s2kz [Occ=Once!] :: T3) ->
+                 case w_s2kz of { MkT3 ww1_s2kC [Occ=Once!] ww2_s2kH [Occ=Once!] ->
+                 case ww1_s2kC of { GHC.Types.I# ww4_s2kF [Occ=Once] ->
+                 case ww2_s2kH of { GHC.Types.I# ww6_s2kK [Occ=Once] ->
+                 case Foo.$wf3 ww4_s2kF ww6_s2kK of ww7_s2kP { __DEFAULT -> GHC.Types.I# ww7_s2kP }
                  }
                  }
                  }}]
 f3
-  = \ (w_s2jy :: T3) ->
-      case w_s2jy of { MkT3 ww1_s2jB ww2_s2jG ->
-      case ww1_s2jB of { GHC.Types.I# ww4_s2jE ->
-      case ww2_s2jG of { GHC.Types.I# ww6_s2jJ -> case Foo.$wf3 ww4_s2jE ww6_s2jJ of ww7_s2jO { __DEFAULT -> GHC.Types.I# ww7_s2jO } }
+  = \ (w_s2kz :: T3) ->
+      case w_s2kz of { MkT3 ww1_s2kC ww2_s2kH ->
+      case ww1_s2kC of { GHC.Types.I# ww4_s2kF ->
+      case ww2_s2kH of { GHC.Types.I# ww6_s2kK -> case Foo.$wf3 ww4_s2kF ww6_s2kK of ww7_s2kP { __DEFAULT -> GHC.Types.I# ww7_s2kP } }
       }
       }