import Data.ByteString     ( ByteString )

 import Data.Function       ( on )

 import Data.List           ( sort, sortBy, partition, zipWith4, mapAccumL )

 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

 import Control.Monad

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

 import qualified Data.Set as Set

 import GHC.ResponseFile (expandResponse)

 import Data.Bifunctor

 import GHC.Data.Graph.Directed

 {-# 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.Time.Format ( formatTime, defaultTimeLocale )

 import Data.Version ( showVersion )

 import qualified Data.Semigroup as S

 import GHC.Utils.Exception as Exception hiding (catch, mask, handle)

 import Foreign hiding (void)

 {-# LANGUAGE LambdaCase #-}

 {-# LANGUAGE NondecreasingIndentation #-}

 {-# LANGUAGE TupleSections #-}

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

 --

         , package terminfo     ? pure [ "-Wno-unused-imports", "-Wno-deriving-typeable" ]

         , package stm          ? pure [ "-Wno-deriving-typeable" ]

         , package osString     ? pure [ "-Wno-deriving-typeable", "-Wno-unused-imports" ]

         , package cabal        ? pure [ "-Wno-deriving-typeable", "-Wno-incomplete-record-selectors" ]

              -- The -Wno-incomplete-record-selectors is due to

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

 ## 4.23.0.0 *TBA*

   * Remove deprecated, unstable heap representation details from `GHC.Exts` ([CLC proposal #212](https://github.com/haskell/core-libraries-committee/issues/212))

   * 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))

 {-# LANGUAGE Trustworthy #-}

 {-# LANGUAGE LambdaCase #-}

 -- | contains a prettyprinter for the

 -- Template Haskell datatypes

 {-# 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 []

 {-# LANGUAGE Trustworthy #-}

 {-# LANGUAGE CPP, NoImplicitPrelude, CApiFFI #-}

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

 -- |

 {-# OPTIONS_HADDOCK not-home #-} -- we want users to import Language.Haskell.TH.Syntax instead

 {-# LANGUAGE CPP #-}

 {-# LANGUAGE DataKinds #-}

 {-# LANGUAGE DeriveGeneric #-}

 -- Vendored from filepath v1.4.2.2

 {-# LANGUAGE PatternGuards #-}

 -- This template expects CPP definitions for:

 --     MODULE_NAME = Posix | Windows

 -- Vendored from filepath v1.4.2.2

 {-# LANGUAGE PatternGuards #-}

 -- This template expects CPP definitions for:

 --     MODULE_NAME = Posix | Windows

 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

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

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

 {-# OPTIONS_GHC -Wno-orphans #-}

 import Data.Data

 import Data.List (intercalate)

 import GHC.Types.SrcLoc

 import Data.Data

 import Data.List.NonEmpty (NonEmpty (..))

 import qualified Data.List.NonEmpty as NE

 import Data.Maybe

   where

     -- we want DPs for the distance from the end of the ns to the

     -- AnnDColon, and to the start of the ty

     dca' = case dca of

           EpaSpan ss@(RealSrcSpan r _) -> (EpaDelta ss (ss2delta (ss2posEnd rd) r) [])

           _                            -> dca

               where

                 cs'' = setPriorComments cs []

                 csd = L (EpaDelta ss dp NoComments) c:commentOrigDeltas cs'

                 delta = case getLoc lc of

                           EpaSpan (RealSrcSpan rr _) -> ss2delta (ss2pos rr) r

                           EpaSpan _ -> (SameLine 0)

 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 ++ " []"

 {-# LANGUAGE DataKinds #-}

 {-# LANGUAGE TupleSections #-}

 {-# LANGUAGE ScopedTypeVariables #-}

 -- Fine if this comes from make/Hadrian or the pre-built base.

 #include <ghcplatform.h>

 import Control.Exception

 import Control.Monad

 import Control.Monad.IO.Class

 import System.Directory

 import System.FilePath

 import System.IO.Error

   ExitFailure _ -> False

 lastLine :: String -> String

         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