-- Recursive let. See Note [Recursion and fixpointing]

 callArityBind boring_vars ae_body int b@(Rec binds)

     (final_ae, Rec binds')

   where

     -- See Note [Taking boring variables into account]

     fix :: [(Id, Maybe (Bool, Arity, CallArityRes), CoreExpr)] -> (CallArityRes, [(Id, CoreExpr)])

     fix ann_binds

           any_change

         = fix ann_binds'

         | otherwise

                           | safe_arity == 0 = ae_rhs -- If it is not a function, its body is evaluated only once

                           | otherwise       = calledMultipleTimes ae_rhs

               in (True, (i', Just (called_once, new_arity, ae_rhs'), rhs'))

           where

 import GHC.Types.Var.Set

 import GHC.Types.Var.Env

 import GHC.Utils.Misc

 import GHC.Data.Pair

 import Data.Semigroup

 TL;DR: check this regularly!

 -}

 {-# INLINE runTyCoVars #-}

 {- *********************************************************************

 *                                                                      *

 tyCoVarsOfCos :: [Coercion] -> TyCoVarSet

 tyCoVarsOfCos cos = runTyCoVars (deep_cos cos)

 (deep_ty, deep_tys, deep_co, deep_cos) = foldTyCo deepTcvFolder emptyVarSet

 deepTcvFolder = TyCoFolder { tcf_view = noView  -- See Note [Free vars and synonyms]

                            , tcf_tyvar = do_tcv, tcf_covar = do_tcv

                            , tcf_hole  = do_hole, tcf_tycobinder = do_bndr }

   where

       where

         do_it acc | v `elemVarSet` is  = acc

                   | v `elemVarSet` acc = acc

                                          acc `extendVarSet` v

     do_bndr is tcv _ = extendVarSet is tcv

 {- *********************************************************************

 *                                                                      *

   -- It's OK to use nonDetEltsUFM here because we immediately

   -- forget the ordering by returning a set

 (shallow_ty, shallow_tys, shallow_co, shallow_cos) = foldTyCo shallowTcvFolder emptyVarSet

 shallowTcvFolder = TyCoFolder { tcf_view = noView  -- See Note [Free vars and synonyms]

                               , tcf_tyvar = do_tcv, tcf_covar = do_tcv

                               , tcf_hole  = do_hole, tcf_tycobinder = do_bndr }

   where

       where

         do_it acc | v `elemVarSet` is  = acc

                   | v `elemVarSet` acc = acc

 coVarsOfCo    co  = runTyCoVars (deep_cv_co co)

 coVarsOfCos   cos = runTyCoVars (deep_cv_cos cos)

 (deep_cv_ty, deep_cv_tys, deep_cv_co, deep_cv_cos) = foldTyCo deepCoVarFolder emptyVarSet

 deepCoVarFolder = TyCoFolder { tcf_view = noView

                              , tcf_tyvar = do_tyvar, tcf_covar = do_covar

                              , tcf_hole  = do_hole, tcf_tycobinder = do_bndr }

       -- the tyvar won't end up in the accumulator, so

       -- we'd look repeatedly.  Blargh.

       where

         do_it acc | v `elemVarSet` is  = acc

                   | v `elemVarSet` acc = acc

                                          acc `extendVarSet` v

 ------- Same again, but for DCoVarSet ----------

 --    But this time the free vars are shallow

 -- add the deep free variables of its kind

 closeOverKinds vs = nonDetStrictFoldVarSet do_one vs vs

   where

 {- --------------- Alternative version 1 (using FV) ------------

 closeOverKinds = fvVarSet . closeOverKindsFV . nonDetEltsUniqSet

   = (tyCoFVsOfCo co1 `unionFV` tyCoFVsOfCo co2 `unionFV` tyCoFVsOfCo w) fv_cand in_scope acc

 tyCoFVsOfCo (CoVarCo v) fv_cand in_scope acc

   = tyCoFVsOfCoVar v fv_cand in_scope acc

 tyCoFVsOfCo (AxiomCo _ cs)    fv_cand in_scope acc = tyCoFVsOfCos cs  fv_cand in_scope acc

 tyCoFVsOfCo (UnivCo { uco_lty = t1, uco_rty = t2, uco_deps = deps}) fv_cand in_scope acc

   = (tyCoFVsOfCos deps `unionFV` tyCoFVsOfType t1

 Note [CoercionHoles and coercion free variables]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

         forall k. [W] co1 :: t1 ~# t2 |> co2

                   [W] co2 :: k ~# *

 Note [CoercionHoles and CoHoleSets]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                    ; traceTcS "Trying to solve the implication" (ppr s1 $$ ppr s2 $$ ppr wanteds)

                    -- Solve the `wanteds` in a nested context

                    ; residual_wanted <- nestImplicTcS skol_info_anon ev_binds_var tclvl $

                                         solveSimpleWanteds wanteds

                    ; return (all_co, isSolvedWC residual_wanted) }

       -- Kick out any inerts constraints that mention unified type variables

       ; kickOutAfterUnification unifs

       ; if solved

                      -- emptyCoHoleSet: fully solved, so all_co has no holes

                 ; stopWith ev "Polytype equality: solved" }

 --    [W] t1 ~# t2

 -- and a Given quantified contraint like (forall a b. blah => a ~ b)

 -- Why?  See Note [Looking up primitive equalities in quantified constraints]

 lookup_eq_in_qcis (CtGiven {}) _ _ _

   = nopStage ()

   where

     hole = case dest of

              HoleDest hole -> hole   -- Equality constraints have HoleDest

     try :: SwapFlag -> SolverStage ()

        | Just (cls, tys) <- unSwap swap (boxEqPred eq_rel) lhs rhs

        = Stage $

          do { let cls_pred = mkClassPred cls tys

                 OneInst {}

                   -> do { dict_ev <- newWantedEvVarNC loc emptyCoHoleSet cls_pred

                         ; chooseInstance dict_ev res

                         ; setEvBind (mkWantedEvBind co_var EvCanonical (mk_sc_sel cls tys dict_ev))

                         ; fillCoercionHole hole emptyCoHoleSet $

                           maybeSymCo swap (mkCoVarCo co_var)

       --  so that we can report unused given constraints,

       --  in GHC.Tc.Solver.neededEvVars

       -- See Note [Tracking redundant constraints] in GHC.Tc.Solver

     }

   | CoEvBindsVar {  -- See Note [Coercion evidence only]

 import GHC.Builtin.Types ( coercibleClass, eqClass, heqClass, unitTyConKey

                          , listTyCon, constraintKind )

 import GHC.Types.Basic

 import GHC.Data.Maybe

 import GHC.Data.List.SetOps ( getNth, findDupsEq )

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 exactTyCoVarsOfType  ty  = runTyCoVars (exact_ty ty)

 exactTyCoVarsOfTypes tys = runTyCoVars (exact_tys tys)

 (exact_ty, exact_tys, _, _) = foldTyCo exactTcvFolder emptyVarSet

 exactTcvFolder = deepTcvFolder { tcf_view = coreView }

                  -- This is the key line

 newtype UniqDSMT m result = UDSMT' (DUniqSupply -> m (result, DUniqSupply))

   deriving (Functor)

 -- Using the one-shot trick is necessary for performance.

 -- Using transfomer's strict `StateT` regressed some performance tests in 1-2%.

 -- The one-shot trick here fixes those regressions.

         GHC.Utils.Containers.Internal.BitUtil

         GHC.Utils.Containers.Internal.StrictPair

         GHC.Utils.Error

         GHC.Utils.Exception

         GHC.Utils.Fingerprint

         GHC.Utils.FV