JoinPoint n  -> parens (int n)

   ppr (ContEx _se e mco)

         -- where

         -- fvs = exprFreeVars e

         -- filter_env env = filterVarEnv_Directly keep env

 import GHC.Core.FamInstEnv      ( FamInstEnv, topNormaliseType_maybe )

 import GHC.Core.DataCon

 import GHC.Core.Opt.Stats ( Tick(..) )

 import GHC.Core.Unfold

 import GHC.Core.Unfold.Make

 import GHC.Core.Utils

       ApplyToVal { sc_arg = arg_clo, sc_cont = cont, sc_hole_ty = fun_ty }

         -- See Note [Avoid redundant simplification]

               ; rebuild_go env (App expr arg') cont }

 completeBindX :: SimplEnv

         --         co1 :: t1 ~ s1

         --         co2 :: s2 ~ t2

         addCoerce co co_is_opt cont@(ApplyToVal { sc_arg = arg_clo

           | not co_is_opt  -- pushCoValArg duplicates the coercion, so optimise first

           = addCoerce (optOutCoercion (zapSubstEnv env) co co_is_opt) True cont

                                        -- See Note [Optimising reflexivity]

           | otherwise = return (CastIt { sc_co = co, sc_opt = co_is_opt, sc_cont = cont })

 {-

 ************************************************************************

 -- Value beta-reduction

 -- This works for /coercion/ lambdas too

 simpl_lam env bndr body (ApplyToVal { sc_arg = arg_clo

   = do { tick (BetaReduction bndr)

        ; let from_what = FromBeta arg_levity

              arg_levity

              --      But fun_ty is an OutType, so is fully substituted

        ; if | Just env' <- preInlineBetaUnconditionally env arg_levity bndr arg_clo

                     tick (PreInlineUnconditionally bndr)

                   ; simplLam env' body cont }

     is_strict_bind

   = -- Evaluate RHS strictly

     simplExprF (rhs_se `setInScopeFromE` env) rhs

                            , sc_env = env, sc_cont = cont, sc_dup = NoDup })

   | otherwise  -- Evaluate RHS lazily

 --------------------

              -> SimplCont -> SimplCont

 -- Drop outer context from join point invocation (jump)

 -- See Note [Join points and case-of-case]

   = cont -- Not a jump

   = trim arity cont

   where

     trim 0 cont@(Stop {})

     trim n cont@(ApplyToTy { sc_cont = k })

       = cont { sc_cont = trim (n-1) k } -- join arity counts types!

     trim _ cont

 {- Note [Join points and case-of-case]

 simplInId env var cont

   | Just dc <- isDataConWorkId_maybe var

   , isLazyDataConRep dc                    -- See Note [Fast path for lazy data constructors]

   | otherwise

         -- Don't trimJoinCont; we haven't already simplified e,

         -- so the cont is not embodied in e

       DoneId out_id -> simplOutId zapped_env out_id $

       DoneEx e mb_join -> simplExprF zapped_env e $

   where

     zapped_env =  zapSubstEnv env  -- See Note [zapSubstEnv]

 ---------------------------------------------------------

 simplOutId :: SimplEnvIS -> OutId -> SimplCont -> SimplM (SimplFloats, OutExpr)

                , sc_hole_ty = fun_ty } <- cont2

   -- Do this even if (contIsStop cont), or if seCaseCase is off.

   -- See Note [No eta-expansion in runRW#]

              -- hole_ty is the type of the current runRW# application

              (outer_cont, new_runrw_res_ty, inner_cont)

                 | seCaseCase env = (mkBoringStop overall_res_ty, overall_res_ty, cont3)

        --    * If we don't do this we get a beta-redex every time, so the

        --      simplifier keeps doing more iterations.

        --    * Even more important: see Note [No eta-expansion in runRW#]

                             -- Important: do not try to eta-expand this lambda

                             -- See Note [No eta-expansion in runRW#]

            _ -> do { s' <- newId (fsLit "s") ManyTy realWorldStatePrimTy

                                             , sc_cont = inner_cont

                                 -- cont' applies to s', then K

        ; let rr'   = getRuntimeRep new_runrw_res_ty

              call' = mkApps (Var fun) [mkTyArg rr', mkTyArg new_runrw_res_ty, arg']

        ; rebuild env call' outer_cont }

 -- Normal case for (f e1 .. en)

 simplOutId env fun cont

 ---------- Simplify value arguments --------------------

 rebuildCall env fun_info

   = case arg_clo of      -- See Note [Avoid redundant simplification]

       DoneId v     -> rebuildCall env (addValArgTo fun_info (Var v) fun_ty) cont

       DoneEx arg _ -> rebuildCall env (addValArgTo fun_info arg     fun_ty) cont

         , seCaseCase env    -- Only when case-of-case is on. See GHC.Driver.Config.Core.Opt.Simplify

                             --    Note [Case-of-case and full laziness]

         -> simplExprF (arg_se `setInScopeFromE` env) in_arg

                 StrictArg { sc_fun = fun_info, sc_fun_ty = fun_ty

                           , sc_dup = NoDup, sc_cont = cont })

                 -- Note [Shadowing in the Simplifier]

         -- There is no benefit (unlike in a let-binding), and we'd

         -- have to be very careful about bogus strictness through

         -- floating a demanded let.

               ; rebuildCall env (addValArgTo fun_info  arg' fun_ty) cont }

 ---------- No further useful info, revert to generic rebuild ------------

 rebuildCall env (ArgInfo { ai_fun = fun, ai_args = rev_args, ai_rules = rules }) cont

         --, text "Rule activation:" <+> ppr (ruleActivation rule)

           , text "Full arity:" <+>  ppr (ruleArity rule)

           , text "Before:" <+> hang (ppr fn) 2 (sep (map ppr args))

       | logHasDumpFlag logger Opt_D_dump_rule_firings

       = log_rule Opt_D_dump_rule_firings "Rule fired:" $

                                     , sc_arg_ty = arg_ty, sc_hole_ty = hole_ty }) }

 mkDupableContWithDmds env dmds

   =     -- e.g.         [...hole...] (...arg...)

         --      ==>

         --              let a = ...arg...

     do  { let dmd:|cont_dmds = expectNonEmpty dmds

         ; (floats1, cont') <- mkDupableContWithDmds env cont_dmds cont

         ; let env' = env `setInScopeFromF` floats1

         ; (let_floats2, arg'') <- makeTrivial env NotTopLevel dmd (fsLit "karg") arg'

         ; let all_floats = floats1 `addLetFloats` let_floats2

         ; return ( all_floats

         -- The continuation type

         SimplCont(..), DupFlag(..), FromWhat(..), StaticEnv,

         contIsDupable, contResultType, contHoleType, contHoleScaling,

         contIsTrivial, contArgs, contIsRhs,

         countArgs, contOutArgs, dropContArgs,

         mkBoringStop, mkRhsStop, mkLazyArgStop,

         -- ArgInfo

         ArgInfo(..), ArgSpec(..), mkArgInfo,

   where

     arg_sd = subDemandIfEvaluated (Partial.head (ai_dmds fun_info))

 -------------------

 contIsRhs :: SimplCont -> Maybe RecFlag

 contIsRhs (Stop _ (RhsCtxt is_rec) _) = Just is_rec