    {-# LINE 1 "libraries/base/GHC/RTS/Flags.hsc" #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE NoImplicitPrelude #-}

    -- | Accessors to GHC RTS flags.
    -- Descriptions of flags can be seen in
    -- <https://www.haskell.org/ghc/docs/latest/html/users_guide/runtime_control.html GHC User's Guide>,
    -- or by running RTS help message using @+RTS --help@.
    --
    -- @since 4.8.0.0
    --
    module GHC.RTS.Flags
      ( RtsTime
      , RTSFlags (..)
      , GiveGCStats (..)
      , GCFlags (..)
      , ConcFlags (..)
      , MiscFlags (..)
      , DebugFlags (..)
      , DoCostCentres (..)
      , CCFlags (..)
      , DoHeapProfile (..)
      , ProfFlags (..)
      , DoTrace (..)
      , TraceFlags (..)
      , TickyFlags (..)
      , ParFlags (..)
      , IoSubSystem (..)
      , getRTSFlags
      , getGCFlags
      , getConcFlags
      , getMiscFlags
      , getIoManagerFlag
      , getDebugFlags
      , getCCFlags
      , getProfFlags
      , getTraceFlags
      , getTickyFlags
      , getParFlags
      ) where

    import Data.Functor ((<$>))

    import Foreign
    import Foreign.C

    import GHC.Base
    import GHC.Enum
    import GHC.Generics (Generic)
    import GHC.IO
    import GHC.Real
    import GHC.Show

    -- | 'RtsTime' is defined as a @StgWord64@ in @stg/Types.h@
    --
    -- @since 4.8.2.0
    type RtsTime = Word64

    -- | Should we produce a summary of the garbage collector statistics after the
    -- program has exited?
    --
    -- @since 4.8.2.0
    data GiveGCStats
        = NoGCStats
        | CollectGCStats
        | OneLineGCStats
        | SummaryGCStats
        | VerboseGCStats
        deriving ( Show -- ^ @since 4.8.0.0
                 , Generic -- ^ @since 4.15.0.0
                 )

    -- | @since 4.8.0.0
    instance Enum GiveGCStats where
        fromEnum NoGCStats      = 0
    {-# LINE 78 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum CollectGCStats = 1
    {-# LINE 79 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum OneLineGCStats = 2
    {-# LINE 80 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum SummaryGCStats = 3
    {-# LINE 81 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum VerboseGCStats = 4
    {-# LINE 82 "libraries/base/GHC/RTS/Flags.hsc" #-}

        toEnum 0      = NoGCStats
    {-# LINE 84 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 1 = CollectGCStats
    {-# LINE 85 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 2 = OneLineGCStats
    {-# LINE 86 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 3 = SummaryGCStats
    {-# LINE 87 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 4 = VerboseGCStats
    {-# LINE 88 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum e = errorWithoutStackTrace ("invalid enum for GiveGCStats: " ++ show e)

    -- | The I/O SubSystem to use in the program.
    --
    -- @since 4.9.0.0
    data IoSubSystem
      = IoPOSIX   -- ^ Use a POSIX I/O Sub-System
      | IoNative  -- ^ Use platform native Sub-System. For unix OSes this is the
                  --   same as IoPOSIX, but on Windows this means use the Windows
                  --   native APIs for I/O, including IOCP and RIO.
      deriving (Eq, Show)

    -- | @since 4.9.0.0
    instance Enum IoSubSystem where
        fromEnum IoPOSIX  = 1
    {-# LINE 103 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum IoNative = 0
    {-# LINE 104 "libraries/base/GHC/RTS/Flags.hsc" #-}

        toEnum 1  = IoPOSIX
    {-# LINE 106 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 0 = IoNative
    {-# LINE 107 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum e = errorWithoutStackTrace ("invalid enum for IoSubSystem: " ++ show e)

    -- | @since 4.9.0.0
    instance Storable IoSubSystem where
        sizeOf = sizeOf . fromEnum
        alignment = sizeOf . fromEnum
        peek ptr = fmap toEnum $ peek (castPtr ptr)
        poke ptr v = poke (castPtr ptr) (fromEnum v)

    -- | Parameters of the garbage collector.
    --
    -- @since 4.8.0.0
    data GCFlags = GCFlags
        { statsFile             :: Maybe FilePath
        , giveStats             :: GiveGCStats
        , maxStkSize            :: Word32
        , initialStkSize        :: Word32
        , stkChunkSize          :: Word32
        , stkChunkBufferSize    :: Word32
        , maxHeapSize           :: Word32
        , minAllocAreaSize      :: Word32
        , largeAllocLim         :: Word32
        , nurseryChunkSize      :: Word32
        , minOldGenSize         :: Word32
        , heapSizeSuggestion    :: Word32
        , heapSizeSuggestionAuto :: Bool
        , oldGenFactor          :: Double
        , returnDecayFactor     :: Double
        , pcFreeHeap            :: Double
        , generations           :: Word32
        , squeezeUpdFrames      :: Bool
        , compact               :: Bool -- ^ True <=> "compact all the time"
        , compactThreshold      :: Double
        , sweep                 :: Bool
          -- ^ use "mostly mark-sweep" instead of copying for the oldest generation
        , ringBell              :: Bool
        , idleGCDelayTime       :: RtsTime
        , doIdleGC              :: Bool
        , heapBase              :: Word -- ^ address to ask the OS for memory
        , allocLimitGrace       :: Word
        , numa                  :: Bool
        , numaMask              :: Word
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    -- | Parameters concerning context switching
    --
    -- @since 4.8.0.0
    data ConcFlags = ConcFlags
        { ctxtSwitchTime  :: RtsTime
        , ctxtSwitchTicks :: Int
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    -- | Miscellaneous parameters
    --
    -- @since 4.8.0.0
    data MiscFlags = MiscFlags
        { tickInterval          :: RtsTime
        , installSignalHandlers :: Bool
        , installSEHHandlers    :: Bool
        , generateCrashDumpFile :: Bool
        , generateStackTrace    :: Bool
        , machineReadable       :: Bool
        , disableDelayedOsMemoryReturn :: Bool
        , internalCounters      :: Bool
        , linkerAlwaysPic       :: Bool
        , linkerMemBase         :: Word
          -- ^ address to ask the OS for memory for the linker, 0 ==> off
        , ioManager             :: IoSubSystem
        , numIoWorkerThreads    :: Word32
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    -- | Flags to control debugging output & extra checking in various
    -- subsystems.
    --
    -- @since 4.8.0.0
    data DebugFlags = DebugFlags
        { scheduler      :: Bool -- ^ @s@
        , interpreter    :: Bool -- ^ @i@
        , weak           :: Bool -- ^ @w@
        , gccafs         :: Bool -- ^ @G@
        , gc             :: Bool -- ^ @g@
        , nonmoving_gc   :: Bool -- ^ @n@
        , block_alloc    :: Bool -- ^ @b@
        , sanity         :: Bool -- ^ @S@
        , stable         :: Bool -- ^ @t@
        , prof           :: Bool -- ^ @p@
        , linker         :: Bool -- ^ @l@ the object linker
        , apply          :: Bool -- ^ @a@
        , stm            :: Bool -- ^ @m@
        , squeeze        :: Bool -- ^ @z@ stack squeezing & lazy blackholing
        , hpc            :: Bool -- ^ @c@ coverage
        , sparks         :: Bool -- ^ @r@
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    -- | Should the RTS produce a cost-center summary?
    --
    -- @since 4.8.2.0
    data DoCostCentres
        = CostCentresNone
        | CostCentresSummary
        | CostCentresVerbose
        | CostCentresAll
        | CostCentresJSON
        deriving ( Show -- ^ @since 4.8.0.0
                 , Generic -- ^ @since 4.15.0.0
                 )

    -- | @since 4.8.0.0
    instance Enum DoCostCentres where
        fromEnum CostCentresNone    = 0
    {-# LINE 225 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum CostCentresSummary = 1
    {-# LINE 226 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum CostCentresVerbose = 2
    {-# LINE 227 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum CostCentresAll     = 3
    {-# LINE 228 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum CostCentresJSON    = 4
    {-# LINE 229 "libraries/base/GHC/RTS/Flags.hsc" #-}

        toEnum 0    = CostCentresNone
    {-# LINE 231 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 1 = CostCentresSummary
    {-# LINE 232 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 2 = CostCentresVerbose
    {-# LINE 233 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 3     = CostCentresAll
    {-# LINE 234 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 4    = CostCentresJSON
    {-# LINE 235 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum e = errorWithoutStackTrace ("invalid enum for DoCostCentres: " ++ show e)

    -- | Parameters pertaining to the cost-center profiler.
    --
    -- @since 4.8.0.0
    data CCFlags = CCFlags
        { doCostCentres :: DoCostCentres
        , profilerTicks :: Int
        , msecsPerTick  :: Int
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    -- | What sort of heap profile are we collecting?
    --
    -- @since 4.8.2.0
    data DoHeapProfile
        = NoHeapProfiling
        | HeapByCCS
        | HeapByMod
        | HeapByDescr
        | HeapByType
        | HeapByRetainer
        | HeapByLDV
        | HeapByClosureType
        | HeapByInfoTable
        deriving ( Show -- ^ @since 4.8.0.0
                 , Generic -- ^ @since 4.15.0.0
                 )

    -- | @since 4.8.0.0
    instance Enum DoHeapProfile where
        fromEnum NoHeapProfiling   = 0
    {-# LINE 268 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum HeapByCCS         = 1
    {-# LINE 269 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum HeapByMod         = 2
    {-# LINE 270 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum HeapByDescr       = 4
    {-# LINE 271 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum HeapByType        = 5
    {-# LINE 272 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum HeapByRetainer    = 6
    {-# LINE 273 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum HeapByLDV         = 7
    {-# LINE 274 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum HeapByClosureType = 8
    {-# LINE 275 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum HeapByInfoTable   = 9
    {-# LINE 276 "libraries/base/GHC/RTS/Flags.hsc" #-}

        toEnum 0    = NoHeapProfiling
    {-# LINE 278 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 1          = HeapByCCS
    {-# LINE 279 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 2          = HeapByMod
    {-# LINE 280 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 4        = HeapByDescr
    {-# LINE 281 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 5         = HeapByType
    {-# LINE 282 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 6     = HeapByRetainer
    {-# LINE 283 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 7          = HeapByLDV
    {-# LINE 284 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 8 = HeapByClosureType
    {-# LINE 285 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 9   = HeapByInfoTable
    {-# LINE 286 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum e = errorWithoutStackTrace ("invalid enum for DoHeapProfile: " ++ show e)

    -- | Parameters of the cost-center profiler
    --
    -- @since 4.8.0.0
    data ProfFlags = ProfFlags
        { doHeapProfile            :: DoHeapProfile
        , heapProfileInterval      :: RtsTime -- ^ time between samples
        , heapProfileIntervalTicks :: Word    -- ^ ticks between samples (derived)
        , startHeapProfileAtStartup :: Bool
        , showCCSOnException       :: Bool
        , maxRetainerSetSize       :: Word
        , ccsLength                :: Word
        , modSelector              :: Maybe String
        , descrSelector            :: Maybe String
        , typeSelector             :: Maybe String
        , ccSelector               :: Maybe String
        , ccsSelector              :: Maybe String
        , retainerSelector         :: Maybe String
        , bioSelector              :: Maybe String
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    -- | Is event tracing enabled?
    --
    -- @since 4.8.2.0
    data DoTrace
        = TraceNone      -- ^ no tracing
        | TraceEventLog  -- ^ send tracing events to the event log
        | TraceStderr    -- ^ send tracing events to @stderr@
        deriving ( Show -- ^ @since 4.8.0.0
                 , Generic -- ^ @since 4.15.0.0
                 )

    -- | @since 4.8.0.0
    instance Enum DoTrace where
        fromEnum TraceNone     = 0
    {-# LINE 324 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum TraceEventLog = 1
    {-# LINE 325 "libraries/base/GHC/RTS/Flags.hsc" #-}
        fromEnum TraceStderr   = 2
    {-# LINE 326 "libraries/base/GHC/RTS/Flags.hsc" #-}

        toEnum 0     = TraceNone
    {-# LINE 328 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 1 = TraceEventLog
    {-# LINE 329 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum 2   = TraceStderr
    {-# LINE 330 "libraries/base/GHC/RTS/Flags.hsc" #-}
        toEnum e = errorWithoutStackTrace ("invalid enum for DoTrace: " ++ show e)

    -- | Parameters pertaining to event tracing
    --
    -- @since 4.8.0.0
    data TraceFlags = TraceFlags
        { tracing        :: DoTrace
        , timestamp      :: Bool -- ^ show timestamp in stderr output
        , traceScheduler :: Bool -- ^ trace scheduler events
        , traceGc        :: Bool -- ^ trace GC events
        , traceNonmovingGc
                         :: Bool -- ^ trace nonmoving GC heap census samples
        , sparksSampled  :: Bool -- ^ trace spark events by a sampled method
        , sparksFull     :: Bool -- ^ trace spark events 100% accurately
        , user           :: Bool -- ^ trace user events (emitted from Haskell code)
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    -- | Parameters pertaining to ticky-ticky profiler
    --
    -- @since 4.8.0.0
    data TickyFlags = TickyFlags
        { showTickyStats :: Bool
        , tickyFile      :: Maybe FilePath
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    -- | Parameters pertaining to parallelism
    --
    -- @since 4.8.0.0
    data ParFlags = ParFlags
        { nCapabilities :: Word32
        , migrate :: Bool
        , maxLocalSparks :: Word32
        , parGcEnabled :: Bool
        , parGcGen :: Word32
        , parGcLoadBalancingEnabled :: Bool
        , parGcLoadBalancingGen :: Word32
        , parGcNoSyncWithIdle :: Word32
        , parGcThreads :: Word32
        , setAffinity :: Bool
        }
        deriving ( Show -- ^ @since 4.8.0.0
                 , Generic -- ^ @since 4.15.0.0
                 )

    -- | Parameters of the runtime system
    --
    -- @since 4.8.0.0
    data RTSFlags = RTSFlags
        { gcFlags         :: GCFlags
        , concurrentFlags :: ConcFlags
        , miscFlags       :: MiscFlags
        , debugFlags      :: DebugFlags
        , costCentreFlags :: CCFlags
        , profilingFlags  :: ProfFlags
        , traceFlags      :: TraceFlags
        , tickyFlags      :: TickyFlags
        , parFlags        :: ParFlags
        } deriving ( Show -- ^ @since 4.8.0.0
                   , Generic -- ^ @since 4.15.0.0
                   )

    foreign import ccall "&RtsFlags" rtsFlagsPtr :: Ptr RTSFlags

    getRTSFlags :: IO RTSFlags
    getRTSFlags =
      RTSFlags <$> getGCFlags
               <*> getConcFlags
               <*> getMiscFlags
               <*> getDebugFlags
               <*> getCCFlags
               <*> getProfFlags
               <*> getTraceFlags
               <*> getTickyFlags
               <*> getParFlags

    peekFilePath :: Ptr () -> IO (Maybe FilePath)
    peekFilePath ptr
      | ptr == nullPtr = return Nothing
      | otherwise      = return (Just "<filepath>")

    -- | Read a NUL terminated string. Return Nothing in case of a NULL pointer.
    peekCStringOpt :: Ptr CChar -> IO (Maybe String)
    peekCStringOpt ptr
      | ptr == nullPtr = return Nothing
      | otherwise      = Just <$> peekCString ptr

    getGCFlags :: IO GCFlags
    getGCFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 0)) rtsFlagsPtr
    {-# LINE 423 "libraries/base/GHC/RTS/Flags.hsc" #-}
      GCFlags <$> (peekFilePath =<< (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr)
    {-# LINE 424 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (toEnum . fromIntegral <$>
                    ((\hsc_ptr -> peekByteOff hsc_ptr 8) ptr :: IO Word32))
    {-# LINE 426 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) ptr
    {-# LINE 427 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) ptr
    {-# LINE 428 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 20) ptr
    {-# LINE 429 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
    {-# LINE 430 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 28) ptr
    {-# LINE 431 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
    {-# LINE 432 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 36) ptr
    {-# LINE 433 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 40) ptr
    {-# LINE 434 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 44) ptr
    {-# LINE 435 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 48) ptr
    {-# LINE 436 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (toBool <$>
                    ((\hsc_ptr -> peekByteOff hsc_ptr 52) ptr :: IO CBool))
    {-# LINE 438 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 56) ptr
    {-# LINE 439 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 64) ptr
    {-# LINE 440 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 72) ptr
    {-# LINE 441 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 84) ptr
    {-# LINE 442 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (toBool <$>
                    ((\hsc_ptr -> peekByteOff hsc_ptr 88) ptr :: IO CBool))
    {-# LINE 444 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (toBool <$>
                    ((\hsc_ptr -> peekByteOff hsc_ptr 89) ptr :: IO CBool))
    {-# LINE 446 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 96) ptr
    {-# LINE 447 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (toBool <$>
                    ((\hsc_ptr -> peekByteOff hsc_ptr 104) ptr :: IO CBool))
    {-# LINE 449 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (toBool <$>
                    ((\hsc_ptr -> peekByteOff hsc_ptr 105) ptr :: IO CBool))
    {-# LINE 451 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) ptr
    {-# LINE 452 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (toBool <$>
                    ((\hsc_ptr -> peekByteOff hsc_ptr 128) ptr :: IO CBool))
    {-# LINE 454 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 144) ptr
    {-# LINE 455 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 152) ptr
    {-# LINE 456 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (toBool <$>
                    ((\hsc_ptr -> peekByteOff hsc_ptr 168) ptr :: IO CBool))
    {-# LINE 458 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 176) ptr
    {-# LINE 459 "libraries/base/GHC/RTS/Flags.hsc" #-}

    getParFlags :: IO ParFlags
    getParFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 432)) rtsFlagsPtr
    {-# LINE 463 "libraries/base/GHC/RTS/Flags.hsc" #-}
      ParFlags
        <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
    {-# LINE 465 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (toBool <$>
              ((\hsc_ptr -> peekByteOff hsc_ptr 4) ptr :: IO CBool))
    {-# LINE 467 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
    {-# LINE 468 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (toBool <$>
              ((\hsc_ptr -> peekByteOff hsc_ptr 12) ptr :: IO CBool))
    {-# LINE 470 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) ptr
    {-# LINE 471 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (toBool <$>
              ((\hsc_ptr -> peekByteOff hsc_ptr 20) ptr :: IO CBool))
    {-# LINE 473 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
    {-# LINE 474 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (\hsc_ptr -> peekByteOff hsc_ptr 28) ptr
    {-# LINE 475 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
    {-# LINE 476 "libraries/base/GHC/RTS/Flags.hsc" #-}
        <*> (toBool <$>
              ((\hsc_ptr -> peekByteOff hsc_ptr 36) ptr :: IO CBool))
    {-# LINE 478 "libraries/base/GHC/RTS/Flags.hsc" #-}

    getConcFlags :: IO ConcFlags
    getConcFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 184)) rtsFlagsPtr
    {-# LINE 482 "libraries/base/GHC/RTS/Flags.hsc" #-}
      ConcFlags <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
    {-# LINE 483 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
    {-# LINE 484 "libraries/base/GHC/RTS/Flags.hsc" #-}

    {-# INLINEABLE getMiscFlags #-}
    getMiscFlags :: IO MiscFlags
    getMiscFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 200)) rtsFlagsPtr
    {-# LINE 489 "libraries/base/GHC/RTS/Flags.hsc" #-}
      MiscFlags <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
    {-# LINE 490 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 8) ptr :: IO CBool))
    {-# LINE 492 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 9) ptr :: IO CBool))
    {-# LINE 494 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 10) ptr :: IO CBool))
    {-# LINE 496 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 11) ptr :: IO CBool))
    {-# LINE 498 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 12) ptr :: IO CBool))
    {-# LINE 500 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 13) ptr :: IO CBool))
    {-# LINE 502 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 14) ptr :: IO CBool))
    {-# LINE 504 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 15) ptr :: IO CBool))
    {-# LINE 506 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) ptr
    {-# LINE 507 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toEnum . fromIntegral
                     <$> ((\hsc_ptr -> peekByteOff hsc_ptr 24) ptr :: IO Word32))
    {-# LINE 509 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (fromIntegral
                     <$> ((\hsc_ptr -> peekByteOff hsc_ptr 28) ptr :: IO Word32))
    {-# LINE 511 "libraries/base/GHC/RTS/Flags.hsc" #-}

    {- Note [The need for getIoManagerFlag]
       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       GHC supports both the new WINIO manager
       as well as the old MIO one. In order to
       decide which code path to take we often
       have to inspect what the user selected at
       RTS startup.

       We could use getMiscFlags but then we end up with core containing
       reads for all MiscFlags. These won't be eliminated at the core level
       even if it's obvious we will only look at the ioManager part of the
       ADT.

       We could add a INLINE pragma, but that just means whatever we inline
       into is likely to be inlined. So rather than adding a dozen pragmas
       we expose a lean way to query this particular flag. It's not satisfying
       but it works well enough and allows these checks to be inlined nicely.

    -}

    {-# INLINE getIoManagerFlag #-}
    -- | Needed to optimize support for different IO Managers on Windows.
    -- See Note [The need for getIoManagerFlag]
    getIoManagerFlag :: IO IoSubSystem
    getIoManagerFlag = do
          let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 200)) rtsFlagsPtr
    {-# LINE 539 "libraries/base/GHC/RTS/Flags.hsc" #-}
          mgrFlag <- ((\hsc_ptr -> peekByteOff hsc_ptr 24) ptr :: IO Word32)
    {-# LINE 540 "libraries/base/GHC/RTS/Flags.hsc" #-}
          return $ (toEnum . fromIntegral) mgrFlag

    getDebugFlags :: IO DebugFlags
    getDebugFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 232)) rtsFlagsPtr
    {-# LINE 545 "libraries/base/GHC/RTS/Flags.hsc" #-}
      DebugFlags <$> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 0) ptr :: IO CBool))
    {-# LINE 547 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 1) ptr :: IO CBool))
    {-# LINE 549 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 2) ptr :: IO CBool))
    {-# LINE 551 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 3) ptr :: IO CBool))
    {-# LINE 553 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 4) ptr :: IO CBool))
    {-# LINE 555 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 5) ptr :: IO CBool))
    {-# LINE 557 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 6) ptr :: IO CBool))
    {-# LINE 559 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 7) ptr :: IO CBool))
    {-# LINE 561 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 9) ptr :: IO CBool))
    {-# LINE 563 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 10) ptr :: IO CBool))
    {-# LINE 565 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 11) ptr :: IO CBool))
    {-# LINE 567 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 12) ptr :: IO CBool))
    {-# LINE 569 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 13) ptr :: IO CBool))
    {-# LINE 571 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 14) ptr :: IO CBool))
    {-# LINE 573 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 15) ptr :: IO CBool))
    {-# LINE 575 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 16) ptr :: IO CBool))
    {-# LINE 577 "libraries/base/GHC/RTS/Flags.hsc" #-}

    getCCFlags :: IO CCFlags
    getCCFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 0)) rtsFlagsPtr
    {-# LINE 581 "libraries/base/GHC/RTS/Flags.hsc" #-}
      CCFlags <$> (toEnum . fromIntegral
                    <$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) ptr :: IO Word32))
    {-# LINE 583 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) ptr
    {-# LINE 584 "libraries/base/GHC/RTS/Flags.hsc" #-}
              <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
    {-# LINE 585 "libraries/base/GHC/RTS/Flags.hsc" #-}

    getProfFlags :: IO ProfFlags
    getProfFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 280)) rtsFlagsPtr
    {-# LINE 589 "libraries/base/GHC/RTS/Flags.hsc" #-}
      ProfFlags <$> (toEnum <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr)
    {-# LINE 590 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
    {-# LINE 591 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) ptr
    {-# LINE 592 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 20) ptr :: IO CBool))
    {-# LINE 594 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (toBool <$>
                      ((\hsc_ptr -> peekByteOff hsc_ptr 21) ptr :: IO CBool))
    {-# LINE 596 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
    {-# LINE 597 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (\hsc_ptr -> peekByteOff hsc_ptr 28) ptr
    {-# LINE 598 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (peekCStringOpt =<< (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr)
    {-# LINE 599 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (peekCStringOpt =<< (\hsc_ptr -> peekByteOff hsc_ptr 40) ptr)
    {-# LINE 600 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (peekCStringOpt =<< (\hsc_ptr -> peekByteOff hsc_ptr 48) ptr)
    {-# LINE 601 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (peekCStringOpt =<< (\hsc_ptr -> peekByteOff hsc_ptr 56) ptr)
    {-# LINE 602 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (peekCStringOpt =<< (\hsc_ptr -> peekByteOff hsc_ptr 64) ptr)
    {-# LINE 603 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (peekCStringOpt =<< (\hsc_ptr -> peekByteOff hsc_ptr 72) ptr)
    {-# LINE 604 "libraries/base/GHC/RTS/Flags.hsc" #-}
                <*> (peekCStringOpt =<< (\hsc_ptr -> peekByteOff hsc_ptr 80) ptr)
    {-# LINE 605 "libraries/base/GHC/RTS/Flags.hsc" #-}

    getTraceFlags :: IO TraceFlags
    getTraceFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 368)) rtsFlagsPtr
    {-# LINE 609 "libraries/base/GHC/RTS/Flags.hsc" #-}
      TraceFlags <$> (toEnum . fromIntegral
                       <$> ((\hsc_ptr -> peekByteOff hsc_ptr 0) ptr :: IO CInt))
    {-# LINE 611 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 4) ptr :: IO CBool))
    {-# LINE 613 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 5) ptr :: IO CBool))
    {-# LINE 615 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 6) ptr :: IO CBool))
    {-# LINE 617 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 7) ptr :: IO CBool))
    {-# LINE 619 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 8) ptr :: IO CBool))
    {-# LINE 621 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 9) ptr :: IO CBool))
    {-# LINE 623 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 11) ptr :: IO CBool))
    {-# LINE 625 "libraries/base/GHC/RTS/Flags.hsc" #-}

    getTickyFlags :: IO TickyFlags
    getTickyFlags = do
      let ptr = ((\hsc_ptr -> hsc_ptr `plusPtr` 416)) rtsFlagsPtr
    {-# LINE 629 "libraries/base/GHC/RTS/Flags.hsc" #-}
      TickyFlags <$> (toBool <$>
                       ((\hsc_ptr -> peekByteOff hsc_ptr 0) ptr :: IO CBool))
    {-# LINE 631 "libraries/base/GHC/RTS/Flags.hsc" #-}
                 <*> (peekFilePath =<< (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr)
    {-# LINE 632 "libraries/base/GHC/RTS/Flags.hsc" #-}