import GHC.Utils.Panic

 import GHC.Utils.Misc

 import Data.List (sortOn, sortBy, nub)

 import Data.List.NonEmpty (nonEmpty)

 import qualified Data.List.NonEmpty as NE

         applyEdges :: [CfgEdge] -> FrontierMap -> FrontierMap -> Set.Set (BlockId, BlockId)

                    -> ([BlockChain], Set.Set (BlockId,BlockId))

         applyEdges [] chainEnds _chainFronts combined =

         applyEdges ((CfgEdge from to _w):edges) chainEnds chainFronts combined

             | Just (c1_e,c1) <- mapLookup from chainEnds

             , Just (c2_f,c2) <- mapLookup to chainFronts

 import qualified GHC.Data.EnumSet as EnumSet

 import qualified GHC.Data.ShortText as ST

 import Data.List ( partition )

 import System.Exit

 import Control.Monad

     let inodes = instantiationNodes (homeUnitId $ hsc_home_unit hsc_env) (hsc_units hsc_env)

     -- TODO: Backpack mode does not properly support ExternalPackage nodes yet

     -- Module nodes do not get given package dependencies (see hsModuleToModSummary).

     let graph_nodes = nodes ++ req_nodes ++ (map (uncurry InstantiationNode) $ inodes) ++ pkg_nodes

         key_nodes = map mkNodeKey graph_nodes

         all_nodes = graph_nodes ++ [LinkNode key_nodes (homeUnitId $ hsc_home_unit hsc_env) | do_link]

     -- This error message is not very good but .bkp mode is just for testing so

     -- better to be direct rather than pretty.

     when

       (pprPanic "Duplicate nodes keys in backpack file" (ppr key_nodes))

     -- 3. Return the kaboodle

 import GHC.Types.SrcLoc

 import GHC.Types.SourceError

 import GHC.Utils.Panic

 import GHC.Utils.Outputable as Outputable

 import GHC.Utils.Monad       ( liftIO, mapMaybeM )

 import System.Exit

 import System.FilePath

 import Control.Monad

 import Data.List ( partition, (\\) )

 import qualified Data.Set as Set

 import GHC.Prelude

   where

     uids = map (second homeUnitId_) flags

     duplicate_ids = Set.fromList (map snd uids \\ map snd deduplicated_uids)

     duplicate_flags = filter (flip Set.member duplicate_ids . snd) uids

 import GHC.Data.Maybe

 import GHC.Data.FastString

 import Data.List (sortBy)

 import Data.Map (Map)

 import qualified Data.Map as Map

 -- modules and direct object files for pkg dependencies

 mkObjectUsage :: Plugins -> FinderCache -> [LinkableUsage] -> PkgsLoaded -> IO [Usage]

 mkObjectUsage plugins fc th_links_needed th_pkgs_needed = do

           ds = concatMap loaded_pkg_hs_objs $ eltsUDFM (plusUDFM th_pkgs_needed plugin_pkgs_needed) -- TODO possibly record loaded_pkg_non_hs_objs as well

           (plugins_links_needed, plugin_pkgs_needed) = loadedPluginDeps plugins

       concat <$> sequence (map linkableToUsage ls ++ map librarySpecToUsage ds)

 import GHC.Settings

 import Control.Monad

 import Data.List (nub)

 import Data.Semigroup ( Semigroup(..) )

 import System.Directory

   filterM doesFileExist [ searchPath </> ("lib" ++ lib ++ ".a")

                         | searchPath <- searchPaths

                         , lib <- libs ]

         libs        = unitHsLibs namever ways pc ++ (map ST.unpack . unitExtDepLibsStaticSys $ pc)

 getLibs :: GhcNameVersion -> Ways -> UnitEnv -> [UnitId] -> IO [(String,String)]

 import qualified GHC.LanguageExtensions as LangExt

 import Control.Monad       ( when, ap, guard, unless )

 import Data.Foldable

 import Data.Function       ( on )

 import Data.Functor.Identity ( Identity (..) )

        ; pats' <- rnLPatsAndThen mk pats

        ; let bndrs = collectPatsBinders CollVarTyVarBinders (NE.toList pats')

        ; liftCps $ setSrcSpan loc $ checkErr (null bndrs) $

        ; return (OrPat noExtField pats') }

 rnPatAndThen mk (SumPat _ pat alt arity)

 import GHC.Settings

 import Data.Version

 import Data.Bifunctor

 import Data.List (isPrefixOf, stripPrefix)

 -- | Find all the include directories in the given units

 collectIncludeDirs :: [UnitInfo] -> [FilePath]

 -- | Find all the C-compiler options in the given units

 collectExtraCcOpts :: [UnitInfo] -> [String]

 -- | Find all the library directories in the given units for the given ways

 collectLibraryDirs :: Ways -> [UnitInfo] -> [FilePath]

 -- | Find all the frameworks in the given units

 collectFrameworks :: [UnitInfo] -> [String]

 -- | Find all the package framework paths in these and the preload packages

 collectFrameworksDirs :: [UnitInfo] -> [String]

 -- | Either the 'unitLibraryDirs' or 'unitLibraryDynDirs' as appropriate for the way.

 libraryDirsForWay :: Ways -> UnitInfo -> [String]

 import System.Directory

 import System.FilePath as FilePath

 import Control.Monad

 import Data.Graph (stronglyConnComp, SCC(..))

 import Data.Char ( toUpper )

 import Data.List ( intersperse, partition, sortBy, sortOn, sort )

       basicLinkedUnits = fmap (RealUnit . Definite)

                          $ filter (flip elemUniqMap pkg_db)

                          $ unitConfigAutoLink cfg

   -- Close the preload packages with their dependencies

   dep_preload <- mayThrowUnitErr

         replaceAt, dropTail, capitalise,

         -- * Sorting

         -- * Comparisons

         isEqual,

 nubSort :: Ord a => [a] -> [a]

 nubSort = Set.toAscList . Set.fromList

 {-

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

 *                                                                      *