groupByInt f xs = nonDetEltsUFM $ List.foldl' go emptyUFM xs

    -- See Note [Unique Determinism and code generation]

   where

       where

 addBlock

     :: (NonLocal block, HasDebugCallStack)

     => block C C -> LabelMap (block C C) -> LabelMap (block C C)

   where

     lbl = entryLabel block

     add _ = error $ "duplicate label " ++ show lbl ++ " in graph"

     , mapInsertWith

     , mapDelete

     , mapAlter

     , mapAdjust

     , mapUnion

     , mapUnions

 mapAlter :: (Maybe v -> Maybe v) -> Label -> LabelMap v -> LabelMap v

 mapAlter f (Label k) (LM m) = LM (M.alter f k m)

 mapAdjust :: (v -> v) -> Label -> LabelMap v -> LabelMap v

 mapAdjust f (Label k) (LM m) = LM (M.adjust f k m)

 -- | Adds a new edge, overwrites existing edges if present

 addEdge :: BlockId -> BlockId -> EdgeInfo -> CFG -> CFG

 addEdge from to info cfg =

     where

         -- Simply insert the edge into the edge list.

         -- We must add the destination node explicitly

 -- | Adds a edge with the given weight to the cfg

     edgelessCfg = mapFromList $ zip (map G.entryLabel blocks) (repeat mapEmpty)

     insertEdge :: CFG -> ((BlockId,BlockId),EdgeInfo) -> CFG

     insertEdge m ((from,to),weight) =

         where

     getBlockEdges :: CmmBlock -> [((BlockId,BlockId),EdgeInfo)]

     getBlockEdges block =

       case branch of

    postInlineUnconditionally is primarily to push allocation into cold

    branches; but a join point doesn't allocate, so that's a non-motivation.

    alternatives, /except/ for ones that will definitely inline unconditionally

    straight away.  (In that case it's silly to make a join point in the first

    place; it just takes an extra Simplifier iteration to undo.)  This choice is

 import Control.Monad (join)

 import Data.Data (Data)

 import GHC.Utils.Panic

 {-

     rm { rm_empty = v `consBag` rm_empty rm }

 insertRM (RM_KnownTc k : ks) v rm@(RM {}) =

   where

 insertRM (RM_WildCard : ks) v rm@(RM {}) =

     rm { rm_wild = insertRM ks v (rm_wild rm) }

         extendTyConEnv_C, extendTyConEnv_Acc, extendTyConEnv,

         extendTyConEnvList, extendTyConEnvList_C,

         filterTyConEnv, anyTyConEnv,

         lookupTyConEnv, lookupTyConEnv_NF, delFromTyConEnv, delListFromTyConEnv,

         elemTyConEnv, mapTyConEnv, disjointTyConEnv,

         lookupDTyConEnv,

         delFromDTyConEnv, filterDTyConEnv,

         mapDTyConEnv, mapMaybeDTyConEnv,

     ) where

 import GHC.Prelude

 mkTyConEnvWith      :: (a -> TyCon) -> [a] -> TyConEnv a

 nonDetTyConEnvElts  :: TyConEnv a -> [a]

 alterTyConEnv       :: (Maybe a-> Maybe a) -> TyConEnv a -> TyCon -> TyConEnv a

 extendTyConEnv_C    :: (a->a->a) -> TyConEnv a -> TyCon -> a -> TyConEnv a

 extendTyConEnv_Acc  :: (a->b->b) -> (a->b) -> TyConEnv b -> TyCon -> a -> TyConEnv b

 extendTyConEnv      :: TyConEnv a -> TyCon -> a -> TyConEnv a

 extendTyConEnvList x l = addListToUFM x l

 lookupTyConEnv x y     = lookupUFM x y

 alterTyConEnv          = alterUFM

 mkTyConEnv     l       = listToUFM l

 mkTyConEnvWith f       = mkTyConEnv . map (\a -> (f a, a))

 elemTyConEnv x y          = elemUFM x y

 alterDTyConEnv :: (Maybe a -> Maybe a) -> DTyConEnv a -> TyCon -> DTyConEnv a

 alterDTyConEnv = alterUDFM

 extendDTyConEnv :: DTyConEnv a -> TyCon -> a -> DTyConEnv a

 extendDTyConEnv = addToUDFM

   Unifiable (state { um_fam_env = extend (um_fam_env state) tc }, ())

   where

     extend :: FamSubstEnv -> TyCon -> FamSubstEnv

 umRnBndr2 :: UMEnv -> TyCoVar -> TyCoVar -> UMEnv

 umRnBndr2 env v1 v2

         extendFsEnv_C, extendFsEnv_Acc, extendFsEnv,

         extendFsEnvList, extendFsEnvList_C,

         filterFsEnv,

         lookupFsEnv, lookupFsEnv_NF, delFromFsEnv, delListFromFsEnv,

         elemFsEnv, mapFsEnv, strictMapFsEnv, mapMaybeFsEnv,

         nonDetFoldFsEnv,

 emptyFsEnv         :: FastStringEnv a

 mkFsEnv            :: [(FastString,a)] -> FastStringEnv a

 alterFsEnv         :: (Maybe a-> Maybe a) -> FastStringEnv a -> FastString -> FastStringEnv a

 extendFsEnv_C      :: (a->a->a) -> FastStringEnv a -> FastString -> a -> FastStringEnv a

 extendFsEnv_Acc    :: (a->b->b) -> (a->b) -> FastStringEnv b -> FastString -> a -> FastStringEnv b

 extendFsEnv        :: FastStringEnv a -> FastString -> a -> FastStringEnv a

 extendFsEnvList x l       = addListToUFM x l

 lookupFsEnv x y           = lookupUFM x y

 alterFsEnv                = alterUFM

 mkFsEnv     l             = listToUFM l

 elemFsEnv x y             = elemUFM x y

 plusFsEnv x y             = plusUFM x y

     , adjustWithKey

     , update

     , updateWithKey

     , updateLookupWithKey

     , alter

     , alterLookup

   | otherwise     = t

 updateWithKey _ _ Nil = Nil

 -- | \(O(\min(n,W))\). Lookup and update.

 -- The function returns original value, if it is updated.

 -- This is different behavior than 'Data.Map.updateLookupWithKey'.

     , adjustWithKey

     , update

     , updateWithKey

     , updateLookupWithKey

     , alter

     , alterLookup

     , adjustWithKey

     , update

     , updateWithKey

     , updateLookupWithKey

     , alter

     , alterF

     , adjustWithKey

     , update

     , updateWithKey

     , updateLookupWithKey

     , alter

     , alterF

       | otherwise     -> t

     Nil -> Nil

 -- | \(O(\min(n,W))\). Lookup and update.

 -- The function returns original value, if it is updated.

 -- This is different behavior than 'Data.Map.updateLookupWithKey'.

 delTcApp m tc tys = adjustDTyConEnv (deleteTM tys) m tc

 insertTcApp :: TcAppMap a -> TyCon -> [Type] -> a -> TcAppMap a

   where

 alterTcApp :: forall a. TcAppMap a -> TyCon -> [Type] -> XT a -> TcAppMap a

   where

 filterTcAppMap :: forall a. (a -> Bool) -> TcAppMap a -> TcAppMap a

 filterTcAppMap f m = mapMaybeDTyConEnv one_tycon m

         filterNameEnv, anyNameEnv,

         mapMaybeNameEnv,

         extendNameEnvListWith,

         plusNameEnvList, plusNameEnvListWith,

         lookupNameEnv, lookupNameEnv_NF, delFromNameEnv, delListFromNameEnv,

         elemNameEnv, mapNameEnv, disjointNameEnv,

         lookupDNameEnv,

         delFromDNameEnv, filterDNameEnv,

         mapDNameEnv,

         eltsDNameEnv, extendDNameEnv_C,

         plusDNameEnv_C,

         foldDNameEnv,

 fromUniqMap        :: UniqMap Name a -> NameEnv a

 nonDetNameEnvElts  :: NameEnv a -> [a]

 alterNameEnv       :: (Maybe a-> Maybe a) -> NameEnv a -> Name -> NameEnv a

 extendNameEnv_C    :: (a->a->a) -> NameEnv a -> Name -> a -> NameEnv a

 extendNameEnv_Acc  :: (a->b->b) -> (a->b) -> NameEnv b -> Name -> a -> NameEnv b

 extendNameEnv      :: NameEnv a -> Name -> a -> NameEnv a

 extendNameEnvListWith f x l = addListToUFM x (map (\a -> (f a, a)) l)

 lookupNameEnv x y     = lookupUFM x y

 alterNameEnv          = alterUFM

 mkNameEnv     l       = listToUFM l

 mkNameEnvWith f       = mkNameEnv . map (\a -> (f a, a))

 fromUniqMap           = mapUFM snd . getUniqMap

 alterDNameEnv :: (Maybe a -> Maybe a) -> DNameEnv a -> Name -> DNameEnv a

 alterDNameEnv = alterUDFM

 extendDNameEnv :: DNameEnv a -> Name -> a -> DNameEnv a

 extendDNameEnv = addToUDFM

   MkOccEnv . extendFsEnv_Acc f' g' env s

     where

      f' :: a -> UniqFM NameSpace b -> UniqFM NameSpace b

      g' a = unitUFM ns (g a)

 -- | Delete one element from an 'OccEnv'.

         delListFromUDFM,

         adjustUDFM,

         adjustUDFM_Directly,

         alterUDFM,

         alterUDFM_L,

         mapUDFM,

   inject Nothing = Nothing

   inject (Just v) = Just $ TaggedVal v i

 -- | The expression (@'alterUDFM_L' f map k@) alters value @x@ at @k@, or absence

 -- thereof and returns the new element at @k@ if there is any.

 -- 'alterUDFM_L' can be used to insert, delete, or update a value in

         addListToUFM,addListToUFM_C,

         addToUFM_Directly,

         addListToUFM_Directly,

         delFromUFM,

         delFromUFM_Directly,

         delListFromUFM,

   -> UniqFM key elt            -- ^ result

 alterUFM f (UFM m) k = UFM (M.alter f (getKey $ getUnique k) m)

 alterUFM_L

   :: Uniquable key

   => (Maybe elt -> Maybe elt)    -- ^ How to adjust

         strictPlusVarEnv, plusVarEnv, plusVarEnv_C,

         strictPlusVarEnv_C, strictPlusVarEnv_C_Directly,

         plusVarEnv_CD, plusMaybeVarEnv_C,

         delVarEnvList, delVarEnv,

         minusVarEnv,

         lookupVarEnv, lookupVarEnv_NF, lookupWithDefaultVarEnv,

         isEmptyDVarEnv, foldDVarEnv, nonDetStrictFoldDVarEnv,

         mapDVarEnv, filterDVarEnv,

         modifyDVarEnv,

         plusDVarEnv, plusDVarEnv_C,

         unitDVarEnv,

         delDVarEnv,

 zipVarEnv         :: [Var] -> [a] -> VarEnv a

 unitVarEnv        :: Var -> a -> VarEnv a

 alterVarEnv       :: (Maybe a -> Maybe a) -> VarEnv a -> Var -> VarEnv a

 extendVarEnv      :: VarEnv a -> Var -> a -> VarEnv a

 extendVarEnv_C    :: (a->a->a) -> VarEnv a -> Var -> a -> VarEnv a

 extendVarEnv_Acc  :: (a->b->b) -> (a->b) -> VarEnv b -> Var -> a -> VarEnv b

 elemVarEnvByKey  = elemUFM_Directly

 disjointVarEnv   = disjointUFM

 alterVarEnv      = alterUFM

 extendVarEnv     = addToUFM

 extendVarEnv_C   = addToUFM_C

 extendVarEnv_Acc = addToUFM_Acc

 alterDVarEnv :: (Maybe a -> Maybe a) -> DVarEnv a -> Var -> DVarEnv a

 alterDVarEnv = alterUDFM

 plusDVarEnv :: DVarEnv a -> DVarEnv a -> DVarEnv a

 plusDVarEnv = plusUDFM

   where width = cmmExprWidth platform e

 addToList :: ([a] -> [a]) -> Label -> LabelMap [a] -> LabelMap [a]

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

 --- everything below here is for diagnostics in case of panic