import Data.ByteString     ( ByteString )

 import Data.Function       ( on )

 import Data.Ord            ( comparing )

 import Control.Monad       ( guard )

 import qualified Data.Set as Set

       PrimOpId op _

         | primOpIsDiv op

             -- there can be 2 args (most div primops) or 3 args

             -- (WordQuotRem2Op), hence the use of last/init

               -- Special case for dividing operations that fail

               -- In general they are NOT ok-for-speculation

               -- (which primop_ok will catch), but they ARE OK

     processSCCs [] = return ()

     processSCCs (AcyclicSCC _: other_sccs) = processSCCs other_sccs

     cycle_err uids =

                     (map (\uid -> text "-" <+> ppr uid <+> text "depends on") start)

                     ++ [text "-" <+> ppr final]

       where

 -- | Check that we don't have multiple units with the same UnitId.

 checkDuplicateUnits :: DynFlags -> [(FilePath, DynFlags)] -> Ghc ()

 {-# OPTIONS_HADDOCK not-home #-}

 {-# OPTIONS_GHC -O2 #-} -- See Note [-O2 Prelude]

 -- | Custom minimal GHC "Prelude"

 --

   , bit

   , shiftL, shiftR

   , setBit, clearBit

   , strictGenericLength

   ) where

 -}

 import qualified Prelude

 import Control.Applicative (Applicative(..))

 import Data.Foldable as X (Foldable (elem, foldMap, foldl, foldl', foldr, length, null, product, sum))

 import Data.Foldable1 as X hiding (head, last)

 clearBit :: (Num a, Bits.Bits a) => a -> Int -> a

 clearBit = \ x i -> x Bits..&. Bits.complement (bit i)

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 but the GHC codebase uses them fairly extensively and insists on building warning-free.

 Thus, instead of adding {-# OPTIONS_GHC -Wno-x-partial #-} to every module which

 employs them, we define warning-less proxies and export them from GHC.Prelude.

 -}

 head :: HasCallStack => [a] -> a

 head = Prelude.head

 {-# INLINE head #-}

 tail :: HasCallStack => [a] -> [a]

 tail = Prelude.tail

 {-# INLINE tail #-}

 {- |

 The 'genericLength' function defined in base can't be specialised due to the

 NOINLINE pragma.

 import Data.Function

 import qualified Data.Foldable as Foldable

 import Data.IORef ( IORef, modifyIORef, newIORef, readIORef, writeIORef )

                    isPrefixOf, isSuffixOf, nub, partition, sort, sortBy, (\\) )

 import qualified Data.List.NonEmpty as NE

 import qualified Data.Set as S

         []    ->

           let graph' = flattenSCCs $ filterToposortToModules $

                 GHC.topSortModuleGraph True (GHC.mkModuleGraph loaded_graph) Nothing

         (m:_) ->

           load_this m

  where

 import Control.Monad

 import Control.Monad.Trans.Class

 import Control.Monad.Trans.Except (throwE, runExceptT)

 import Prelude

 import qualified Data.List.NonEmpty as NE

     argv0 <- getArgs

     let (minusB_args, argv1) = partition ("-B" `isPrefixOf`) argv0

     let argv2 = map (mkGeneralLocated "on the commandline") argv1

 import GHC.Boot.TH.Syntax

 import Data.Word ( Word8 )

 import Data.Char ( toLower, chr )

 import GHC.Show  ( showMultiLineString )

 import GHC.Lexeme( isVarSymChar )

 import Data.Ratio ( numerator, denominator )

     pprStms [s] = ppr s

     pprStms ss  = braces (semiSep ss)

 -- This will probably break with fixity declarations - would need a ';'

     if null ss'

        -- If there are no statements in a list comprehension besides the last

        -- one, we simply treat it like a normal list.

         <+> bar

         <+> commaSep ss'

          <> text "]"

 pprExp _ (ArithSeqE d) = ppr d

 pprExp _ (ListE es) = brackets (commaSep es)

 pprExp i (SigE e t) = parensIf (i > noPrec) $ pprExp sigPrec e

 {-# OPTIONS_HADDOCK not-home #-}

 {-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}

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

 -- |

 -- Module      :  GHC.Internal.Float

 tail (_:xs)             =  xs

 tail []                 =  errorEmptyList "tail"

 -- | \(\mathcal{O}(n)\). Extract the last element of a list, which must be

 -- finite and non-empty.

 --

 --

 -- ==== __Examples__

 --

 lastError :: HasCallStack => a

 lastError = errorEmptyList "last"

 -- | \(\mathcal{O}(n)\). Return all the elements of a list except the last one.

 -- The list must be non-empty.

 --

 --

 -- ==== __Examples__

 --

   where init' _ []     = []

         init' y (z:zs) = y : init' z zs

 -- | \(\mathcal{O}(1)\). Test whether a list is empty.

 --

 -- >>> null []

       where

         -- XXX bits copied from System.FilePath, since that's not available here

 tempCounter :: IORef Int

 tempCounter = unsafePerformIO $ newIORef 0

 import GHC.Internal.Data.Data hiding (Fixity(..))

 import GHC.Internal.Data.NonEmpty (NonEmpty(..))

 import GHC.Internal.Data.Traversable

 import GHC.Internal.Word

 import GHC.Internal.Generics (Generic)

 import GHC.Internal.IORef

 import GHC.Internal.Control.Exception

 import GHC.Internal.Num

 import GHC.Internal.IO.Unsafe

 import GHC.Internal.MVar

 import GHC.Internal.IO.Exception

 import GHC.Internal.Unicode

 import GHC.Internal.ForeignSrcLang

 import GHC.Internal.LanguageExtensions

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

 --

 --              The Quasi class

     --   (i.e. non-empty, starts with capital, all alpha)

     is_rev_mod_name rev_mod_str

       | (compt, rest) <- break (== '.') rev_mod_str

       = case rest of

           []             -> True

           (_dot : rest') -> is_rev_mod_name rest'

 import Data.Char(toLower, toUpper, isAsciiLower, isAsciiUpper)

 import Data.Maybe(isJust)

 import System.Environment(getEnv)

 splitSearchPath :: String -> [FilePath]

 splitSearchPath = f

     where

 -- | Get a list of 'FilePath's in the $PATH variable.

 getSearchPath :: IO [FilePath]

 -- > splitExtension "file/path.txt.bob.fred" == ("file/path.txt.bob",".fred")

 -- > splitExtension "file/path.txt/" == ("file/path.txt/","")

 splitExtension :: FilePath -> (String, String)

 -- | Get the extension of a file, returns @\"\"@ for no extension, @.ext@ otherwise.

 --

 -- > hasTrailingPathSeparator "test" == False

 -- > hasTrailingPathSeparator "test/" == True

 hasTrailingPathSeparator :: FilePath -> Bool

 hasLeadingPathSeparator :: FilePath -> Bool

 hasLeadingPathSeparator "" = False

 -- > Windows:  dropTrailingPathSeparator "\\" == "\\"

 -- > Posix:    not (hasTrailingPathSeparator (dropTrailingPathSeparator x)) || isDrive x

 dropTrailingPathSeparator :: FilePath -> FilePath

 -- | Get the directory name, move up one level.

 --

 -- > Posix:   normalise "bob/fred/." == "bob/fred/"

 -- > Posix:   normalise "//home" == "/home"

 normalise :: FilePath -> FilePath

 normaliseDrive :: FilePath -> FilePath

 normaliseDrive "" = ""

 import Data.Char(toLower, toUpper, isAsciiLower, isAsciiUpper)

 import Data.Maybe(isJust)

 import System.Environment(getEnv)

 splitSearchPath :: String -> [FilePath]

 splitSearchPath = f

     where

 -- | Get a list of 'FilePath's in the $PATH variable.

 getSearchPath :: IO [FilePath]

 -- > splitExtension "file/path.txt.bob.fred" == ("file/path.txt.bob",".fred")

 -- > splitExtension "file/path.txt/" == ("file/path.txt/","")

 splitExtension :: FilePath -> (String, String)

 -- | Get the extension of a file, returns @\"\"@ for no extension, @.ext@ otherwise.

 --

 -- > hasTrailingPathSeparator "test" == False

 -- > hasTrailingPathSeparator "test/" == True

 hasTrailingPathSeparator :: FilePath -> Bool

 hasLeadingPathSeparator :: FilePath -> Bool

 hasLeadingPathSeparator "" = False

 -- > Windows:  dropTrailingPathSeparator "\\" == "\\"

 -- > Posix:    not (hasTrailingPathSeparator (dropTrailingPathSeparator x)) || isDrive x

 dropTrailingPathSeparator :: FilePath -> FilePath

 -- | Get the directory name, move up one level.

 --

 -- > Posix:   normalise "bob/fred/." == "bob/fred/"

 -- > Posix:   normalise "//home" == "/home"

 normalise :: FilePath -> FilePath

 normaliseDrive :: FilePath -> FilePath

 normaliseDrive "" = ""

 import GHC.Driver.Env.Types

 import GHC.Profiling

 import System.Mem

 import Control.Monad

 import System.Exit

 import GHC.Platform

       requestHeapCensus

       performGC

       [ys] <- filter (isPrefixOf (ghcUnitId <> ":GHC.Unit.Module.ModDetails.ModDetails")) . lines <$> readFile "jspace.hp"

       -- The output should be 50 * 8 * word_size (i.e. 3600, or 1600 on 32-bit architectures):

       -- the test contains DEPTH + WIDTH + 2 = 50 modules J, H_0, .., H_DEPTH, W_1, .., W_WIDTH,

       -- and each ModDetails contains 1 (info table) + 8 word-sized fields.

 module KeepCafsBase (x) where

 x :: Int

 import GHC.Parser.Lexer (allocateComments)

 import Data.Data hiding ( Fixity )

 import qualified Data.Map.Strict as Map

 import Debug.Trace

 ghead _info (h:_) = h

 glast :: String -> [a] -> a

 gtail :: String -> [a] -> [a]

 gtail  info []    = error $ "gtail " ++ info ++ " []"

         divAlphabet

           << unordList

             ( map (\str -> anchor ! [href (subIndexHtmlFile str)] << str) $

                 ]

                   ++ [merged_name]

             )

           writeUtf8File (joinPath [odir, subIndexHtmlFile [c]]) (renderToString debug html)

         where

           html = indexPage True (Just c) index_part

       index :: [(String, Map GHC.Name [(Module, Bool)])]

       index = sortBy cmp (Map.toAscList full_index)

 import Control.Monad

 import Data.Char (chr, isAlpha, isSpace, isUpper)

 import Data.Functor (($>))

 import Data.Maybe (fromMaybe, mapMaybe)

 import Data.Monoid

 import qualified Data.Set as Set

   DocCodeBlock . parseParagraph . dropSpaces

     <$> ("@" *> skipHorizontalSpace *> "\n" *> block' <* "@")

   where

           Just (' ', _) -> case mapM dropSpace ys of

             Nothing -> xs

             Just zs -> T.intercalate "\n" zs