&& logHasDumpFlag logger Opt_D_dump_simpl_stats) $

           logDumpMsg logger

                   "Simplifier statistics for following pass"

                                               <+> text "iterations",

                          blankLine,

                          pprSimplCount counts_out])

                 ; read_rule_env = updExternalPackageRules base_rule_env <$> read_eps_rules

                 ; fam_envs = (eps_fam_inst_env eps, fam_inst_env)

                 -- Simplify the program

            ((binds1, rules1), counts1) <-

 -- See Note [The environments of the Simplify pass]

 data SimplMode = SimplMode -- See comments in GHC.Core.Opt.Simplify.Monad

   , sm_do_eta_reduction :: !Bool

   }

 instance Outputable SimplMode where

     ppr (SimplMode { sm_phase = p , sm_names = ss

                    , sm_cast_swizzle = cs

                    , sm_eta_expand = eta, sm_case_case = cc })

        = text "SimplMode" <+> braces (

          sep [ text "Phase =" <+> ppr p <+>

                brackets (text (concat $ intersperse "," ss)) <> comma

              , pp_flag i   (text "inline") <> comma

              , pp_flag r   (text "rules") <> comma

              , pp_flag eta (text "eta-expand") <> comma

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

 simplOutId env fun cont

        ; let rules_for_me = getRules rule_base fun

              out_args     = contOutArgs env cont :: [OutExpr]

        ; mb_match <- if not (null rules_for_me) &&

                         (isClassOpId fun || activeUnfolding (seMode env) fun)

                      then tryRules env rules_for_me fun out_args

     -- Try inlining

     do { logger <- getLogger

        ; case mb_inline of{

             Nothing ->

     -- Neither worked, so just rebuild

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

 --      Dealing with a call site

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

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

   = do { let args = reverse rev_args

            Just (rule_arity, rhs) -> simplExprF env rhs $

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

        ; return (Just expr) }

   | otherwise

   = return Nothing

   where

     interesting_cont = interestingCallContext env call_cont

     log_inlining doc

     dump_inline unfolding cont

       | not (logHasDumpFlag logger Opt_D_dump_inlinings) = return ()

       | not (logHasDumpFlag logger Opt_D_verbose_core2core)

             log_inlining $

       | otherwise

       = log_inlining $

                 nest 4 (vcat [text "Inlined fn: " <+> nest 2 (ppr unfolding),

                               text "Cont:  " <+> ppr cont])]

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

         isSimplified, contIsStop,

         contIsDupable, contResultType, contHoleType, contHoleScaling,

         countArgs, contOutArgs, dropContArgs,

         mkBoringStop, mkRhsStop, mkLazyArgStop,

         interestingCallContext,

     lone _               = True

     go args (ApplyToVal { sc_arg = arg, sc_env = se, sc_cont = k })

     go args (ApplyToTy { sc_cont = k }) = go args k

     go args (CastIt { sc_cont = k })    = go args k

     go args k                           = (False, reverse args, k)

 contOutArgs :: SimplEnv -> SimplCont -> [OutExpr]

 -- Get the leading arguments from the `SimplCont`, as /OutExprs/

 contOutArgs env cont

       -- Why NonRecursive?  Becuase it's a bit like

       --   let a = g x in f a

 interestingCallContext :: SimplEnv -> SimplCont -> CallCtxt

 -- See Note [Interesting call context]

 interestingCallContext env cont

   b) we say that a con-like argument (eg (df d)) is interesting

 -}

 -- See Note [Interesting arguments]

   where

     -- n is # value args to which the expression is applied

     go env n (Var v)

            DoneId v'            -> go_var n v'

            DoneEx e _           -> go (zapSubstEnv env)             n e

            ContEx tvs cvs ids e -> go (setSubstEnv env tvs cvs ids) n e

     go _   _ (Lit l)

        | isLitRubbish l        = TrivArg -- Leads to unproductive inlining in WWRec, #20035

     one_occ IAmDead = True -- Happens in ((\x.1) v)

     one_occ OneOcc{ occ_n_br    = 1

     one_occ OneOcc{ occ_n_br   = 1

                   , occ_in_lam = IsInsideLam

                   , occ_int_cxt = IsInteresting }

 initSimplMode dflags phase name = SimplMode

   { sm_names = [name]

   , sm_phase = phase

   , sm_rules = gopt Opt_EnableRewriteRules dflags

   , sm_eta_expand = gopt Opt_DoLambdaEtaExpansion dflags

   , sm_cast_swizzle = True