assertPpr (arity <= 0x3f) (ppr arity) $

               -- 0x3f since we only have 6 bits to encode the

               -- alternative

 -- | Inverse of 'mkSumTyConUnique'

 isSumTyConUnique :: Unique -> Maybe Arity

   | alt >= arity

   = panic ("mkSumDataConUnique: " ++ show alt ++ " >= " ++ show arity)

   | otherwise

 getUnboxedSumName :: Int -> Name

 getUnboxedSumName n

 -}

 mkCTupleTyConUnique :: Arity -> Unique

 mkCTupleDataConUnique :: Arity -> Unique

 mkCTupleSelIdUnique :: ConTagZ -> Arity -> Unique

 mkCTupleSelIdUnique sc_pos arity

   | sc_pos >= arity

   = panic ("mkCTupleSelIdUnique: " ++ show sc_pos ++ " >= " ++ show arity)

   | otherwise

 -- | Inverse of 'mkCTupleTyConUnique'

 isCTupleTyConUnique :: Unique -> Maybe Arity

 -- Normal tuples

 mkTupleDataConUnique :: Boxity -> Arity -> Unique

 mkTupleTyConUnique :: Boxity -> Arity -> Unique

 -- | Inverse of 'mkTupleTyConUnique'

 isTupleTyConUnique :: Unique -> Maybe (Boxity, Arity)

 mkPrimOpWrapperUnique  :: Int -> Unique

 mkPreludeMiscIdUnique  :: Int -> Unique

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

 mkPseudoUniqueE, mkBuiltinUnique :: Int -> Unique

 mkRegSingleUnique, mkRegPairUnique, mkRegSubUnique, mkRegClassUnique :: Int -> Unique

 mkCostCentreUnique :: Int -> Unique

 varNSUnique, dataNSUnique, tvNSUnique, tcNSUnique :: Unique

 mkFldNSUnique :: FastString -> Unique

 isFldNSUnique :: Unique -> Bool

 isFldNSUnique uniq = case unpkUnique uniq of

   (tag, _) -> tag == 'f'

 initExitJoinUnique :: Unique

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

 -- Wired-in type constructor keys occupy *two* slots:

 -- See Note [Related uniques for wired-in things]

 mkPreludeTyConUnique   :: Int -> Unique

 tyConRepNameUnique :: Unique -> Unique

 tyConRepNameUnique  u = incrUnique u

 -- See Note [Related uniques for wired-in things]

 mkPreludeDataConUnique :: Int -> Unique

 dataConTyRepNameUnique, dataConWorkerUnique :: Unique -> Unique

 dataConWorkerUnique  u = incrUnique u

 -- A little delicate!

 mkBoxingTyConUnique :: Int -> Unique

 boxingDataConUnique :: Unique -> Unique

 boxingDataConUnique u = stepUnique u 2

              -- TODO(#25273): Use the deterministic UniqDSM (ie `runUniqueDSM`) instead

              -- of UniqSM (see `initUs_`) to guarantee deterministic objects

              -- when doing thread sanitization.

             return $ initUs_ us $

               annotateTSAN platform g

           else return g

         cr_name_ppr_ctx        :: NamePprCtx,

         cr_loc                 :: SrcSpan,   -- Use this for log/error messages so they

                                              -- are at least tagged with the right source file

 }

 -- Note: CoreWriter used to be defined with data, rather than newtype.  If it

 runCoreM :: HscEnv

          -> RuleBase

          -> Module

          -> NamePprCtx

          -> SrcSpan

 addSimplCount :: SimplCount -> CoreM ()

 addSimplCount count = write (CoreWriter { cw_simpl_count = count })

 getUniqTag = read cr_uniq_tag

 -- Convenience accessors for useful fields of HscEnv

 import GHC.Types.Demand ( zapDmdEnvSig )

 import GHC.Types.Name.Ppr

 import GHC.Types.Var ( Var )

 import Control.Monad

 import qualified GHC.LanguageExtensions as LangExt

                                 , mg_rdr_env = rdr_env })

   = do { hpt_rule_base <- home_pkg_rules

        ; let builtin_passes = getCoreToDo dflags hpt_rule_base extra_vars

        ; (guts2, stats) <- runCoreM hsc_env hpt_rule_base uniq_tag mod

                                     name_ppr_ctx loc $

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

 -}

 instance MonadUnique SimplM where

 instance HasLogger SimplM where

     getLogger = gets st_logger

                (\a -> a `seqList` ()) $ do

     let initialCorePrepEnv = mkInitialCorePrepEnv cp_cfg

     let implicit_binds = mkDataConWorkers

           (cpPgm_generateDebugInfo pgm_cfg)

 corePrepExpr :: Logger -> CorePrepConfig -> CoreExpr -> IO CoreExpr

 corePrepExpr logger config expr = do

     withTiming logger (text "CorePrep [expr]") (\e -> e `seq` ()) $ do

       let initialCorePrepEnv = mkInitialCorePrepEnv config

       let new_expr = initUs_ us (cpeBodyNF initialCorePrepEnv expr)

       putDumpFileMaybe logger Opt_D_dump_prep "CorePrep" FormatCore (ppr new_expr)

 import GHC.Types.Name.Reader

 import GHC.Types.Name.Ppr

 import GHC.Types.TyThing

 import GHC.Types.Unique.Set

 import GHC.Utils.Fingerprint ( Fingerprint )

   --

   -- The id has to be exported for the JS backend. This isn't required for the

   -- byte-code interpreter but it does no harm to always do it.

   let binding_name = mkSystemVarName u (fsLit ("BCO_toplevel"))

   let binding_id   = mkExportedVanillaId binding_name (exprType simpl_expr)

 runDs :: HscEnv -> (DsGblEnv, DsLclEnv) -> DsM a -> IO (Messages DsMessage, Maybe a)

 runDs hsc_env (ds_gbl, ds_lcl) thing_inside

                               (tryM thing_inside)

        ; msgs   <- readIORef (ds_msgs ds_gbl)

        ; let final_res

 import GHC.Types.Basic

 import GHC.Types.Name

 import GHC.Types.Name.Shape

 import GHC.Utils.Outputable

 import GHC.Utils.Misc

             sh_if_errs = errs_var

         }

     -- Modeled off of 'initTc'

     msgs <- readIORef errs_var

     case res of

         Left _                               -> return (Left msgs)

                                , ids    = supply

                                }

 initJSM :: IO JEnv

              return (initJSMState "js" supply)

 update_stream :: UniqSupply -> JSM ()

 getHiVirtualRegFromLo reg

  = case reg of

         -- makes a pseudo-unique with tag 'H'

         _               -> panic "Reg.getHiVirtualRegFromLo"

 getHiVRegFromLo :: Reg -> Reg

       debugTraceMsg (hsc_logger hsc_env) 1 $

           text "Warning: _result has been evaluated, some bindings have been lost"

    let tv_subst     = newTyVars us free_tvs

        (filtered_ids, occs'') = unzip         -- again, sync the occ-names

           [ (id, occ) | (id, Just _hv, occ) <- zip3 ids mb_hValues occs' ]

 import GHC.Stg.Syntax

 import GHC.Types.Basic ( CbvMark (..) )

 import GHC.Types.Demand (isDeadEndAppSig)

 import GHC.Types.RepType (dataConRuntimeRepStrictness)

 import GHC.Core (AltCon(..))

 import Data.List (mapAccumL)

     let export_tag_info = collectExportInfo stg_binds_w_tags

     -- Rewrite STG to uphold the strict field invariant

     let rewritten_binds = {-# SCC "StgEptRewrite" #-} rewriteTopBinds this_mod us_t stg_binds_w_tags :: [TgStgTopBinding]

     return (rewritten_binds,export_tag_info)

     -- -fexternal-dynamic-refs flag. See GHC.Stg.Utils.allowTopLevelConApp.

   }

   deriving (Functor, Applicative, Monad, MonadIO)

 instance MonadUnique StgM where

   getUniqueM = StgM $ do { tag <- ask

                          ; liftIO $! uniqFromTag tag}

 runStgM mask (StgM m) = runReaderT m mask

 stg2stg :: Logger

         ; stg_linter False "StgFromCore" binds

         ; showPass logger "Stg2Stg"

         -- Do the main business!

             foldM (do_stg_pass this_mod) binds (stgPipeline_phases opts)

           -- Dependency sort the program as last thing. The program needs to be

   getUniqueM = GHC.Types.Unique.Supply.getUniqueM

 initC :: IO CgState

             ; return (initCgState uniqs) }

 runC :: StgToCmmConfig -> FCodeState -> CgState -> FCode a -> (a, CgState)

 import GHC.Types.SourceFile

 import GHC.Types.SrcLoc

 import GHC.Types.Unique.FM

 import GHC.Types.Basic

 import GHC.Types.CostCentre.State

                              -- Includes all info about imported things

                              -- BangPattern is to fix leak, see #15111

         env_gbl  :: gbl,     -- Info about things defined at the top level

                              -- of the module being compiled

 -- shares a certain 'Unique'.

 mkSkolemInfo :: MonadIO m => SkolemInfoAnon -> m SkolemInfo

 mkSkolemInfo sk_anon = do

   return (SkolemInfo u sk_anon)

 getSkolemInfo :: SkolemInfo -> SkolemInfoAnon

                 tcl_errs       = errs_var

                 }

                      do { r <- tryM do_this

                         ; case r of

                           Right res -> return (Just res)

   where

     interactive_src_loc = mkRealSrcLoc (fsLit "<interactive>") 1 1

            -> HscEnv

            -> gbl -> lcl

            -> TcRnIf gbl lcl a

                         if_doc = text "initIfaceLoad",

                         if_rec_types = emptyKnotVars

                     }

 -- | This is used when we are doing to call 'typecheckModule' on an 'ModIface',

 -- if it's part of a loop with some other modules then we need to use their

                         if_doc = text "initIfaceLoadModule",

                         if_rec_types = readTcRef <$> knotVarsWithout this_mod (hsc_type_env_vars hsc_env)

                     }

 initIfaceCheck :: SDoc -> HscEnv -> IfG a -> IO a

 -- Used when checking the up-to-date-ness of the old Iface

                         if_doc = text "initIfaceCheck" <+> doc,

                         if_rec_types = readTcRef <$> hsc_type_env_vars hsc_env

                     }

 initIfaceLcl :: Module -> SDoc -> IsBootInterface -> IfL a -> IfM lcl a

 initIfaceLcl mod loc_doc hi_boot_file thing_inside

 -- each original name; i.e. (module-name, occ-name) pair and provides

 -- something of a lookup mechanism for those names.

 data NameCache = NameCache

   , nsNames    :: {-# UNPACK #-} !(MVar OrigNameCache)

   }

 -- | Initialize a new name cache

 newNameCache :: IO NameCache

 -- | This is a version of `newNameCache` that lets you supply your

 -- own unique tag and set of known key names. This can go wrong if the tag

 -- an example.

 --

 -- Use `newNameCache` when possible.

 -- | This takes a tag for uniques to be generated and the list of knownKeyNames

 -- These must be initialized properly to ensure that names generated from this

 --

 -- Use `newNameCache` or `newNameCacheWith` instead

 {-# DEPRECATED initNameCache "Use newNameCache or newNameCacheWith instead" #-}

 initNameCache c names = newNameCacheWith c (initOrigNames names)

 initOrigNames :: [Name] -> OrigNameCache

 module GHC.Types.Unique (

         -- * Main data types

         Unique, Uniquable(..),

         uNIQUE_BITS,

         -- ** Constructors, destructors and operations on 'Unique's

 -- These are sometimes also referred to as \"keys\" in comments in GHC.

 newtype Unique = MkUnique Word64

 {-# INLINE uNIQUE_BITS #-}

 uNIQUE_BITS :: Int

 uNIQUE_BITS = 64 - UNIQUE_TAG_BITS

 incrUnique   :: Unique -> Unique

 stepUnique   :: Unique -> Word64 -> Unique

 mkUniqueGrimily = MkUnique

 stepUnique (MkUnique i) n = MkUnique (i + n)

 mkLocalUnique :: Word64 -> Unique

 minLocalUnique :: Unique

 minLocalUnique = mkLocalUnique 0

 -- and as long as the Char fits in 8 bits, which we assume anyway!

 -- EXPORTED and used only in GHC.Builtin.Uniques

 mkUnique c i

   = MkUnique (tag .|. bits)

   where

     bits = i .&. uniqueMask

 mkUniqueInt c i = mkUnique c (intToWord64 i)

 mkUniqueIntGrimily :: Int -> Unique

     DUniqResult uq us -> (uq, us)

 -- | Set the tag of uniques generated from this deterministic unique supply

 newTagDUniqSupply c (DUS w) = DUS $ getKey $ newTagUnique (mkUniqueGrimily w) c

 -- | Get the tag uniques generated from this deterministic unique supply would have

 -- | Get a unique from a monad that can access a unique supply.

 --

 -- | Set the tag of the running @UniqDSMT@ supply to the given tag and run an action with it.

 -- All uniques produced in the given action will use this tag, until the tag is changed

 -- again.

 setTagUDSMT tag (UDSMT act) = UDSMT $ \us -> do

   let origtag = getTagDUniqSupply us

       new_us  = newTagDUniqSupply tag us

         -- ** Operations on supplies

         uniqFromSupply, uniqsFromSupply, -- basic ops

         mkSplitUniqSupply,

         splitUniqSupply, listSplitUniqSupply,

                    UniqSupply UniqSupply

                                 -- when split => these two supplies

 -- ^ Create a unique supply out of thin air.

 -- The "tag" (Char) supplied is mostly cosmetic, making it easier

 -- to figure out where a Unique was born. See Note [Uniques and tags].

 -- See Note [How the unique supply works]

 -- See Note [Optimising the unique supply]

   = unsafeDupableInterleaveIO (IO mk_supply)

   where

         -- Here comes THE MAGIC: see Note [How the unique supply works]

         -- This is one of the most hammered bits in the whole compiler

     poke ghc_unique_counter64 counter

     poke ghc_unique_inc       inc

 uniqFromTag !tag

   = do { uqNum <- genSym

        ; return $! mkUnique tag uqNum }

 splitUniqSupply :: UniqSupply -> (UniqSupply, UniqSupply)

 -- ^ Build two 'UniqSupply' from a single one, each of which