*                                                                      *

 ********************************************************************* -}

 -- Only works for External Names that have a Module

 lookupGlobalName name = loadGlobalName name (nameModule name)

 loadGlobalName :: forall lcl.

                -> Module  -- Use this for non-External Names (maybe Backpack-related?)

                -> IfM lcl (MaybeErr IfaceMessage TyThing)

 loadGlobalName name mod

 lookupSyntaxName std_uniq

   = do { rebind <- xoptM LangExt.RebindableSyntax

        ; if not rebind

                  ; return (nm, emptyFVs) }

          else do { nm <- lookupOccRnNone $ mkRdrUnqual $

                          knownKeyOccName std_uniq

              -> RnM (SyntaxExpr GhcRn, FreeVars) -- Possibly a non-standard

                                                  -- name

 lookupSyntax std_uniq

 {-

 Note [QualifiedDo]

 import GHC.Hs

 import GHC.Tc.Errors.Types

 import GHC.Tc.Utils.Monad

 import GHC.Rename.Bind ( rnLocalBindsAndThen, rnLocalValBindsLHS, rnLocalValBindsRHS

 import qualified Data.Foldable as Partial (maximum)

 import Data.List (unzip4)

 import Data.List.NonEmpty ( NonEmpty(..), head, init, last, nonEmpty, scanl, tail )

 import Data.Ord

 import Data.Array

 import GHC.Driver.Env (HscEnv)

             (\ _ -> return ((), emptyFVs))

       ; (pp_stmts, fvs2) <- postProcessStmtsForApplicativeDo do_or_lc stmts1

       ; return ( HsDo noExtField do_or_lc (L l pp_stmts), fvs1 `plusFV` fvs2 ) }

 -- ExplicitList: see Note [Handling overloaded and rebindable constructs]

 rnExpr (ExplicitList _ exps)

   = do  { (exps', fvs) <- rnExprs exps

 rnStmt ctxt rnBody (L loc (LastStmt _ (L lb body) noret _)) thing_inside

   = do  { (body', fv_expr) <- rnBody body

         ; (ret_op, fvs1) <- if isMonadCompContext ctxt

                             else return (noSyntaxExpr, emptyFVs)

                             -- The 'return' in a LastStmt is used only

                             -- for MonadComp; and we don't want to report

 rnStmt ctxt rnBody (L loc (BodyStmt _ (L lb body) _ _)) thing_inside

   = do  { (body', fv_expr) <- rnBody body

         ; (guard_op, fvs2) <- if isComprehensionContext ctxt

                               else return (noSyntaxExpr, emptyFVs)

                               -- Only list/monad comprehensions use 'guard'

                               -- Also for sub-stmts of same eg [ e | x<-xs, gd | blah ]

                  , fvs `plusFV` fvs1 `plusFV` fvs2 `plusFV` fvs3) } }

 rnStmt ctxt _ (L loc (ParStmt _ segs _ _)) thing_inside

         ; ((segs', thing), fvs4) <- rnParallelStmts (ParStmtCtxt ctxt) return_op segs thing_inside

         ; return (([(L loc (ParStmt noExtField segs' mzip_op bind_op), fvs4)], thing)

                  , fvs1 `plusFV` fvs2 `plusFV` fvs3 `plusFV` fvs4) }

                    ; return ((by', used_bndrs, thing), fvs) }

        -- Lookup `return`, `(>>=)` and `liftM` for monad comprehensions

        ; (fmap_op,   fvs5) <- case form of

                                 ThenForm -> return (noExpr, emptyFVs)

        ; let all_fvs  = fvs1 `plusFV` fvs2 `plusFV` fvs3

                              `plusFV` fvs4 `plusFV` fvs5

     dupErr vs = addErr $ TcRnListComprehensionDuplicateBinding (NE.head vs)

 lookupQualifiedDoStmtName ctxt n

   | otherwise

 -- | Is this a context where we respect RebindableSyntax?

 -- but ListComp are never rebindable

 rebindableContext :: HsStmtContextRn -> Bool

 rebindableContext ctxt = case ctxt of

   HsDoStmt flavour -> rebindableDoStmtContext flavour

 rebindableDoStmtContext :: HsDoFlavour -> Bool

 rebindableDoStmtContext flavour = case flavour of

   GhciStmtCtxt -> True   -- I suppose?

 {-

   -> RnM ([ExprLStmt GhcRn], FreeVars)

 mkApplicativeStmt ctxt args need_join body_stmts

   = do { (fmap_op, fvs1) <- lookupQualifiedDoStmtName (HsDoStmt ctxt) fmapClassOpKey

        ; (mb_join, fvs3) <-

            if need_join then

              do { (join_op, fvs) <- lookupQualifiedDoStmtName (HsDoStmt ctxt) joinMIdKey

 import GHC.Tc.Errors.Types

 import GHC.Tc.Errors.Ppr ( pprHsDocContext )

 import GHC.Tc.Utils.Monad

 import GHC.Types.Name.Reader

 import GHC.Types.Hint ( UntickedPromotedThing(..) )

 lookupFixityOp (NormalOp n)  = lookupFixityRn (getName n)

 lookupFixityOp (UnboundOp u) = lookupFixityRn (mkUnboundName (occName u))

 lookupFixityOp (RecFldOp f)  = lookupFieldFixityRn f

                                   ; lookupFixityRn nm }

 -- Precedence-related error messages

 import GHC.Data.FastString ( uniqCompareFS )

 import GHC.Data.List.SetOps( removeDups )

 import GHC.Utils.Misc

 import GHC.Utils.Panic.Plain

 import GHC.Types.SrcLoc

 gen_Eq_binds :: SrcSpan -> DerivInstTys -> TcM (LHsBinds GhcPs, Bag AuxBindSpec)

 gen_Eq_binds loc dit@(DerivInstTys{ dit_rep_tc = tycon

                                   , dit_rep_tc_args = tycon_args }) = do

        ; return ([mk_eq_bind eq_RDR], emptyBag) }

   where

     all_cons = getPossibleDataCons tycon tycon_args

     -- See Note [Auxiliary binders]

     tag2con_RDR <- new_tag2con_rdr_name loc tycon

     maxtag_RDR  <- new_maxtag_rdr_name  loc tycon

     return ( method_binds eq_RDR tag2con_RDR maxtag_RDR

            , aux_binds    tag2con_RDR maxtag_RDR )

         ; uniq <- newUnique

         ; let loc' = noAnnSrcSpan $ locA loc

         ; interPrintName <- getInteractivePrintName

         ; let fresh_it  = itName uniq (locA loc)

               matches   = [mkMatch (mkPrefixFunRhs (L loc' fresh_it) noAnn) (noLocA []) rn_expr

                                    emptyLocalBinds]

        ; opt_pr_flag <- goptM Opt_PrintBindResult

        ; ghciStep   <- getGhciStepIO

        ; let gi_stmt | (L loc (BindStmt x pat expr)) <- rn_stmt

                      = L loc $ BindStmt x pat (nlHsApp ghciStep expr)

                      | otherwise

         failIllegalTyCon, failIllegalTyVar,

         tcLookupKnownKeyGlobal, tcLookupKnownKeyTyCon, tcLookupKnownKeyClass,

         -- Local environment

         tcExtendKindEnv, tcExtendKindEnvList,

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

 -}

 tcLookupKnownKeyGlobal :: HasDebugCallStack => KnownKeyNameKey -> TcM TyThing

 tcLookupKnownKeyGlobal uniq

        ; case mb_thing of

            Succeeded thing -> return thing

            Failed msg      -> failWithTc (TcRnInterfaceError msg) }

 tcLookupKnownKeyClass :: HasDebugCallStack => KnownKeyNameKey -> TcM Class

 tcLookupKnownKeyClass uniq

   = do { thing <- tcLookupKnownKeyGlobal uniq

            AnId id -> return id

            _  -> wrongThingErr WrongThingClass (AGlobal thing) (getName thing) }

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

 *                                                                      *

               -- When we are instantiating a signature,

               -- we DEFINITELY do not want to knot tie.

               is_instantiate = fromMaybe False (isHomeUnitInstantiating <$> mhome_unit)

         ; setEnvs (if_env, ()) thing_inside }

 -- | 'initIfaceLoad' can be used when there's no chance that the action will

   | PatGuard (HsMatchContext fn)      -- ^ Pattern guard for specified thing

   | ParStmtCtxt (HsStmtContext fn)    -- ^ A branch of a parallel stmt

   | TransStmtCtxt (HsStmtContext fn)  -- ^ A branch of a transform stmt

 -- | Haskell arrow match context.

 data HsArrowMatchContext

 -- | @since base-2.01

 instance Monad []  where

     {-# INLINE (>>=) #-}

     {-# INLINE (>>) #-}

     (>>) = (*>)

 import GHC.Internal.Bignum.Primitives

 import GHC.Internal.Prim

 import GHC.Internal.Types

 -- See W1 of Note [Tracking dependencies on primitives] in GHC.Internal.Base

 -- (This module uses the empty tuple () and string literals.)

 integerPowMod# :: Integer -> Integer -> Natural -> (# Natural | () #)

 integerPowMod# !b !e !m

    | integerIsZero b

      -- when the exponent is negative, try to find the modular multiplicative

      -- inverse and use it instead

    | integerIsNegative e = case integerRecipMod# b m of

 -- For why this file exists

 -- See Note [Semigroup stimes cycle] in GHC.Internal.Base

 infixl 7  *

 infixl 6  +, -

     fromInteger         :: Integer -> a

     x - y               = x + negate y

 import GHC.Internal.Classes (Ord)

 import GHC.Internal.Bignum.Integer (Integer)

 import {-# SOURCE #-} GHC.Internal.Enum (Enum)

 data Ratio a

     which imports ‘GHC.Base‘ (libraries/base/GHC/Base.hs)

 -}

 import GHC.Internal.Types (Char, Int)

 default ()

 {-# LANGUAGE Trustworthy #-}

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

 -- |

 -- Module      :  GHC.Internal.Tuple

 ) where

 -- See W1 of Note [Tracking dependencies on primitives] in GHC.Internal.Base

 default () -- Double and Integer aren't available yet

      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2,l2)

 maxTupleSize :: Int