base-exports.stdout-javascript-unknown-ghcjs

  mapAccumR :: forall acc x y. (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
  maximum :: forall a. (GHC.Classes.Ord a, GHC.Internal.Stack.Types.HasCallStack) => [a] -> a
  maximumBy :: forall a. (a -> a -> GHC.Types.Ordering) -> [a] -> a
  minimum :: forall a. (GHC.Classes.Ord a, GHC.Internal.Stack.Types.HasCallStack) => [a] -> a
  minimumBy :: forall a. (a -> a -> GHC.Types.Ordering) -> [a] -> a
  notElem :: forall a. GHC.Classes.Eq a => a -> [a] -> GHC.Types.Bool
  nub :: forall a. GHC.Classes.Eq a => [a] -> [a]
  nubBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a]
  null :: forall a. [a] -> GHC.Types.Bool
  or :: [GHC.Types.Bool] -> GHC.Types.Bool
  partition :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  permutations :: forall a. [a] -> [[a]]
  product :: forall a. GHC.Internal.Num.Num a => [a] -> a
  repeat :: forall a. a -> [a]
  replicate :: forall a. GHC.Types.Int -> a -> [a]
  reverse :: forall a. [a] -> [a]
  scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
  scanl' :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
  scanl1 :: forall a. (a -> a -> a) -> [a] -> [a]
  scanr :: forall a b. (a -> b -> b) -> b -> [a] -> [b]
  scanr1 :: forall a. (a -> a -> a) -> [a] -> [a]
  singleton :: forall a. a -> [a]
  sort :: forall a. GHC.Classes.Ord a => [a] -> [a]
  sortBy :: forall a. (a -> a -> GHC.Types.Ordering) -> [a] -> [a]
  sortOn :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [a]
  span :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  splitAt :: forall a. GHC.Types.Int -> [a] -> ([a], [a])
  stripPrefix :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Internal.Maybe.Maybe [a]
  subsequences :: forall a. [a] -> [[a]]
  sum :: forall a. GHC.Internal.Num.Num a => [a] -> a
  tail :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  tails :: forall a. [a] -> [[a]]
  take :: forall a. GHC.Types.Int -> [a] -> [a]
  takeWhile :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  transpose :: forall a. [[a]] -> [[a]]
  uncons :: forall a. [a] -> GHC.Internal.Maybe.Maybe (a, [a])
  unfoldr :: forall b a. (b -> GHC.Internal.Maybe.Maybe (a, b)) -> b -> [a]
  union :: forall a. GHC.Classes.Eq a => [a] -> [a] -> [a]
  unionBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a] -> [a]
  unlines :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  unsnoc :: forall a. [a] -> GHC.Internal.Maybe.Maybe ([a], a)
  unwords :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  unzip :: forall a b. [(a, b)] -> ([a], [b])
  unzip3 :: forall a b c. [(a, b, c)] -> ([a], [b], [c])
  unzip4 :: forall a b c d. [(a, b, c, d)] -> ([a], [b], [c], [d])
  unzip5 :: forall a b c d e. [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
  unzip6 :: forall a b c d e f. [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
  unzip7 :: forall a b c d e f g. [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
  words :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]
  zip :: forall a b. [a] -> [b] -> [(a, b)]
  zip3 :: forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
  zip4 :: forall a b c d. [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
  zip5 :: forall a b c d e. [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
  zip6 :: forall a b c d e f. [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
  zip7 :: forall a b c d e f g. [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
  zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
  zipWith3 :: forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
  zipWith4 :: forall a b c d e. (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
  zipWith5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
  zipWith6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
  zipWith7 :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]

module GHC.OverloadedLabels where
  -- Safety: None
  type IsLabel :: GHC.Types.Symbol -> * -> Constraint
  class IsLabel x a where
    fromLabel :: a
    {-# MINIMAL fromLabel #-}

module GHC.Pack where
  -- Safety: None
  packCString# :: [GHC.Types.Char] -> GHC.Prim.ByteArray#
  unpackAppendCString# :: GHC.Prim.Addr# -> [GHC.Types.Char] -> [GHC.Types.Char]
  unpackCString :: forall a. GHC.Internal.Ptr.Ptr a -> [GHC.Types.Char]
  unpackCString# :: GHC.Prim.Addr# -> [GHC.Types.Char]
  unpackFoldrCString# :: forall a. GHC.Prim.Addr# -> (GHC.Types.Char -> a -> a) -> a -> a
  unpackNBytes# :: GHC.Prim.Addr# -> GHC.Prim.Int# -> [GHC.Types.Char]

module GHC.Profiling where
  -- Safety: Safe
  requestHeapCensus :: GHC.Types.IO ()
  startHeapProfTimer :: GHC.Types.IO ()
  startProfTimer :: GHC.Types.IO ()
  stopHeapProfTimer :: GHC.Types.IO ()
  stopProfTimer :: GHC.Types.IO ()

module GHC.Ptr where
  -- Safety: None
  type role FunPtr phantom
  type FunPtr :: * -> *
  data FunPtr a = FunPtr GHC.Prim.Addr#
  type role Ptr phantom
  type Ptr :: * -> *
  data Ptr a = Ptr GHC.Prim.Addr#
  alignPtr :: forall a. Ptr a -> GHC.Types.Int -> Ptr a
  castFunPtr :: forall a b. FunPtr a -> FunPtr b
  castFunPtrToPtr :: forall a b. FunPtr a -> Ptr b
  castPtr :: forall a b. Ptr a -> Ptr b
  castPtrToFunPtr :: forall a b. Ptr a -> FunPtr b
  minusPtr :: forall a b. Ptr a -> Ptr b -> GHC.Types.Int
  nullFunPtr :: forall a. FunPtr a
  nullPtr :: forall a. Ptr a
  plusPtr :: forall a b. Ptr a -> GHC.Types.Int -> Ptr b

module GHC.RTS.Flags where
  -- Safety: None
  type CCFlags :: *
  data CCFlags = CCFlags {doCostCentres :: DoCostCentres, profilerTicks :: GHC.Types.Int, msecsPerTick :: GHC.Types.Int}
  type ConcFlags :: *
  data ConcFlags = ConcFlags {ctxtSwitchTime :: RtsTime, ctxtSwitchTicks :: GHC.Types.Int}
  type DebugFlags :: *
  data DebugFlags = DebugFlags {scheduler :: GHC.Types.Bool, interpreter :: GHC.Types.Bool, weak :: GHC.Types.Bool, gccafs :: GHC.Types.Bool, gc :: GHC.Types.Bool, nonmoving_gc :: GHC.Types.Bool, block_alloc :: GHC.Types.Bool, sanity :: GHC.Types.Bool, stable :: GHC.Types.Bool, prof :: GHC.Types.Bool, linker :: GHC.Types.Bool, apply :: GHC.Types.Bool, stm :: GHC.Types.Bool, squeeze :: GHC.Types.Bool, hpc :: GHC.Types.Bool, sparks :: GHC.Types.Bool}
  type DoCostCentres :: *
  data DoCostCentres = CostCentresNone | CostCentresSummary | CostCentresVerbose | CostCentresAll | CostCentresJSON
  type DoHeapProfile :: *
  data DoHeapProfile = NoHeapProfiling | HeapByCCS | HeapByMod | HeapByDescr | HeapByType | HeapByRetainer | HeapByLDV | HeapByClosureType | HeapByInfoTable | HeapByEra
  type DoTrace :: *
  data DoTrace = TraceNone | TraceEventLog | TraceStderr
  type GCFlags :: *
  data GCFlags
    = GCFlags {statsFile :: GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath,
               giveStats :: GiveGCStats,
               maxStkSize :: GHC.Internal.Word.Word32,
               initialStkSize :: GHC.Internal.Word.Word32,
               stkChunkSize :: GHC.Internal.Word.Word32,
               stkChunkBufferSize :: GHC.Internal.Word.Word32,
               maxHeapSize :: GHC.Internal.Word.Word32,
               minAllocAreaSize :: GHC.Internal.Word.Word32,
               largeAllocLim :: GHC.Internal.Word.Word32,
               nurseryChunkSize :: GHC.Internal.Word.Word32,
               minOldGenSize :: GHC.Internal.Word.Word32,
               heapSizeSuggestion :: GHC.Internal.Word.Word32,
               heapSizeSuggestionAuto :: GHC.Types.Bool,
               oldGenFactor :: GHC.Types.Double,
               returnDecayFactor :: GHC.Types.Double,
               pcFreeHeap :: GHC.Types.Double,
               generations :: GHC.Internal.Word.Word32,
               squeezeUpdFrames :: GHC.Types.Bool,
               compact :: GHC.Types.Bool,
               compactThreshold :: GHC.Types.Double,
               sweep :: GHC.Types.Bool,
               ringBell :: GHC.Types.Bool,
               idleGCDelayTime :: RtsTime,
               doIdleGC :: GHC.Types.Bool,
               heapBase :: GHC.Types.Word,
               allocLimitGrace :: GHC.Types.Word,
               numa :: GHC.Types.Bool,
               numaMask :: GHC.Types.Word}
  type GiveGCStats :: *
  data GiveGCStats = NoGCStats | CollectGCStats | OneLineGCStats | SummaryGCStats | VerboseGCStats
  type HpcFlags :: *
  data HpcFlags = HpcFlags {writeTixFile :: GHC.Types.Bool}
  type IoManagerFlag :: *
  data IoManagerFlag = IoManagerFlagAuto | IoManagerFlagSelect | IoManagerFlagMIO | IoManagerFlagWinIO | IoManagerFlagWin32Legacy
  type IoSubSystem :: *
  data IoSubSystem = IoPOSIX | IoNative
  type MiscFlags :: *
  data MiscFlags = MiscFlags {tickInterval :: RtsTime, installSignalHandlers :: GHC.Types.Bool, installSEHHandlers :: GHC.Types.Bool, generateCrashDumpFile :: GHC.Types.Bool, generateStackTrace :: GHC.Types.Bool, machineReadable :: GHC.Types.Bool, disableDelayedOsMemoryReturn :: GHC.Types.Bool, internalCounters :: GHC.Types.Bool, linkerAlwaysPic :: GHC.Types.Bool, linkerMemBase :: GHC.Types.Word, ioManager :: IoManagerFlag, numIoWorkerThreads :: GHC.Internal.Word.Word32}
  type ParFlags :: *
  data ParFlags = ParFlags {nCapabilities :: GHC.Internal.Word.Word32, migrate :: GHC.Types.Bool, maxLocalSparks :: GHC.Internal.Word.Word32, parGcEnabled :: GHC.Types.Bool, parGcGen :: GHC.Internal.Word.Word32, parGcLoadBalancingEnabled :: GHC.Types.Bool, parGcLoadBalancingGen :: GHC.Internal.Word.Word32, parGcNoSyncWithIdle :: GHC.Internal.Word.Word32, parGcThreads :: GHC.Internal.Word.Word32, setAffinity :: GHC.Types.Bool}
  type ProfFlags :: *
  data ProfFlags
    = ProfFlags {doHeapProfile :: DoHeapProfile,
                 heapProfileInterval :: RtsTime,
                 heapProfileIntervalTicks :: GHC.Types.Word,
                 startHeapProfileAtStartup :: GHC.Types.Bool,
                 startTimeProfileAtStartup :: GHC.Types.Bool,
                 showCCSOnException :: GHC.Types.Bool,
                 automaticEraIncrement :: GHC.Types.Bool,
                 maxRetainerSetSize :: GHC.Types.Word,
                 ccsLength :: GHC.Types.Word,
                 modSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 descrSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 typeSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 ccSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 ccsSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 retainerSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 bioSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 eraSelector :: GHC.Types.Word}
  type RTSFlags :: *
  data RTSFlags = RTSFlags {gcFlags :: GCFlags, concurrentFlags :: ConcFlags, miscFlags :: MiscFlags, debugFlags :: DebugFlags, costCentreFlags :: CCFlags, profilingFlags :: ProfFlags, traceFlags :: TraceFlags, tickyFlags :: TickyFlags, parFlags :: ParFlags, hpcFlags :: HpcFlags}
  type RtsTime :: *
  type RtsTime = GHC.Internal.Word.Word64
  type TickyFlags :: *
  data TickyFlags = TickyFlags {showTickyStats :: GHC.Types.Bool, tickyFile :: GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath}
  type TraceFlags :: *
  data TraceFlags = TraceFlags {tracing :: DoTrace, timestamp :: GHC.Types.Bool, traceScheduler :: GHC.Types.Bool, traceGc :: GHC.Types.Bool, traceNonmovingGc :: GHC.Types.Bool, sparksSampled :: GHC.Types.Bool, sparksFull :: GHC.Types.Bool, user :: GHC.Types.Bool}
  getCCFlags :: GHC.Types.IO CCFlags
  getConcFlags :: GHC.Types.IO ConcFlags
  getDebugFlags :: GHC.Types.IO DebugFlags
  getGCFlags :: GHC.Types.IO GCFlags
  getHpcFlags :: GHC.Types.IO HpcFlags
  getMiscFlags :: GHC.Types.IO MiscFlags
  getParFlags :: GHC.Types.IO ParFlags
  getProfFlags :: GHC.Types.IO ProfFlags
  getRTSFlags :: GHC.Types.IO RTSFlags
  getTickyFlags :: GHC.Types.IO TickyFlags
  getTraceFlags :: GHC.Types.IO TraceFlags

module GHC.Read where
  -- Safety: Safe
  type Read :: * -> Constraint
  class Read a where
    readsPrec :: GHC.Types.Int -> ReadS a
    readList :: ReadS [a]
    readPrec :: GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
    readListPrec :: GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a]
    {-# MINIMAL readsPrec | readPrec #-}
  type ReadS :: * -> *
  type ReadS a = GHC.Internal.Base.String -> [(a, GHC.Internal.Base.String)]
  choose :: forall a. [(GHC.Internal.Base.String, GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a)] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  expectP :: GHC.Internal.Text.Read.Lex.Lexeme -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec ()
  lex :: ReadS GHC.Internal.Base.String
  lexDigits :: ReadS GHC.Internal.Base.String
  lexLitChar :: ReadS GHC.Internal.Base.String
  lexP :: GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec GHC.Internal.Text.Read.Lex.Lexeme
  list :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a]
  paren :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  parens :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readField :: forall a. GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readFieldHash :: forall a. GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readListDefault :: forall a. Read a => ReadS [a]
  readListPrecDefault :: forall a. Read a => GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a]
  readLitChar :: ReadS GHC.Types.Char
  readNumber :: forall a. GHC.Internal.Num.Num a => (GHC.Internal.Text.Read.Lex.Lexeme -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a) -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readParen :: forall a. GHC.Types.Bool -> ReadS a -> ReadS a
  readSymField :: forall a. GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a

module GHC.Real where
  -- Safety: Safe
  (%) :: forall a. Integral a => a -> a -> Ratio a
  type Fractional :: * -> Constraint
  class GHC.Internal.Num.Num a => Fractional a where
    (/) :: a -> a -> a
    recip :: a -> a
    fromRational :: Rational -> a
    {-# MINIMAL fromRational, (recip | (/)) #-}
  type FractionalExponentBase :: *
  data FractionalExponentBase = Base2 | Base10
  type Integral :: * -> Constraint
  class (Real a, GHC.Internal.Enum.Enum a) => Integral a where
    quot :: a -> a -> a
    rem :: a -> a -> a
    div :: a -> a -> a
    mod :: a -> a -> a
    quotRem :: a -> a -> (a, a)
    divMod :: a -> a -> (a, a)
    toInteger :: a -> GHC.Num.Integer.Integer
    {-# MINIMAL quotRem, toInteger #-}
  type Ratio :: * -> *
  data Ratio a = !a :% !a
  type Rational :: *
  type Rational = Ratio GHC.Num.Integer.Integer
  type Real :: * -> Constraint
  class (GHC.Internal.Num.Num a, GHC.Classes.Ord a) => Real a where
    toRational :: a -> Rational
    {-# MINIMAL toRational #-}
  type RealFrac :: * -> Constraint
  class (Real a, Fractional a) => RealFrac a where
    properFraction :: forall b. Integral b => a -> (b, a)
    truncate :: forall b. Integral b => a -> b
    round :: forall b. Integral b => a -> b
    ceiling :: forall b. Integral b => a -> b
    floor :: forall b. Integral b => a -> b
    {-# MINIMAL properFraction #-}
  (^) :: forall a b. (GHC.Internal.Num.Num a, Integral b) => a -> b -> a
  (^%^) :: forall a. Integral a => Rational -> a -> Rational
  (^^) :: forall a b. (Fractional a, Integral b) => a -> b -> a
  (^^%^^) :: forall a. Integral a => Rational -> a -> Rational
  denominator :: forall a. Ratio a -> a
  divZeroError :: forall a. a
  even :: forall a. Integral a => a -> GHC.Types.Bool
  fromIntegral :: forall a b. (Integral a, GHC.Internal.Num.Num b) => a -> b
  gcd :: forall a. Integral a => a -> a -> a
  infinity :: Rational
  integralEnumFrom :: forall a. (Integral a, GHC.Internal.Enum.Bounded a) => a -> [a]
  integralEnumFromThen :: forall a. (Integral a, GHC.Internal.Enum.Bounded a) => a -> a -> [a]
  integralEnumFromThenTo :: forall a. Integral a => a -> a -> a -> [a]
  integralEnumFromTo :: forall a. Integral a => a -> a -> [a]
  lcm :: forall a. Integral a => a -> a -> a
  mkRationalBase10 :: Rational -> GHC.Num.Integer.Integer -> Rational
  mkRationalBase2 :: Rational -> GHC.Num.Integer.Integer -> Rational
  mkRationalWithExponentBase :: Rational -> GHC.Num.Integer.Integer -> FractionalExponentBase -> Rational
  notANumber :: Rational
  numerator :: forall a. Ratio a -> a
  numericEnumFrom :: forall a. Fractional a => a -> [a]
  numericEnumFromThen :: forall a. Fractional a => a -> a -> [a]
  numericEnumFromThenTo :: forall a. (GHC.Classes.Ord a, Fractional a) => a -> a -> a -> [a]
  numericEnumFromTo :: forall a. (GHC.Classes.Ord a, Fractional a) => a -> a -> [a]
  odd :: forall a. Integral a => a -> GHC.Types.Bool
  overflowError :: forall a. a
  powImpl :: forall a b. (GHC.Internal.Num.Num a, Integral b) => a -> b -> a
  powImplAcc :: forall a b. (GHC.Internal.Num.Num a, Integral b) => a -> b -> a -> a
  ratioPrec :: GHC.Types.Int
  ratioPrec1 :: GHC.Types.Int
  ratioZeroDenominatorError :: forall a. a
  realToFrac :: forall a b. (Real a, Fractional b) => a -> b
  reduce :: forall a. Integral a => a -> a -> Ratio a
  showSigned :: forall a. Real a => (a -> GHC.Internal.Show.ShowS) -> GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  underflowError :: forall a. a

module GHC.Records where
  -- Safety: Safe
  type HasField :: forall {k} {r_rep :: GHC.Types.RuntimeRep} {a_rep :: GHC.Types.RuntimeRep}. k -> TYPE r_rep -> TYPE a_rep -> Constraint
  class HasField x r a | x r -> a where
    getField :: r -> a
    {-# MINIMAL getField #-}

module GHC.ResponseFile where
  -- Safety: Safe
  escapeArgs :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  expandResponse :: [GHC.Internal.Base.String] -> GHC.Types.IO [GHC.Internal.Base.String]
  getArgsWithResponseFiles :: GHC.Types.IO [GHC.Internal.Base.String]
  unescapeArgs :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]

module GHC.ST where
  -- Safety: None
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ST (STRep s a)
  type STRep :: * -> * -> *
  type STRep s a = GHC.Prim.State# s -> (# GHC.Prim.State# s, a #)
  type role STret nominal representational
  type STret :: * -> * -> *
  data STret s a = STret (GHC.Prim.State# s) a
  liftST :: forall s a. ST s a -> GHC.Prim.State# s -> STret s a
  runST :: forall a. (forall s. ST s a) -> a
  unsafeDupableInterleaveST :: forall s a. ST s a -> ST s a
  unsafeInterleaveST :: forall s a. ST s a -> ST s a

module GHC.STRef where
  -- Safety: None
  type role STRef nominal representational
  type STRef :: * -> * -> *
  data STRef s a = STRef (GHC.Prim.MutVar# s a)
  newSTRef :: forall a s. a -> GHC.Internal.ST.ST s (STRef s a)
  readSTRef :: forall s a. STRef s a -> GHC.Internal.ST.ST s a
  writeSTRef :: forall s a. STRef s a -> a -> GHC.Internal.ST.ST s ()

module GHC.Show where
  -- Safety: Safe
  type Show :: * -> Constraint
  class Show a where
    showsPrec :: GHC.Types.Int -> a -> ShowS
    show :: a -> GHC.Internal.Base.String
    showList :: [a] -> ShowS
    {-# MINIMAL showsPrec | show #-}
  type ShowS :: *
  type ShowS = GHC.Internal.Base.String -> GHC.Internal.Base.String
  appPrec :: GHC.Types.Int
  appPrec1 :: GHC.Types.Int
  asciiTab :: [GHC.Internal.Base.String]
  intToDigit :: GHC.Types.Int -> GHC.Types.Char
  protectEsc :: (GHC.Types.Char -> GHC.Types.Bool) -> ShowS -> ShowS
  showChar :: GHC.Types.Char -> ShowS
  showCommaSpace :: ShowS
  showList__ :: forall a. (a -> ShowS) -> [a] -> ShowS
  showLitChar :: GHC.Types.Char -> ShowS
  showLitString :: GHC.Internal.Base.String -> ShowS
  showMultiLineString :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]
  showParen :: GHC.Types.Bool -> ShowS -> ShowS
  showSignedInt :: GHC.Types.Int -> GHC.Types.Int -> ShowS
  showSpace :: ShowS
  showString :: GHC.Internal.Base.String -> ShowS
  shows :: forall a. Show a => a -> ShowS

module GHC.Stable where
  -- Safety: None
  type StablePtr :: * -> *
  data StablePtr a = StablePtr (GHC.Prim.StablePtr# a)
  castPtrToStablePtr :: forall a. GHC.Internal.Ptr.Ptr () -> StablePtr a
  castStablePtrToPtr :: forall a. StablePtr a -> GHC.Internal.Ptr.Ptr ()
  deRefStablePtr :: forall a. StablePtr a -> GHC.Types.IO a
  freeStablePtr :: forall a. StablePtr a -> GHC.Types.IO ()
  newStablePtr :: forall a. a -> GHC.Types.IO (StablePtr a)

module GHC.StableName where
  -- Safety: Safe
  type role StableName phantom
  type StableName :: * -> *
  data StableName a = StableName (GHC.Prim.StableName# a)
  eqStableName :: forall a b. StableName a -> StableName b -> GHC.Types.Bool
  hashStableName :: forall a. StableName a -> GHC.Types.Int
  makeStableName :: forall a. a -> GHC.Types.IO (StableName a)

module GHC.Stack where
  -- Safety: Safe
  type CallStack :: *
  data CallStack = ...
  type CostCentre :: *
  data CostCentre
  type CostCentreStack :: *
  data CostCentreStack
  type HasCallStack :: Constraint
  type HasCallStack = ?callStack::CallStack :: Constraint
  type SrcLoc :: *
  data SrcLoc = SrcLoc {srcLocPackage :: [GHC.Types.Char], srcLocModule :: [GHC.Types.Char], srcLocFile :: [GHC.Types.Char], srcLocStartLine :: GHC.Types.Int, srcLocStartCol :: GHC.Types.Int, srcLocEndLine :: GHC.Types.Int, srcLocEndCol :: GHC.Types.Int}
  callStack :: HasCallStack => CallStack
  ccLabel :: GHC.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccModule :: GHC.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccSrcSpan :: GHC.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccsCC :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentre)
  ccsParent :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  ccsToStrings :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO [GHC.Internal.Base.String]
  clearCCS :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  currentCallStack :: GHC.Types.IO [GHC.Internal.Base.String]
  emptyCallStack :: CallStack
  errorWithStackTrace :: forall a. GHC.Internal.Base.String -> a
  freezeCallStack :: CallStack -> CallStack
  fromCallSiteList :: [([GHC.Types.Char], SrcLoc)] -> CallStack
  getCCSOf :: forall a. a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  getCallStack :: CallStack -> [([GHC.Types.Char], SrcLoc)]
  getCurrentCCS :: forall dummy. dummy -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  popCallStack :: CallStack -> CallStack
  prettyCallStack :: CallStack -> GHC.Internal.Base.String
  prettySrcLoc :: SrcLoc -> GHC.Internal.Base.String
  pushCallStack :: ([GHC.Types.Char], SrcLoc) -> CallStack -> CallStack
  renderStack :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  whoCreated :: forall a. a -> GHC.Types.IO [GHC.Internal.Base.String]
  withFrozenCallStack :: forall a. HasCallStack => (HasCallStack => a) -> a

module GHC.Stack.CCS where
  -- Safety: Safe
  type CostCentre :: *
  data CostCentre
  type CostCentreStack :: *
  data CostCentreStack
  ccLabel :: GHC.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccModule :: GHC.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccSrcSpan :: GHC.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccsCC :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentre)
  ccsParent :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  ccsToStrings :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO [GHC.Internal.Base.String]
  clearCCS :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  currentCallStack :: GHC.Types.IO [GHC.Internal.Base.String]
  getCCSOf :: forall a. a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  getCurrentCCS :: forall dummy. dummy -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  renderStack :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  whoCreated :: forall a. a -> GHC.Types.IO [GHC.Internal.Base.String]

module GHC.Stack.CloneStack where
  -- Safety: None
  type StackEntry :: *
  data StackEntry = StackEntry {functionName :: GHC.Internal.Base.String, moduleName :: GHC.Internal.Base.String, srcLoc :: GHC.Internal.Base.String, closureType :: GHC.Internal.ClosureTypes.ClosureType}
  type StackSnapshot :: *
  data StackSnapshot = StackSnapshot GHC.Prim.StackSnapshot#
  cloneMyStack :: GHC.Types.IO StackSnapshot
  cloneThreadStack :: GHC.Internal.Conc.Sync.ThreadId -> GHC.Types.IO StackSnapshot
  decode :: StackSnapshot -> GHC.Types.IO [StackEntry]

module GHC.Stack.Types where
  -- Safety: Safe
  type CallStack :: *
  data CallStack = EmptyCallStack | PushCallStack [GHC.Types.Char] SrcLoc CallStack | FreezeCallStack CallStack
  type HasCallStack :: Constraint
  type HasCallStack = ?callStack::CallStack :: Constraint
  type SrcLoc :: *
  data SrcLoc = SrcLoc {srcLocPackage :: [GHC.Types.Char], srcLocModule :: [GHC.Types.Char], srcLocFile :: [GHC.Types.Char], srcLocStartLine :: GHC.Types.Int, srcLocStartCol :: GHC.Types.Int, srcLocEndLine :: GHC.Types.Int, srcLocEndCol :: GHC.Types.Int}
  emptyCallStack :: CallStack
  freezeCallStack :: CallStack -> CallStack
  fromCallSiteList :: [([GHC.Types.Char], SrcLoc)] -> CallStack
  getCallStack :: CallStack -> [([GHC.Types.Char], SrcLoc)]
  pushCallStack :: ([GHC.Types.Char], SrcLoc) -> CallStack -> CallStack

module GHC.StaticPtr where
  -- Safety: None
  type IsStatic :: (* -> *) -> Constraint
  class IsStatic p where
    fromStaticPtr :: forall a. ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a => StaticPtr a -> p a
    {-# MINIMAL fromStaticPtr #-}
  type StaticKey :: *
  type StaticKey = GHC.Internal.Fingerprint.Type.Fingerprint
  type StaticPtr :: * -> *
  data StaticPtr a = ...
  type StaticPtrInfo :: *
  data StaticPtrInfo = StaticPtrInfo {spInfoUnitId :: GHC.Internal.Base.String, spInfoModuleName :: GHC.Internal.Base.String, spInfoSrcLoc :: (GHC.Types.Int, GHC.Types.Int)}
  deRefStaticPtr :: forall a. StaticPtr a -> a
  staticKey :: forall a. StaticPtr a -> StaticKey
  staticPtrInfo :: forall a. StaticPtr a -> StaticPtrInfo
  staticPtrKeys :: GHC.Types.IO [StaticKey]
  unsafeLookupStaticPtr :: forall a. StaticKey -> GHC.Types.IO (GHC.Internal.Maybe.Maybe (StaticPtr a))

module GHC.Stats where
  -- Safety: Safe
  type GCDetails :: *
  data GCDetails
    = GCDetails {gcdetails_gen :: GHC.Internal.Word.Word32,
                 gcdetails_threads :: GHC.Internal.Word.Word32,
                 gcdetails_allocated_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_live_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_large_objects_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_compact_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_slop_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_mem_in_use_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_copied_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_par_max_copied_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_par_balanced_copied_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_block_fragmentation_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_sync_elapsed_ns :: RtsTime,
                 gcdetails_cpu_ns :: RtsTime,
                 gcdetails_elapsed_ns :: RtsTime,
                 gcdetails_nonmoving_gc_sync_cpu_ns :: RtsTime,
                 gcdetails_nonmoving_gc_sync_elapsed_ns :: RtsTime}
  type RTSStats :: *
  data RTSStats
    = RTSStats {gcs :: GHC.Internal.Word.Word32,
                major_gcs :: GHC.Internal.Word.Word32,
                allocated_bytes :: GHC.Internal.Word.Word64,
                max_live_bytes :: GHC.Internal.Word.Word64,
                max_large_objects_bytes :: GHC.Internal.Word.Word64,
                max_compact_bytes :: GHC.Internal.Word.Word64,
                max_slop_bytes :: GHC.Internal.Word.Word64,
                max_mem_in_use_bytes :: GHC.Internal.Word.Word64,
                cumulative_live_bytes :: GHC.Internal.Word.Word64,
                copied_bytes :: GHC.Internal.Word.Word64,
                par_copied_bytes :: GHC.Internal.Word.Word64,
                cumulative_par_max_copied_bytes :: GHC.Internal.Word.Word64,
                cumulative_par_balanced_copied_bytes :: GHC.Internal.Word.Word64,
                init_cpu_ns :: RtsTime,
                init_elapsed_ns :: RtsTime,
                mutator_cpu_ns :: RtsTime,
                mutator_elapsed_ns :: RtsTime,
                gc_cpu_ns :: RtsTime,
                gc_elapsed_ns :: RtsTime,
                cpu_ns :: RtsTime,
                elapsed_ns :: RtsTime,
                nonmoving_gc_sync_cpu_ns :: RtsTime,
                nonmoving_gc_sync_elapsed_ns :: RtsTime,
                nonmoving_gc_sync_max_elapsed_ns :: RtsTime,
                nonmoving_gc_cpu_ns :: RtsTime,
                nonmoving_gc_elapsed_ns :: RtsTime,
                nonmoving_gc_max_elapsed_ns :: RtsTime,
                gc :: GCDetails}
  type RtsTime :: *
  type RtsTime = GHC.Internal.Int.Int64
  getRTSStats :: GHC.Types.IO RTSStats
  getRTSStatsEnabled :: GHC.Types.IO GHC.Types.Bool

module GHC.Storable where
  -- Safety: Safe
  readDoubleOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Double -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Double
  readFloatOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Float -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Float
  readFunPtrOffPtr :: forall a. GHC.Internal.Ptr.Ptr (GHC.Internal.Ptr.FunPtr a) -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.FunPtr a)
  readInt16OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Int.Int16 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Int.Int16
  readInt32OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Int.Int32 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Int.Int32
  readInt64OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Int.Int64 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Int.Int64
  readInt8OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Int.Int8 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Int.Int8
  readIntOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Int -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  readPtrOffPtr :: forall a. GHC.Internal.Ptr.Ptr (GHC.Internal.Ptr.Ptr a) -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  readStablePtrOffPtr :: forall a. GHC.Internal.Ptr.Ptr (GHC.Internal.Stable.StablePtr a) -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Stable.StablePtr a)
  readWideCharOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Char -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Char
  readWord16OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word16 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Word.Word16
  readWord32OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word32 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Word.Word32
  readWord64OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Word.Word64
  readWord8OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Word.Word8
  readWordOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Word -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Word
  writeDoubleOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Double -> GHC.Types.Int -> GHC.Types.Double -> GHC.Types.IO ()
  writeFloatOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Float -> GHC.Types.Int -> GHC.Types.Float -> GHC.Types.IO ()
  writeFunPtrOffPtr :: forall a. GHC.Internal.Ptr.Ptr (GHC.Internal.Ptr.FunPtr a) -> GHC.Types.Int -> GHC.Internal.Ptr.FunPtr a -> GHC.Types.IO ()
  writeInt16OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Int.Int16 -> GHC.Types.Int -> GHC.Internal.Int.Int16 -> GHC.Types.IO ()
  writeInt32OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Int.Int32 -> GHC.Types.Int -> GHC.Internal.Int.Int32 -> GHC.Types.IO ()
  writeInt64OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Int.Int64 -> GHC.Types.Int -> GHC.Internal.Int.Int64 -> GHC.Types.IO ()
  writeInt8OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Int.Int8 -> GHC.Types.Int -> GHC.Internal.Int.Int8 -> GHC.Types.IO ()
  writeIntOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Types.IO ()
  writePtrOffPtr :: forall a. GHC.Internal.Ptr.Ptr (GHC.Internal.Ptr.Ptr a) -> GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ()
  writeStablePtrOffPtr :: forall a. GHC.Internal.Ptr.Ptr (GHC.Internal.Stable.StablePtr a) -> GHC.Types.Int -> GHC.Internal.Stable.StablePtr a -> GHC.Types.IO ()
  writeWideCharOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Char -> GHC.Types.Int -> GHC.Types.Char -> GHC.Types.IO ()
  writeWord16OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word16 -> GHC.Types.Int -> GHC.Internal.Word.Word16 -> GHC.Types.IO ()
  writeWord32OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word32 -> GHC.Types.Int -> GHC.Internal.Word.Word32 -> GHC.Types.IO ()
  writeWord64OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word64 -> GHC.Types.Int -> GHC.Internal.Word.Word64 -> GHC.Types.IO ()
  writeWord8OffPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Internal.Word.Word8 -> GHC.Types.IO ()
  writeWordOffPtr :: GHC.Internal.Ptr.Ptr GHC.Types.Word -> GHC.Types.Int -> GHC.Types.Word -> GHC.Types.IO ()

module GHC.TopHandler where
  -- Safety: Safe
  flushStdHandles :: GHC.Types.IO ()
  reportError :: GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()
  reportStackOverflow :: GHC.Types.IO ()
  runIO :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  runIOFastExit :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  runMainIO :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  runNonIO :: forall a. a -> GHC.Types.IO a
  topHandler :: forall a. GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO a
  topHandlerFastExit :: forall a. GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO a

module GHC.TypeError where
  -- Safety: Safe
  type Assert :: GHC.Types.Bool -> Constraint -> Constraint
  type family Assert check errMsg where
    forall (_1 :: Constraint). Assert GHC.Types.True _1 = () :: Constraint
    forall (_1 :: GHC.Types.Bool) (errMsg :: Constraint). Assert _1 errMsg = errMsg
  type ErrorMessage :: *
  data ErrorMessage = Text GHC.Types.Symbol | forall t. ShowType t | ErrorMessage :<>: ErrorMessage | ErrorMessage :$$: ErrorMessage
  type TypeError :: forall b. ErrorMessage -> b
  type family TypeError a where
  type Unsatisfiable :: ErrorMessage -> Constraint
  class Unsatisfiable msg where
    ...
    {-# MINIMAL GHC.Internal.TypeError.unsatisfiableLifted #-}
  unsatisfiable :: forall {rep :: GHC.Types.RuntimeRep} (msg :: ErrorMessage) (a :: TYPE rep). Unsatisfiable msg => a

module GHC.TypeLits where
  -- Safety: Safe
  type (*) :: Natural -> Natural -> Natural
  type family (*) a b
  type (+) :: Natural -> Natural -> Natural
  type family (+) a b
  type (-) :: Natural -> Natural -> Natural
  type family (-) a b
  type (<=) :: forall {t}. t -> t -> Constraint
  type (<=) x y = GHC.Internal.TypeError.Assert (x <=? y) (GHC.Internal.Data.Type.Ord.LeErrMsg x y) :: Constraint
  type (<=?) :: forall k. k -> k -> GHC.Types.Bool
  type (<=?) m n = GHC.Internal.Data.Type.Ord.OrdCond (GHC.Internal.Data.Type.Ord.Compare m n) GHC.Types.True GHC.Types.True GHC.Types.False :: GHC.Types.Bool
  type AppendSymbol :: Symbol -> Symbol -> Symbol
  type family AppendSymbol a b
  type CharToNat :: GHC.Types.Char -> Natural
  type family CharToNat a
  type CmpChar :: GHC.Types.Char -> GHC.Types.Char -> GHC.Types.Ordering
  type family CmpChar a b
  type CmpNat :: Natural -> Natural -> GHC.Types.Ordering
  type family CmpNat a b
  type CmpSymbol :: Symbol -> Symbol -> GHC.Types.Ordering
  type family CmpSymbol a b
  type ConsSymbol :: GHC.Types.Char -> Symbol -> Symbol
  type family ConsSymbol a b
  type Div :: Natural -> Natural -> Natural
  type family Div a b
  type ErrorMessage :: *
  data ErrorMessage = Text Symbol | forall t. ShowType t | ErrorMessage :<>: ErrorMessage | ErrorMessage :$$: ErrorMessage
  type KnownChar :: GHC.Types.Char -> Constraint
  class KnownChar n where
    charSing :: SChar n
    {-# MINIMAL charSing #-}
  type KnownNat :: Nat -> Constraint
  class KnownNat n where
    natSing :: SNat n
    {-# MINIMAL natSing #-}
  type KnownSymbol :: Symbol -> Constraint
  class KnownSymbol n where
    symbolSing :: SSymbol n
    {-# MINIMAL symbolSing #-}
  type Log2 :: Natural -> Natural
  type family Log2 a
  type Mod :: Natural -> Natural -> Natural
  type family Mod a b
  type Nat :: *
  type Nat = Natural
  type NatToChar :: Natural -> GHC.Types.Char
  type family NatToChar a
  type Natural :: *
  data Natural = ...
  type role OrderingI nominal nominal
  type OrderingI :: forall {k}. k -> k -> *
  data OrderingI a b where
    LTI :: forall {k} (a :: k) (b :: k). (GHC.Internal.Data.Type.Ord.Compare a b ~ GHC.Types.LT) => OrderingI a b
    EQI :: forall {k} (a :: k). (GHC.Internal.Data.Type.Ord.Compare a a ~ GHC.Types.EQ) => OrderingI a a
    GTI :: forall {k} (a :: k) (b :: k). (GHC.Internal.Data.Type.Ord.Compare a b ~ GHC.Types.GT) => OrderingI a b
  pattern SChar :: forall (c :: GHC.Types.Char). () => KnownChar c => SChar c
  type role SChar nominal
  type SChar :: GHC.Types.Char -> *
  newtype SChar s = ...
  pattern SNat :: forall (n :: Nat). () => KnownNat n => SNat n
  type role SNat nominal
  type SNat :: Nat -> *
  newtype SNat n = ...
  pattern SSymbol :: forall (s :: Symbol). () => KnownSymbol s => SSymbol s
  type role SSymbol nominal
  type SSymbol :: Symbol -> *
  newtype SSymbol s = ...
  type SomeChar :: *
  data SomeChar = forall (n :: GHC.Types.Char). KnownChar n => SomeChar (GHC.Internal.Data.Proxy.Proxy n)
  type SomeNat :: *
  data SomeNat = forall (n :: Nat). KnownNat n => SomeNat (GHC.Internal.Data.Proxy.Proxy n)
  type SomeSymbol :: *
  data SomeSymbol = forall (n :: Symbol). KnownSymbol n => SomeSymbol (GHC.Internal.Data.Proxy.Proxy n)
  type Symbol :: *
  data Symbol
  type TypeError :: forall b. ErrorMessage -> b
  type family TypeError a where
  type UnconsSymbol :: Symbol -> GHC.Internal.Maybe.Maybe (GHC.Types.Char, Symbol)
  type family UnconsSymbol a
  type (^) :: Natural -> Natural -> Natural
  type family (^) a b
  charVal :: forall (n :: GHC.Types.Char) (proxy :: GHC.Types.Char -> *). KnownChar n => proxy n -> GHC.Types.Char
  charVal' :: forall (n :: GHC.Types.Char). KnownChar n => GHC.Prim.Proxy# n -> GHC.Types.Char
  cmpChar :: forall (a :: GHC.Types.Char) (b :: GHC.Types.Char) (proxy1 :: GHC.Types.Char -> *) (proxy2 :: GHC.Types.Char -> *). (KnownChar a, KnownChar b) => proxy1 a -> proxy2 b -> OrderingI a b
  cmpNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> OrderingI a b
  cmpSymbol :: forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *) (proxy2 :: Symbol -> *). (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> OrderingI a b
  decideChar :: forall (a :: GHC.Types.Char) (b :: GHC.Types.Char) (proxy1 :: GHC.Types.Char -> *) (proxy2 :: GHC.Types.Char -> *). (KnownChar a, KnownChar b) => proxy1 a -> proxy2 b -> GHC.Internal.Data.Either.Either ((a GHC.Internal.Data.Type.Equality.:~: b) -> GHC.Internal.Base.Void) (a GHC.Internal.Data.Type.Equality.:~: b)
  decideNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Internal.Data.Either.Either ((a GHC.Internal.Data.Type.Equality.:~: b) -> GHC.Internal.Base.Void) (a GHC.Internal.Data.Type.Equality.:~: b)
  decideSymbol :: forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *) (proxy2 :: Symbol -> *). (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> GHC.Internal.Data.Either.Either ((a GHC.Internal.Data.Type.Equality.:~: b) -> GHC.Internal.Base.Void) (a GHC.Internal.Data.Type.Equality.:~: b)
  fromSChar :: forall (c :: GHC.Types.Char). SChar c -> GHC.Types.Char
  fromSNat :: forall (n :: Nat). SNat n -> GHC.Num.Integer.Integer
  fromSSymbol :: forall (s :: Symbol). SSymbol s -> GHC.Internal.Base.String
  natVal :: forall (n :: Nat) (proxy :: Nat -> *). KnownNat n => proxy n -> GHC.Num.Integer.Integer
  natVal' :: forall (n :: Nat). KnownNat n => GHC.Prim.Proxy# n -> GHC.Num.Integer.Integer
  sameChar :: forall (a :: GHC.Types.Char) (b :: GHC.Types.Char) (proxy1 :: GHC.Types.Char -> *) (proxy2 :: GHC.Types.Char -> *). (KnownChar a, KnownChar b) => proxy1 a -> proxy2 b -> GHC.Internal.Maybe.Maybe (a GHC.Internal.Data.Type.Equality.:~: b)
  sameNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Internal.Maybe.Maybe (a GHC.Internal.Data.Type.Equality.:~: b)
  sameSymbol :: forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *) (proxy2 :: Symbol -> *). (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> GHC.Internal.Maybe.Maybe (a GHC.Internal.Data.Type.Equality.:~: b)
  someCharVal :: GHC.Types.Char -> SomeChar
  someNatVal :: GHC.Num.Integer.Integer -> GHC.Internal.Maybe.Maybe SomeNat
  someSymbolVal :: GHC.Internal.Base.String -> SomeSymbol
  symbolVal :: forall (n :: Symbol) (proxy :: Symbol -> *). KnownSymbol n => proxy n -> GHC.Internal.Base.String
  symbolVal' :: forall (n :: Symbol). KnownSymbol n => GHC.Prim.Proxy# n -> GHC.Internal.Base.String
  withKnownChar :: forall (c :: GHC.Types.Char) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). SChar c -> (KnownChar c => r) -> r
  withKnownNat :: forall (n :: Nat) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). SNat n -> (KnownNat n => r) -> r
  withKnownSymbol :: forall (s :: Symbol) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). SSymbol s -> (KnownSymbol s => r) -> r
  withSomeSChar :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). GHC.Types.Char -> (forall (c :: GHC.Types.Char). SChar c -> r) -> r
  withSomeSNat :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). GHC.Num.Integer.Integer -> (forall (n :: Nat). GHC.Internal.Maybe.Maybe (SNat n) -> r) -> r
  withSomeSSymbol :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). GHC.Internal.Base.String -> (forall (s :: Symbol). SSymbol s -> r) -> r

module GHC.TypeLits.Internal where
  -- Safety: Safe
  type CmpChar :: GHC.Types.Char -> GHC.Types.Char -> GHC.Types.Ordering
  type family CmpChar a b
  type CmpSymbol :: Symbol -> Symbol -> GHC.Types.Ordering
  type family CmpSymbol a b
  type Symbol :: *
  data Symbol

module GHC.TypeNats where
  -- Safety: Safe
  type (*) :: Natural -> Natural -> Natural
  type family (*) a b
  type (+) :: Natural -> Natural -> Natural
  type family (+) a b
  type (-) :: Natural -> Natural -> Natural
  type family (-) a b
  type (<=) :: forall {t}. t -> t -> Constraint
  type (<=) x y = GHC.Internal.TypeError.Assert (x <=? y) (GHC.Internal.Data.Type.Ord.LeErrMsg x y) :: Constraint
  type (<=?) :: forall k. k -> k -> GHC.Types.Bool
  type (<=?) m n = GHC.Internal.Data.Type.Ord.OrdCond (GHC.Internal.Data.Type.Ord.Compare m n) GHC.Types.True GHC.Types.True GHC.Types.False :: GHC.Types.Bool
  type CmpNat :: Natural -> Natural -> GHC.Types.Ordering
  type family CmpNat a b
  type Div :: Natural -> Natural -> Natural
  type family Div a b
  type KnownNat :: Nat -> Constraint
  class KnownNat n where
    natSing :: SNat n
    {-# MINIMAL natSing #-}
  type Log2 :: Natural -> Natural
  type family Log2 a
  type Mod :: Natural -> Natural -> Natural
  type family Mod a b
  type Nat :: *
  type Nat = Natural
  type Natural :: *
  data Natural = ...
  pattern SNat :: forall (n :: Nat). () => KnownNat n => SNat n
  type role SNat nominal
  type SNat :: Nat -> *
  newtype SNat n = ...
  type SomeNat :: *
  data SomeNat = forall (n :: Nat). KnownNat n => SomeNat (GHC.Internal.Data.Proxy.Proxy n)
  type (^) :: Natural -> Natural -> Natural
  type family (^) a b
  cmpNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Internal.Data.Type.Ord.OrderingI a b
  decideNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Internal.Data.Either.Either ((a GHC.Internal.Data.Type.Equality.:~: b) -> GHC.Internal.Base.Void) (a GHC.Internal.Data.Type.Equality.:~: b)
  fromSNat :: forall (n :: Nat). SNat n -> Natural
  natVal :: forall (n :: Nat) (proxy :: Nat -> *). KnownNat n => proxy n -> Natural
  natVal' :: forall (n :: Nat). KnownNat n => GHC.Prim.Proxy# n -> Natural
  sameNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Internal.Maybe.Maybe (a GHC.Internal.Data.Type.Equality.:~: b)
  someNatVal :: Natural -> SomeNat
  withKnownNat :: forall (n :: Nat) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). SNat n -> (KnownNat n => r) -> r
  withSomeSNat :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). Natural -> (forall (n :: Nat). SNat n -> r) -> r

module GHC.TypeNats.Internal where
  -- Safety: Safe
  type CmpNat :: Natural -> Natural -> GHC.Types.Ordering
  type family CmpNat a b
  type Natural :: *
  data Natural = ...

module GHC.Unicode where
  -- Safety: Safe
  type GeneralCategory :: *
  data GeneralCategory = UppercaseLetter | LowercaseLetter | TitlecaseLetter | ModifierLetter | OtherLetter | NonSpacingMark | SpacingCombiningMark | EnclosingMark | DecimalNumber | LetterNumber | OtherNumber | ConnectorPunctuation | DashPunctuation | OpenPunctuation | ClosePunctuation | InitialQuote | FinalQuote | OtherPunctuation | MathSymbol | CurrencySymbol | ModifierSymbol | OtherSymbol | Space | LineSeparator | ParagraphSeparator | Control | Format | Surrogate | PrivateUse | NotAssigned
  generalCategory :: GHC.Types.Char -> GeneralCategory
  isAlpha :: GHC.Types.Char -> GHC.Types.Bool
  isAlphaNum :: GHC.Types.Char -> GHC.Types.Bool
  isAscii :: GHC.Types.Char -> GHC.Types.Bool
  isAsciiLower :: GHC.Types.Char -> GHC.Types.Bool
  isAsciiUpper :: GHC.Types.Char -> GHC.Types.Bool
  isControl :: GHC.Types.Char -> GHC.Types.Bool
  isDigit :: GHC.Types.Char -> GHC.Types.Bool
  isHexDigit :: GHC.Types.Char -> GHC.Types.Bool
  isLatin1 :: GHC.Types.Char -> GHC.Types.Bool
  isLower :: GHC.Types.Char -> GHC.Types.Bool
  isLowerCase :: GHC.Types.Char -> GHC.Types.Bool
  isOctDigit :: GHC.Types.Char -> GHC.Types.Bool
  isPrint :: GHC.Types.Char -> GHC.Types.Bool
  isPunctuation :: GHC.Types.Char -> GHC.Types.Bool
  isSpace :: GHC.Types.Char -> GHC.Types.Bool
  isSymbol :: GHC.Types.Char -> GHC.Types.Bool
  isUpper :: GHC.Types.Char -> GHC.Types.Bool
  isUpperCase :: GHC.Types.Char -> GHC.Types.Bool
  toLower :: GHC.Types.Char -> GHC.Types.Char
  toTitle :: GHC.Types.Char -> GHC.Types.Char
  toUpper :: GHC.Types.Char -> GHC.Types.Char
  unicodeVersion :: GHC.Internal.Data.Version.Version

module GHC.Weak where
  -- Safety: None
  type Weak :: * -> *
  data Weak v = Weak (GHC.Prim.Weak# v)
  deRefWeak :: forall v. Weak v -> GHC.Types.IO (GHC.Internal.Maybe.Maybe v)
  finalize :: forall v. Weak v -> GHC.Types.IO ()
  getFinalizerExceptionHandler :: GHC.Types.IO (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ())
  mkWeak :: forall k v. k -> v -> GHC.Internal.Maybe.Maybe (GHC.Types.IO ()) -> GHC.Types.IO (Weak v)
  printToHandleFinalizerExceptionHandler :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()
  setFinalizerExceptionHandler :: (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()

module GHC.Weak.Finalize where
  -- Safety: None
  getFinalizerExceptionHandler :: GHC.Types.IO (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ())
  printToHandleFinalizerExceptionHandler :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()
  runFinalizerBatch :: GHC.Types.Int -> GHC.Prim.Array# (GHC.Prim.State# GHC.Prim.RealWorld -> GHC.Prim.State# GHC.Prim.RealWorld) -> GHC.Types.IO ()
  setFinalizerExceptionHandler :: (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()

module GHC.Word where
  -- Safety: Safe
  type Word :: *
  data Word = W# GHC.Prim.Word#
  type Word16 :: *
  data Word16 = W16# GHC.Prim.Word16#
  type Word32 :: *
  data Word32 = W32# GHC.Prim.Word32#
  type Word64 :: *
  data Word64 = W64# GHC.Prim.Word64#
  type Word8 :: *
  data Word8 = W8# GHC.Prim.Word8#
  bitReverse16 :: Word16 -> Word16
  bitReverse32 :: Word32 -> Word32
  bitReverse64 :: Word64 -> Word64
  bitReverse8 :: Word8 -> Word8
  byteSwap16 :: Word16 -> Word16
  byteSwap32 :: Word32 -> Word32
  byteSwap64 :: Word64 -> Word64
  eqWord :: Word -> Word -> GHC.Types.Bool
  eqWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  eqWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  eqWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  eqWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  geWord :: Word -> Word -> GHC.Types.Bool
  geWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  geWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  geWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  geWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  gtWord :: Word -> Word -> GHC.Types.Bool
  gtWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  gtWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  gtWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  gtWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  leWord :: Word -> Word -> GHC.Types.Bool
  leWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  leWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  leWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  leWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  ltWord :: Word -> Word -> GHC.Types.Bool
  ltWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  ltWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  ltWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  ltWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  neWord :: Word -> Word -> GHC.Types.Bool
  neWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  neWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  neWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  neWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  uncheckedShiftL64# :: GHC.Prim.Word64# -> GHC.Prim.Int# -> GHC.Prim.Word64#
  uncheckedShiftRL64# :: GHC.Prim.Word64# -> GHC.Prim.Int# -> GHC.Prim.Word64#

module Numeric where
  -- Safety: Safe
  type Floating :: * -> Constraint
  class GHC.Internal.Real.Fractional a => Floating a where
    pi :: a
    exp :: a -> a
    log :: a -> a
    sqrt :: a -> a
    (**) :: a -> a -> a
    logBase :: a -> a -> a
    sin :: a -> a
    cos :: a -> a
    tan :: a -> a
    asin :: a -> a
    acos :: a -> a
    atan :: a -> a
    sinh :: a -> a
    cosh :: a -> a
    tanh :: a -> a
    asinh :: a -> a
    acosh :: a -> a
    atanh :: a -> a
    log1p :: a -> a
    expm1 :: a -> a
    log1pexp :: a -> a
    log1mexp :: a -> a
    {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh #-}
  floatToDigits :: forall a. GHC.Internal.Float.RealFloat a => GHC.Num.Integer.Integer -> a -> ([GHC.Types.Int], GHC.Types.Int)
  fromRat :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Real.Rational -> a
  lexDigits :: GHC.Internal.Text.ParserCombinators.ReadP.ReadS GHC.Internal.Base.String
  readBin :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readDec :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readFloat :: forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readHex :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readInt :: forall a. GHC.Internal.Num.Num a => a -> (GHC.Types.Char -> GHC.Types.Bool) -> (GHC.Types.Char -> GHC.Types.Int) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readOct :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readSigned :: forall a. GHC.Internal.Real.Real a => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  showBin :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Internal.Show.ShowS
  showEFloat :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showFFloat :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showFFloatAlt :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showFloat :: forall a. GHC.Internal.Float.RealFloat a => a -> GHC.Internal.Show.ShowS
  showGFloat :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showGFloatAlt :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showHFloat :: forall a. GHC.Internal.Float.RealFloat a => a -> GHC.Internal.Show.ShowS
  showHex :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Internal.Show.ShowS
  showInt :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Internal.Show.ShowS
  showIntAtBase :: forall a. GHC.Internal.Real.Integral a => a -> (GHC.Types.Int -> GHC.Types.Char) -> a -> GHC.Internal.Show.ShowS
  showOct :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Internal.Show.ShowS
  showSigned :: forall a. GHC.Internal.Real.Real a => (a -> GHC.Internal.Show.ShowS) -> GHC.Types.Int -> a -> GHC.Internal.Show.ShowS

module Numeric.Natural where
  -- Safety: Safe
  type Natural :: *
  data Natural = ...
  minusNaturalMaybe :: Natural -> Natural -> GHC.Internal.Maybe.Maybe Natural

module Prelude where
  -- Safety: Trustworthy
  (!!) :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> Int -> a
  ($) :: forall (repa :: GHC.Types.RuntimeRep) (repb :: GHC.Types.RuntimeRep) (a :: TYPE repa) (b :: TYPE repb). (a -> b) -> a -> b
  ($!) :: forall (r :: GHC.Types.RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
  (&&) :: Bool -> Bool -> Bool
  (++) :: forall a. [a] -> [a] -> [a]
  (.) :: forall b c a. (b -> c) -> (a -> b) -> a -> c
  (<$>) :: forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
  (=<<) :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
  type Applicative :: (* -> *) -> Constraint
  class Functor f => Applicative f where
    pure :: forall a. a -> f a
    (<*>) :: forall a b. f (a -> b) -> f a -> f b
    liftA2 :: forall a b c. (a -> b -> c) -> f a -> f b -> f c
    (*>) :: forall a b. f a -> f b -> f b
    (<*) :: forall a b. f a -> f b -> f a
    {-# MINIMAL pure, ((<*>) | liftA2) #-}
  type Bool :: *
  data Bool = False | True
  type Bounded :: * -> Constraint
  class Bounded a where
    minBound :: a
    maxBound :: a
    {-# MINIMAL minBound, maxBound #-}
  type Char :: *
  data Char = ...
  type Double :: *
  data Double = ...
  type Either :: * -> * -> *
  data Either a b = Left a | Right b
  type Enum :: * -> Constraint
  class Enum a where
    succ :: a -> a
    pred :: a -> a
    toEnum :: Int -> a
    fromEnum :: a -> Int
    enumFrom :: a -> [a]
    enumFromThen :: a -> a -> [a]
    enumFromTo :: a -> a -> [a]
    enumFromThenTo :: a -> a -> a -> [a]
    {-# MINIMAL toEnum, fromEnum #-}
  type Eq :: * -> Constraint
  class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool
    {-# MINIMAL (==) | (/=) #-}
  type FilePath :: *
  type FilePath = String
  type Float :: *
  data Float = ...
  type Floating :: * -> Constraint
  class Fractional a => Floating a where
    pi :: a
    exp :: a -> a
    log :: a -> a
    sqrt :: a -> a
    (**) :: a -> a -> a
    logBase :: a -> a -> a
    sin :: a -> a
    cos :: a -> a
    tan :: a -> a
    asin :: a -> a
    acos :: a -> a
    atan :: a -> a
    sinh :: a -> a
    cosh :: a -> a
    tanh :: a -> a
    asinh :: a -> a
    acosh :: a -> a
    atanh :: a -> a
    ...