BRK_FUN ibi@(InternalBreakpointId info_mod infox) -> do

     p1 <- ptr $ BCOPtrBreakArray info_mod

                     then r

     info_addr        <- lit1 $ BCONPtrFS $ moduleNameFS $ moduleName info_mod

     info_unitid_addr <- lit1 $ BCONPtrFS $ unitIdFS     $ moduleUnitId info_mod

     np               <- lit1 $ BCONPtrCostCentre ibi

     emit_ bci_BRK_FUN [ Op p1, Op info_addr, Op info_unitid_addr

   BRK_ALTS active -> emit_ bci_BRK_ALTS [SmallOp (if active then 1 else 0)]

 import GHC.Prelude

 import GHC.Settings.Utils         ( maybeRead )

 import GHC.Settings.Config        ( cProjectVersion )

 import GHC.Utils.Binary

 import GHC.Types.Name

 import GHC.Types.Name.Cache

 import GHC.Types.SrcLoc as SrcLoc

 import GHC.Types.Unique.FM

 import qualified GHC.Utils.Binary as Binary

 import GHC.Utils.Panic

 import qualified Data.Array        as A

   case hie_name of

     ExternalName mod occ span -> updateNameCache nc mod occ $ \cache -> do

       case lookupOrigNameCache cache mod occ of

         Just name -> pure (cache, name)

         Nothing   -> do

           uniq <- takeUniqFromNameCache nc

       -- don't update the NameCache for local names

       pure $ mkInternalName uniq occ span

 -- ** Reading and writing `HieName`'s

 putHieName :: WriteBinHandle -> HieName -> IO ()

 putHieName bh (LocalName occName span) = do

   putByte bh 1

   put_ bh (occName, BinSrcSpan span)

 getHieName :: ReadBinHandle -> IO HieName

 getHieName bh = do

     1 -> do

       (occ, span) <- get bh

       return $ LocalName occ $ unBinSrcSpan span

     _ -> panic "GHC.Iface.Ext.Binary.getHieName: invalid tag"

 import GHC.Settings.Config

 import GHC.Utils.Binary

 import GHC.Data.FastString

 import GHC.Iface.Type

 import GHC.Unit.Module            ( ModuleName, Module )

 import GHC.Types.Name

 import GHC.Utils.Outputable hiding ( (<>) )

 import GHC.Types.SrcLoc

 import GHC.Types.Avail

 import qualified GHC.Utils.Outputable as O ( (<>) )

 import GHC.Utils.Panic

 import GHC.Core.ConLike           ( ConLike(..) )

 data HieName

   = ExternalName !Module !OccName !SrcSpan

   | LocalName !OccName !SrcSpan

   deriving (Eq)

 instance Ord HieName where

     -- TODO (int-index): Perhaps use RealSrcSpan in HieName?

   compare (LocalName a b) (LocalName c d) = compare a c S.<> leftmost_smallest b d

     -- TODO (int-index): Perhaps use RealSrcSpan in HieName?

   compare ExternalName{} _ = LT

   compare LocalName{} ExternalName{} = GT

 instance Outputable HieName where

   ppr (ExternalName m n sp) = text "ExternalName" <+> ppr m <+> ppr n <+> ppr sp

   ppr (LocalName n sp) = text "LocalName" <+> ppr n <+> ppr sp

 hieNameOcc :: HieName -> OccName

 hieNameOcc (ExternalName _ occ _) = occ

 hieNameOcc (LocalName occ _) = occ

 toHieName :: Name -> HieName

 {- Note [Capture Entity Information]

 -- > static void hs_hpc_init_Main(void) {

 -- >

 -- >   static StgWord64 k0[2] = {16252233372134256ULL,7370534374096082ULL};

 -- >   hs_spt_insert(k0, &Main_r2wb_closure);

 -- >

 -- >   static StgWord64 k1[2] = {12545634534567898ULL,5409674567544151ULL};

 -- >   hs_spt_insert(k1, &Main_r2wc_closure);

 -- >

 -- > }

 --

 -- where the constants are fingerprints produced from the static forms.

 --

 -- declarations. For this to work, the identifiers of static pointers need to be

 -- exported. This is done in 'GHC.Core.Opt.SetLevels.newLvlVar'.

 --

         -- CLabel. Regardless, MayHaveCafRefs/NoCafRefs wouldn't make

         -- any difference here, they would pretty-print to the same

         -- foreign stub content.

            <> (pprCLabel platform $ mkClosureLabel n MayHaveCafRefs) <> semi

         $$ text "hs_spt_insert" <> parens

              (hcat $ punctuate comma

   3) Loading of interface files encodes names via Uniques, as detailed in

      Note [Symbol table representation of names] in GHC.Iface.Binary

 -}

 -- | The NameCache makes sure that there is just one Unique assigned for

 # Changelog for [`base` package](http://hackage.haskell.org/package/base)

 ## 4.23.0.0 *TBA*

   * Add `Data.List.NonEmpty.mapMaybe`. ([CLC proposal #337](https://github.com/haskell/core-libraries-committee/issues/337))

   * Fix issues with toRational for types capable to represent infinite and not-a-number values ([CLC proposal #338](https://github.com/haskell/core-libraries-committee/issues/338))

   * Modify the implementation of `Data.List.sortOn` to use `(>)` instead of `compare`. ([CLC proposal #332](https://github.com/haskell/core-libraries-committee/issues/332))

      -- **  Legacy interface for arrays of arrays

      module GHC.Internal.ArrayArray,

      -- *  Primitive operations

      module GHC.Prim,

      module GHC.Prim.Ext,

      -- **  Running 'RealWorld' state thread

   , whereFrom#

   , isByteArrayWeaklyPinned#, isMutableByteArrayWeaklyPinned#

   -- Don't re-export vector FMA instructions

   , fmaddFloatX4#

   , fmsubFloatX4#

   , minWord8X32#

   , minWord8X64#

   )

 import GHC.Prim.Ext

 {-# LANGUAGE UnboxedTuples #-}

 {-# LANGUAGE RecordWildCards #-}

 {-# LANGUAGE CPP #-}

 --

 --  (c) The University of Glasgow 2002-2006

 import Foreign hiding (newArray)

 import Unsafe.Coerce (unsafeCoerce)

 import GHC.Arr          ( Array(..) )

 import GHC.IO

 import Control.Exception ( ErrorCall(..) )

 {-# LANGUAGE ScopedTypeVariables, StandaloneDeriving, DeriveGeneric,

     TupleSections, RecordWildCards, InstanceSigs, CPP #-}

 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}

 -- |

 -- Running TH splices

 import Data.Map (Map)

 import qualified Data.Map as M

 import Data.Maybe

 import qualified GHC.Boot.TH.Syntax as TH

 import Unsafe.Coerce

         rts,

         array            == 0.5.*,

         base             >= 4.8 && < 4.23,

         ghc-prim         >= 0.5.0 && < 0.14,

         binary           == 0.8.*,

         bytestring       >= 0.10 && < 0.13,

          p1           = BCO_GET_LARGE_ARG;

          info_mod     = BCO_GET_LARGE_ARG;

          info_unit_id = BCO_GET_LARGE_ARG;

          np           = BCO_GET_LARGE_ARG;

          debugBelch ("BRK_FUN " );  printPtr( ptrs[p1] );

          debugBelch("%" FMT_Word, literals[info_mod] );

             arg1_brk_array      = BCO_GET_LARGE_ARG;

             /* info_mod_name = */ BCO_GET_LARGE_ARG;

             /* info_mod_id   = */ BCO_GET_LARGE_ARG;

             StgPtr* ptrs = (StgPtr*)(&bco->ptrs->payload[0]);

             StgArrBytes* breakPoints = (StgArrBytes *) BCO_PTR(arg1_brk_array);

             arg1_brk_array      = BCO_GET_LARGE_ARG;

             arg2_info_mod_name  = BCO_GET_LARGE_ARG;

             arg3_info_mod_id    = BCO_GET_LARGE_ARG;

 #if defined(PROFILING)

             arg5_cc             = BCO_GET_LARGE_ARG;

 #else

   return ()

 freshNameCache :: IO NameCache

 -- | Read a Haddock (@.haddock@) interface file. Return either an

 -- 'InterfaceFile' or an error message.