    {-# LINE 1 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    {-# LANGUAGE CApiFFI #-}
    {-# LANGUAGE RecordWildCards #-}
    {-# LANGUAGE Trustworthy #-}
    {-# LANGUAGE PatternSynonyms #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE NumDecimals #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  System.Posix.Files.Common
    -- Copyright   :  (c) The University of Glasgow 2002
    -- License     :  BSD-style (see the file libraries/base/LICENSE)
    --
    -- Maintainer  :  libraries@haskell.org
    -- Stability   :  provisional
    -- Portability :  non-portable (requires POSIX)
    --
    -- Functions defined by the POSIX standards for manipulating and querying the
    -- file system. Names of underlying POSIX functions are indicated whenever
    -- possible. A more complete documentation of the POSIX functions together
    -- with a more detailed description of different error conditions are usually
    -- available in the system's manual pages or from
    -- <http://www.unix.org/version3/online.html> (free registration required).
    --
    -- When a function that calls an underlying POSIX function fails, the errno
    -- code is converted to an 'IOError' using 'Foreign.C.Error.errnoToIOError'.
    -- For a list of which errno codes may be generated, consult the POSIX
    -- documentation for the underlying function.
    --
    -----------------------------------------------------------------------------

    module System.Posix.Files.Common (
        -- * File modes
        -- FileMode exported by System.Posix.Types
        unionFileModes, intersectFileModes,
        nullFileMode,
        ownerReadMode, ownerWriteMode, ownerExecuteMode, ownerModes,
        groupReadMode, groupWriteMode, groupExecuteMode, groupModes,
        otherReadMode, otherWriteMode, otherExecuteMode, otherModes,
        setUserIDMode, setGroupIDMode,
        stdFileMode,   accessModes,
        fileTypeModes,
        blockSpecialMode, characterSpecialMode, namedPipeMode, regularFileMode,
        directoryMode, symbolicLinkMode, socketMode,

        -- ** Setting file modes
        setFdMode, setFileCreationMask,

        -- * File status
        FileStatus(..),
        -- ** Obtaining file status
        getFdStatus,
        -- ** Querying file status
        deviceID, fileID, fileMode, linkCount, fileOwner, fileGroup,
        specialDeviceID, fileSize, accessTime, modificationTime,
        statusChangeTime,
        accessTimeHiRes, modificationTimeHiRes, statusChangeTimeHiRes,
        setFdTimesHiRes, touchFd,
        isBlockDevice, isCharacterDevice, isNamedPipe, isRegularFile,
        isDirectory, isSymbolicLink, isSocket,

        fileBlockSize,
        fileBlocks,

        -- * Extended file status
        StatxFlags(..),
        pattern EmptyPath,
        pattern NoAutoMount,
        pattern SymlinkNoFollow,
        pattern SyncAsStat,
        pattern ForceSync,
        pattern DontSync,
        defaultStatxFlags,
        StatxMask(..),
        pattern StatxType,
        pattern StatxMode,
        pattern StatxNlink,
        pattern StatxUid,
        pattern StatxGid,
        pattern StatxAtime,
        pattern StatxMtime,
        pattern StatxCtime,
        pattern StatxBtime,
        pattern StatxIno,
        pattern StatxSize,
        pattern StatxBlocks,
        pattern StatxMntId,
        pattern StatxBasicStats,
        pattern StatxAll,
        defaultStatxMask,
        ExtendedFileStatus(..),
        CAttributes(..),
        getExtendedFileStatus_,
        fileBlockSizeX,
        linkCountX,
        fileOwnerX,
        fileGroupX,
        fileModeX,
        fileIDX,
        fileSizeX,
        fileBlocksX,
        accessTimeHiResX,
        creationTimeHiResX,
        statusChangeTimeHiResX,
        modificationTimeHiResX,
        deviceIDX,
        specialDeviceIDX,
        mountIDX,
        fileCompressedX,
        fileImmutableX,
        fileAppendX,
        fileNoDumpX,
        fileEncryptedX,
        fileVerityX,
        fileDaxX,
        isBlockDeviceX,
        isCharacterDeviceX,
        isNamedPipeX,
        isRegularFileX,
        isDirectoryX,
        isSymbolicLinkX,
        isSocketX,
        haveStatx,

        -- * Setting file sizes
        setFdSize,

        -- * Changing file ownership
        setFdOwnerAndGroup,

        -- * Find system-specific limits for a file
        PathVar(..), getFdPathVar, pathVarConst,

        -- * Low level types and functions

    {-# LINE 138 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        CTimeSpec(..),
        toCTimeSpec,
        c_utimensat,

    {-# LINE 142 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 147 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        CTimeVal(..),
        toCTimeVal,
        c_utimes,

    {-# LINE 151 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        c_lutimes,

    {-# LINE 153 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      ) where

    import System.Posix.Types
    import System.IO.Unsafe
    import Data.Bits
    import Data.Int
    import Data.Ratio
    import Data.Word

    {-# LINE 162 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    import Data.Time.Clock (secondsToNominalDiffTime)
    import Data.Fixed (Fixed(..))

    {-# LINE 165 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    import Data.Time.Clock.POSIX (POSIXTime)
    import System.Posix.Internals
    import Foreign.C
    import Foreign.ForeignPtr

    {-# LINE 170 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    import Foreign.Marshal (withArray)

    {-# LINE 172 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    import Foreign.Ptr
    import Foreign.Storable

    {-# LINE 179 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- -----------------------------------------------------------------------------
    -- POSIX file modes

    -- The abstract type 'FileMode', constants and operators for
    -- manipulating the file modes defined by POSIX.

    -- | No permissions.
    nullFileMode :: FileMode
    nullFileMode :: FileMode
    nullFileMode = FileMode
    0

    -- | Owner has read permission.
    ownerReadMode :: FileMode
    ownerReadMode :: FileMode
    ownerReadMode = (FileMode
    256)
    {-# LINE 193 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Owner has write permission.
    ownerWriteMode :: FileMode
    ownerWriteMode :: FileMode
    ownerWriteMode = (FileMode
    128)
    {-# LINE 197 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Owner has execute permission.
    ownerExecuteMode :: FileMode
    ownerExecuteMode :: FileMode
    ownerExecuteMode = (FileMode
    64)
    {-# LINE 201 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Group has read permission.
    groupReadMode :: FileMode
    groupReadMode :: FileMode
    groupReadMode = (FileMode
    32)
    {-# LINE 205 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Group has write permission.
    groupWriteMode :: FileMode
    groupWriteMode :: FileMode
    groupWriteMode = (FileMode
    16)
    {-# LINE 209 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Group has execute permission.
    groupExecuteMode :: FileMode
    groupExecuteMode :: FileMode
    groupExecuteMode = (FileMode
    8)
    {-# LINE 213 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Others have read permission.
    otherReadMode :: FileMode
    otherReadMode :: FileMode
    otherReadMode = (FileMode
    4)
    {-# LINE 217 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Others have write permission.
    otherWriteMode :: FileMode
    otherWriteMode :: FileMode
    otherWriteMode = (FileMode
    2)
    {-# LINE 221 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Others have execute permission.
    otherExecuteMode :: FileMode
    otherExecuteMode :: FileMode
    otherExecuteMode = (FileMode
    1)
    {-# LINE 225 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Set user ID on execution.
    setUserIDMode :: FileMode
    setUserIDMode :: FileMode
    setUserIDMode = (FileMode
    2048)
    {-# LINE 229 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Set group ID on execution.
    setGroupIDMode :: FileMode
    setGroupIDMode :: FileMode
    setGroupIDMode = (FileMode
    1024)
    {-# LINE 233 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Owner, group and others have read and write permission.
    stdFileMode :: FileMode
    stdFileMode :: FileMode
    stdFileMode = FileMode
    ownerReadMode  FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .|. FileMode
    ownerWriteMode FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .|.
                  FileMode
    groupReadMode  FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .|. FileMode
    groupWriteMode FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .|.
                  FileMode
    otherReadMode  FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .|. FileMode
    otherWriteMode

    -- | Owner has read, write and execute permission.
    ownerModes :: FileMode
    ownerModes :: FileMode
    ownerModes = (FileMode
    448)
    {-# LINE 243 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Group has read, write and execute permission.
    groupModes :: FileMode
    groupModes :: FileMode
    groupModes = (FileMode
    56)
    {-# LINE 247 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Others have read, write and execute permission.
    otherModes :: FileMode
    otherModes :: FileMode
    otherModes = (FileMode
    7)
    {-# LINE 251 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Owner, group and others have read, write and execute permission.
    accessModes :: FileMode
    accessModes :: FileMode
    accessModes = FileMode
    ownerModes FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .|. FileMode
    groupModes FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .|. FileMode
    otherModes

    -- | Combines the two file modes into one that contains modes that appear in
    -- either.
    unionFileModes :: FileMode -> FileMode -> FileMode
    unionFileModes :: FileMode -> FileMode -> FileMode
    unionFileModes FileMode
    m1 FileMode
    m2 = FileMode
    m1 FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .|. FileMode
    m2

    -- | Combines two file modes into one that only contains modes that appear in
    -- both.
    intersectFileModes :: FileMode -> FileMode -> FileMode
    intersectFileModes :: FileMode -> FileMode -> FileMode
    intersectFileModes FileMode
    m1 FileMode
    m2 = FileMode
    m1 FileMode -> FileMode -> FileMode
    forall a. Bits a => a -> a -> a
    .&. FileMode
    m2

    fileTypeModes :: FileMode
    fileTypeModes :: FileMode
    fileTypeModes = (FileMode
    61440)
    {-# LINE 268 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    blockSpecialMode :: FileMode
    blockSpecialMode :: FileMode
    blockSpecialMode = (FileMode
    24576)
    {-# LINE 271 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    characterSpecialMode :: FileMode
    characterSpecialMode :: FileMode
    characterSpecialMode = (FileMode
    8192)
    {-# LINE 274 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    namedPipeMode :: FileMode
    namedPipeMode :: FileMode
    namedPipeMode = (FileMode
    4096)
    {-# LINE 277 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    regularFileMode :: FileMode
    regularFileMode :: FileMode
    regularFileMode = (FileMode
    32768)
    {-# LINE 280 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    directoryMode :: FileMode
    directoryMode :: FileMode
    directoryMode = (FileMode
    16384)
    {-# LINE 283 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    symbolicLinkMode :: FileMode
    symbolicLinkMode :: FileMode
    symbolicLinkMode = (FileMode
    40960)
    {-# LINE 286 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    socketMode :: FileMode
    socketMode :: FileMode
    socketMode = (FileMode
    49152)
    {-# LINE 289 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 291 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | @setFdMode fd mode@ acts like 'setFileMode' but uses a file descriptor
    -- @fd@ instead of a 'FilePath'.
    --
    -- Note: calls @fchmod@.
    setFdMode :: Fd -> FileMode -> IO ()
    setFdMode :: Fd -> FileMode -> IO ()
    setFdMode (Fd CInt
    fd) FileMode
    m =
      String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "setFdMode" (CInt -> FileMode -> IO CInt
    c_fchmod CInt
    fd FileMode
    m)

    foreign import ccall unsafe "fchmod"
      c_fchmod :: CInt -> CMode -> IO CInt

    {-# LINE 310 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | @setFileCreationMask mode@ sets the file mode creation mask to @mode@.
    -- Modes set by this operation are subtracted from files and directories upon
    -- creation. The previous file creation mask is returned.
    --
    -- Note: calls @umask@.
    setFileCreationMask :: FileMode -> IO FileMode
    setFileCreationMask :: FileMode -> IO FileMode
    setFileCreationMask FileMode
    mask = FileMode -> IO FileMode
    c_umask FileMode
    mask

    -- -----------------------------------------------------------------------------
    -- stat() support

    -- | POSIX defines operations to get information, such as owner, permissions,
    -- size and access times, about a file. This information is represented by the
    -- 'FileStatus' type.
    --
    -- Note: see @chmod@.
    --
    -- Limitations: Support for high resolution timestamps is filesystem dependent:
    --
    -- - HFS+ volumes on OS X only support whole-second times.
    --
    newtype FileStatus = FileStatus (ForeignPtr CStat) -- ^ The constructor is considered internal and may change.

    -- | ID of the device on which this file resides.
    deviceID         :: FileStatus -> DeviceID
    -- | inode number
    fileID           :: FileStatus -> FileID
    -- | File mode (such as permissions).
    fileMode         :: FileStatus -> FileMode
    -- | Number of hard links to this file.
    linkCount        :: FileStatus -> LinkCount
    -- | ID of owner.
    fileOwner        :: FileStatus -> UserID
    -- | ID of group.
    fileGroup        :: FileStatus -> GroupID
    -- | Describes the device that this file represents.
    specialDeviceID  :: FileStatus -> DeviceID
    -- | Size of the file in bytes. If this file is a symbolic link the size is
    -- the length of the pathname it contains.
    fileSize         :: FileStatus -> FileOffset
    -- | Number of blocks allocated for this file, in units of
    -- 512-bytes. Returns @Nothing@ if @st_blocks@ is not supported on this
    -- platform.
    fileBlocks       :: FileStatus -> Maybe CBlkCnt
    -- | Gives the preferred block size for efficient filesystem I/O in
    -- bytes. Returns @Nothing@ if @st_blocksize@ is not supported on this
    -- platform.
    fileBlockSize    :: FileStatus -> Maybe CBlkSize
    -- | Time of last access.
    accessTime       :: FileStatus -> EpochTime
    -- | Time of last access in sub-second resolution. Depends on the timestamp resolution of the
    -- underlying filesystem.
    accessTimeHiRes  :: FileStatus -> POSIXTime
    -- | Time of last modification.
    modificationTime :: FileStatus -> EpochTime
    -- | Time of last modification in sub-second resolution. Depends on the timestamp resolution of the
    -- underlying filesystem.
    modificationTimeHiRes :: FileStatus -> POSIXTime
    -- | Time of last status change (i.e. owner, group, link count, mode, etc.).
    statusChangeTime :: FileStatus -> EpochTime
    -- | Time of last status change (i.e. owner, group, link count, mode, etc.) in sub-second resolution.
    -- Depends on the timestamp resolution of the underlying filesystem.
    statusChangeTimeHiRes :: FileStatus -> POSIXTime

    deviceID :: FileStatus -> DeviceID
    deviceID (FileStatus ForeignPtr CStat
    stat) =
      IO DeviceID -> DeviceID
    forall a. IO a -> a
    unsafePerformIO (IO DeviceID -> DeviceID) -> IO DeviceID -> DeviceID
    forall a b. (a -> b) -> a -> b
    $ ForeignPtr CStat -> (Ptr CStat -> IO DeviceID) -> IO DeviceID
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr CStat
    stat ((Ptr CStat -> IO DeviceID) -> IO DeviceID)
    -> (Ptr CStat -> IO DeviceID) -> IO DeviceID
    forall a b. (a -> b) -> a -> b
    $ ((\Ptr CStat
    hsc_ptr -> Ptr CStat -> Int -> IO DeviceID
    forall b. Ptr b -> Int -> IO DeviceID
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr CStat
    hsc_ptr Int
    0))
    {-# LINE 377 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileID (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 8))
    fileMode :: FileStatus -> FileMode
    {-# LINE 379 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileMode (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 24))
    {-# LINE 381 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    linkCount (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 16))
    {-# LINE 383 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileOwner (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 28))
    {-# LINE 385 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileGroup (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 32))
    {-# LINE 387 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    specialDeviceID (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 40))
    fileSize :: FileStatus -> FileOffset
    {-# LINE 389 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileSize (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 48))
    {-# LINE 391 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    accessTime (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 72))
    {-# LINE 393 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    modificationTime (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 88))
    {-# LINE 395 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    statusChangeTime (FileStatus stat) =
      unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 104))
    {-# LINE 397 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 399 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileBlocks (FileStatus stat) =
      Just $ unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 64))
    {-# LINE 401 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 404 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 405 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileBlockSize (FileStatus stat) =
      Just $ unsafePerformIO $ withForeignPtr stat $ ((\hsc_ptr -> peekByteOff hsc_ptr 56))
    {-# LINE 407 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 410 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    accessTimeHiRes :: FileStatus -> POSIXTime
    accessTimeHiRes (FileStatus ForeignPtr CStat
    stat) =
      IO POSIXTime -> POSIXTime
    forall a. IO a -> a
    unsafePerformIO (IO POSIXTime -> POSIXTime) -> IO POSIXTime -> POSIXTime
    forall a b. (a -> b) -> a -> b
    $ ForeignPtr CStat -> (Ptr CStat -> IO POSIXTime) -> IO POSIXTime
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr CStat
    stat ((Ptr CStat -> IO POSIXTime) -> IO POSIXTime)
    -> (Ptr CStat -> IO POSIXTime) -> IO POSIXTime
    forall a b. (a -> b) -> a -> b
    $ \Ptr CStat
    stat_ptr -> do
        sec  <- ((\Ptr CStat
    hsc_ptr -> Ptr CStat -> Int -> IO EpochTime
    forall b. Ptr b -> Int -> IO EpochTime
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr CStat
    hsc_ptr Int
    72)) Ptr CStat
    stat_ptr :: IO EpochTime
    {-# LINE 414 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 415 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        nsec <- ((\hsc_ptr -> peekByteOff hsc_ptr 80)) stat_ptr :: IO (Int64)
    {-# LINE 416 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        let frac = toInteger nsec % 10^(9::Int)

    {-# LINE 432 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        return $ fromRational $ toRational sec + frac

    modificationTimeHiRes :: FileStatus -> POSIXTime
    modificationTimeHiRes (FileStatus ForeignPtr CStat
    stat) =
      IO POSIXTime -> POSIXTime
    forall a. IO a -> a
    unsafePerformIO (IO POSIXTime -> POSIXTime) -> IO POSIXTime -> POSIXTime
    forall a b. (a -> b) -> a -> b
    $ ForeignPtr CStat -> (Ptr CStat -> IO POSIXTime) -> IO POSIXTime
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr CStat
    stat ((Ptr CStat -> IO POSIXTime) -> IO POSIXTime)
    -> (Ptr CStat -> IO POSIXTime) -> IO POSIXTime
    forall a b. (a -> b) -> a -> b
    $ \Ptr CStat
    stat_ptr -> do
        sec  <- ((\Ptr CStat
    hsc_ptr -> Ptr CStat -> Int -> IO EpochTime
    forall b. Ptr b -> Int -> IO EpochTime
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr CStat
    hsc_ptr Int
    88)) Ptr CStat
    stat_ptr :: IO EpochTime
    {-# LINE 437 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 438 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        nsec <- ((\hsc_ptr -> peekByteOff hsc_ptr 96)) stat_ptr :: IO (Int64)
    {-# LINE 439 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        let frac = toInteger nsec % 10^(9::Int)

    {-# LINE 455 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        return $ fromRational $ toRational sec + frac

    statusChangeTimeHiRes :: FileStatus -> POSIXTime
    statusChangeTimeHiRes (FileStatus ForeignPtr CStat
    stat) =
      IO POSIXTime -> POSIXTime
    forall a. IO a -> a
    unsafePerformIO (IO POSIXTime -> POSIXTime) -> IO POSIXTime -> POSIXTime
    forall a b. (a -> b) -> a -> b
    $ ForeignPtr CStat -> (Ptr CStat -> IO POSIXTime) -> IO POSIXTime
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr CStat
    stat ((Ptr CStat -> IO POSIXTime) -> IO POSIXTime)
    -> (Ptr CStat -> IO POSIXTime) -> IO POSIXTime
    forall a b. (a -> b) -> a -> b
    $ \Ptr CStat
    stat_ptr -> do
        sec  <- ((\Ptr CStat
    hsc_ptr -> Ptr CStat -> Int -> IO EpochTime
    forall b. Ptr b -> Int -> IO EpochTime
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr CStat
    hsc_ptr Int
    104)) Ptr CStat
    stat_ptr :: IO EpochTime
    {-# LINE 460 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 461 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        nsec <- ((\hsc_ptr -> peekByteOff hsc_ptr 112)) stat_ptr :: IO (Int64)
    {-# LINE 462 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        let frac = toInteger nsec % 10^(9::Int)

    {-# LINE 478 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        return $ fromRational $ toRational sec + frac

    -- | Checks if this file is a block device.
    isBlockDevice     :: FileStatus -> Bool
    -- | Checks if this file is a character device.
    isCharacterDevice :: FileStatus -> Bool
    -- | Checks if this file is a named pipe device.
    isNamedPipe       :: FileStatus -> Bool
    -- | Checks if this file is a regular file device.
    isRegularFile     :: FileStatus -> Bool
    -- | Checks if this file is a directory device.
    isDirectory       :: FileStatus -> Bool
    -- | Checks if this file is a symbolic link device.
    isSymbolicLink    :: FileStatus -> Bool
    -- | Checks if this file is a socket device.
    isSocket          :: FileStatus -> Bool

    isBlockDevice :: FileStatus -> Bool
    isBlockDevice FileStatus
    stat =
      (FileStatus -> FileMode
    fileMode FileStatus
    stat FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    blockSpecialMode
    isCharacterDevice :: FileStatus -> Bool
    isCharacterDevice FileStatus
    stat =
      (FileStatus -> FileMode
    fileMode FileStatus
    stat FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    characterSpecialMode
    isNamedPipe :: FileStatus -> Bool
    isNamedPipe FileStatus
    stat =
      (FileStatus -> FileMode
    fileMode FileStatus
    stat FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    namedPipeMode
    isRegularFile :: FileStatus -> Bool
    isRegularFile FileStatus
    stat =
      (FileStatus -> FileMode
    fileMode FileStatus
    stat FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    regularFileMode
    isDirectory :: FileStatus -> Bool
    isDirectory FileStatus
    stat =
      (FileStatus -> FileMode
    fileMode FileStatus
    stat FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    directoryMode
    isSymbolicLink :: FileStatus -> Bool
    isSymbolicLink FileStatus
    stat =
      (FileStatus -> FileMode
    fileMode FileStatus
    stat FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    symbolicLinkMode
    isSocket :: FileStatus -> Bool
    isSocket FileStatus
    stat =
      (FileStatus -> FileMode
    fileMode FileStatus
    stat FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    socketMode

    -- | @getFdStatus fd@ acts as 'getFileStatus' but uses a file descriptor @fd@.
    --
    -- Note: calls @fstat@.
    getFdStatus :: Fd -> IO FileStatus
    getFdStatus :: Fd -> IO FileStatus
    getFdStatus (Fd CInt
    fd) = do
      fp <- Int -> IO (ForeignPtr CStat)
    forall a. Int -> IO (ForeignPtr a)
    mallocForeignPtrBytes (Int
    144)
    {-# LINE 516 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      withForeignPtr fp $ \p ->
        throwErrnoIfMinus1_ "getFdStatus" (c_fstat fd p)
      return (FileStatus fp)

    -- -----------------------------------------------------------------------------
    -- Setting file times

    {-# LINE 524 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    data CTimeSpec = CTimeSpec EpochTime CLong

    instance Storable CTimeSpec where
        sizeOf :: CTimeSpec -> Int
    sizeOf    CTimeSpec
    _ = (Int
    16)
    {-# LINE 528 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        alignment _ = alignment (undefined :: CInt)
        poke :: Ptr CTimeSpec -> CTimeSpec -> IO ()
    poke Ptr CTimeSpec
    p (CTimeSpec EpochTime
    sec CLong
    nsec) = do
            ((\Ptr CTimeSpec
    hsc_ptr -> Ptr CTimeSpec -> Int -> EpochTime -> IO ()
    forall b. Ptr b -> Int -> EpochTime -> IO ()
    forall a b. Storable a => Ptr b -> Int -> a -> IO ()
    pokeByteOff Ptr CTimeSpec
    hsc_ptr Int
    0)) Ptr CTimeSpec
    p EpochTime
    sec
    {-# LINE 531 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            ((\Ptr CTimeSpec
    hsc_ptr -> Ptr CTimeSpec -> Int -> CLong -> IO ()
    forall b. Ptr b -> Int -> CLong -> IO ()
    forall a b. Storable a => Ptr b -> Int -> a -> IO ()
    pokeByteOff Ptr CTimeSpec
    hsc_ptr Int
    8)) Ptr CTimeSpec
    p CLong
    nsec
    {-# LINE 532 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        peek p = do
            sec  <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
    {-# LINE 534 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            nsec <- (\hsc_ptr -> peekByteOff hsc_ptr 8) p
    {-# LINE 535 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            return $ CTimeSpec sec nsec

    toCTimeSpec :: POSIXTime -> CTimeSpec
    toCTimeSpec :: POSIXTime -> CTimeSpec
    toCTimeSpec POSIXTime
    t = EpochTime -> CLong -> CTimeSpec
    CTimeSpec (Int64 -> EpochTime
    CTime Int64
    sec) (Ratio Integer -> CLong
    forall b. Integral b => Ratio Integer -> b
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate (Ratio Integer -> CLong) -> Ratio Integer -> CLong
    forall a b. (a -> b) -> a -> b
    $ Ratio Integer
    10Ratio Integer -> Int -> Ratio Integer
    forall a b. (Num a, Integral b) => a -> b -> a
    ^(Int
    9::Int) Ratio Integer -> Ratio Integer -> Ratio Integer
    forall a. Num a => a -> a -> a
    * Ratio Integer
    frac)
      where
        (Int64
    sec, Ratio Integer
    frac) = if (Ratio Integer
    frac' Ratio Integer -> Ratio Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    < Ratio Integer
    0) then (Int64
    sec' Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    - Int64
    1, Ratio Integer
    frac' Ratio Integer -> Ratio Integer -> Ratio Integer
    forall a. Num a => a -> a -> a
    + Ratio Integer
    1) else (Int64
    sec', Ratio Integer
    frac')
        (Int64
    sec', Ratio Integer
    frac') = Ratio Integer -> (Int64, Ratio Integer)
    forall b. Integral b => Ratio Integer -> (b, Ratio Integer)
    forall a b. (RealFrac a, Integral b) => a -> (b, a)
    properFraction (Ratio Integer -> (Int64, Ratio Integer))
    -> Ratio Integer -> (Int64, Ratio Integer)
    forall a b. (a -> b) -> a -> b
    $ POSIXTime -> Ratio Integer
    forall a. Real a => a -> Ratio Integer
    toRational POSIXTime
    t

    {-# LINE 543 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 545 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    foreign import capi unsafe "sys/stat.h utimensat"
        c_utimensat :: CInt -> CString -> Ptr CTimeSpec -> CInt -> IO CInt

    {-# LINE 548 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 550 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    foreign import capi unsafe "sys/stat.h futimens"
        c_futimens :: CInt -> Ptr CTimeSpec -> IO CInt

    {-# LINE 553 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    data CTimeVal = CTimeVal (Int64) (Int64)
    {-# LINE 555 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    instance Storable CTimeVal where
        sizeOf :: CTimeVal -> Int
    sizeOf    CTimeVal
    _ = (Int
    16)
    {-# LINE 558 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        alignment _ = alignment (undefined :: CInt)
        poke :: Ptr CTimeVal -> CTimeVal -> IO ()
    poke Ptr CTimeVal
    p (CTimeVal Int64
    sec Int64
    usec) = do
            ((\Ptr CTimeVal
    hsc_ptr -> Ptr CTimeVal -> Int -> Int64 -> IO ()
    forall b. Ptr b -> Int -> Int64 -> IO ()
    forall a b. Storable a => Ptr b -> Int -> a -> IO ()
    pokeByteOff Ptr CTimeVal
    hsc_ptr Int
    0)) Ptr CTimeVal
    p Int64
    sec
    {-# LINE 561 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            ((\Ptr CTimeVal
    hsc_ptr -> Ptr CTimeVal -> Int -> Int64 -> IO ()
    forall b. Ptr b -> Int -> Int64 -> IO ()
    forall a b. Storable a => Ptr b -> Int -> a -> IO ()
    pokeByteOff Ptr CTimeVal
    hsc_ptr Int
    8)) Ptr CTimeVal
    p Int64
    usec
    {-# LINE 562 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        peek p = do
            sec  <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
    {-# LINE 564 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            usec <- (\hsc_ptr -> peekByteOff hsc_ptr 8) p
    {-# LINE 565 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            return $ CTimeVal sec usec

    toCTimeVal :: POSIXTime -> CTimeVal
    toCTimeVal :: POSIXTime -> CTimeVal
    toCTimeVal POSIXTime
    t = Int64 -> Int64 -> CTimeVal
    CTimeVal Int64
    sec (Ratio Integer -> Int64
    forall b. Integral b => Ratio Integer -> b
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate (Ratio Integer -> Int64) -> Ratio Integer -> Int64
    forall a b. (a -> b) -> a -> b
    $ Ratio Integer
    10Ratio Integer -> Int -> Ratio Integer
    forall a b. (Num a, Integral b) => a -> b -> a
    ^(Int
    6::Int) Ratio Integer -> Ratio Integer -> Ratio Integer
    forall a. Num a => a -> a -> a
    * Ratio Integer
    frac)
      where
        (Int64
    sec, Ratio Integer
    frac) = if (Ratio Integer
    frac' Ratio Integer -> Ratio Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    < Ratio Integer
    0) then (Int64
    sec' Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    - Int64
    1, Ratio Integer
    frac' Ratio Integer -> Ratio Integer -> Ratio Integer
    forall a. Num a => a -> a -> a
    + Ratio Integer
    1) else (Int64
    sec', Ratio Integer
    frac')
        (Int64
    sec', Ratio Integer
    frac') = Ratio Integer -> (Int64, Ratio Integer)
    forall b. Integral b => Ratio Integer -> (b, Ratio Integer)
    forall a b. (RealFrac a, Integral b) => a -> (b, a)
    properFraction (Ratio Integer -> (Int64, Ratio Integer))
    -> Ratio Integer -> (Int64, Ratio Integer)
    forall a b. (a -> b) -> a -> b
    $ POSIXTime -> Ratio Integer
    forall a. Real a => a -> Ratio Integer
    toRational POSIXTime
    t

    foreign import capi unsafe "sys/time.h utimes"
        c_utimes :: CString -> Ptr CTimeVal -> IO CInt

    {-# LINE 577 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    foreign import capi unsafe "sys/time.h lutimes"
        c_lutimes :: CString -> Ptr CTimeVal -> IO CInt

    {-# LINE 580 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 582 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    foreign import capi unsafe "sys/time.h futimes"
        c_futimes :: CInt -> Ptr CTimeVal -> IO CInt

    {-# LINE 585 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 594 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Like 'setFileTimesHiRes' but uses a file descriptor instead of a path.
    -- This operation is not supported on all platforms. On these platforms,
    -- this function will raise an exception.
    --
    -- Note: calls @futimens@ or @futimes@. Support for high resolution timestamps
    --   is filesystem dependent with the following limitations:
    --
    -- - HFS+ volumes on OS X truncate the sub-second part of the timestamp.
    --
    --
    -- @since 2.7.0.0
    setFdTimesHiRes :: Fd -> POSIXTime -> POSIXTime -> IO ()

    {-# LINE 611 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    setFdTimesHiRes :: Fd -> POSIXTime -> POSIXTime -> IO ()
    setFdTimesHiRes (Fd CInt
    fd) POSIXTime
    atime POSIXTime
    mtime =
      [CTimeSpec] -> (Ptr CTimeSpec -> IO ()) -> IO ()
    forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
    withArray [POSIXTime -> CTimeSpec
    toCTimeSpec POSIXTime
    atime, POSIXTime -> CTimeSpec
    toCTimeSpec POSIXTime
    mtime] ((Ptr CTimeSpec -> IO ()) -> IO ())
    -> (Ptr CTimeSpec -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr CTimeSpec
    times ->
        String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "setFdTimesHiRes" (CInt -> Ptr CTimeSpec -> IO CInt
    c_futimens CInt
    fd Ptr CTimeSpec
    times)

    {-# LINE 623 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Like 'touchFile' but uses a file descriptor instead of a path.
    -- This operation is not supported on all platforms. On these platforms,
    -- this function will raise an exception.
    --
    -- Note: calls @futimes@.
    --
    -- @since 2.7.0.0
    touchFd :: Fd -> IO ()

    {-# LINE 637 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    touchFd :: Fd -> IO ()
    touchFd (Fd CInt
    fd) =
      String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "touchFd" (CInt -> Ptr CTimeVal -> IO CInt
    c_futimes CInt
    fd Ptr CTimeVal
    forall a. Ptr a
    nullPtr)

    {-# LINE 644 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- -----------------------------------------------------------------------------
    -- fchown()

    {-# LINE 649 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Acts as 'setOwnerAndGroup' but uses a file descriptor instead of a
    -- 'FilePath'.
    --
    -- Note: calls @fchown@.
    setFdOwnerAndGroup :: Fd -> UserID -> GroupID -> IO ()
    setFdOwnerAndGroup :: Fd -> UserID -> GroupID -> IO ()
    setFdOwnerAndGroup (Fd CInt
    fd) UserID
    uid GroupID
    gid =
      String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "setFdOwnerAndGroup" (CInt -> UserID -> GroupID -> IO CInt
    c_fchown CInt
    fd UserID
    uid GroupID
    gid)

    foreign import ccall unsafe "fchown"
      c_fchown :: CInt -> CUid -> CGid -> IO CInt

    {-# LINE 668 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- -----------------------------------------------------------------------------
    -- ftruncate()

    -- | Acts as 'setFileSize' but uses a file descriptor instead of a 'FilePath'.
    --
    -- Note: calls @ftruncate@.
    setFdSize :: Fd -> FileOffset -> IO ()
    setFdSize :: Fd -> FileOffset -> IO ()
    setFdSize (Fd CInt
    fd) FileOffset
    off =
      String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "setFdSize" (CInt -> FileOffset -> IO CInt
    c_ftruncate CInt
    fd FileOffset
    off)

    -- -----------------------------------------------------------------------------
    -- pathconf()/fpathconf() support

    data PathVar
      = FileSizeBits                  {- _PC_FILESIZEBITS     -}
      | LinkLimit                     {- _PC_LINK_MAX         -}
      | InputLineLimit                {- _PC_MAX_CANON        -}
      | InputQueueLimit               {- _PC_MAX_INPUT        -}
      | FileNameLimit                 {- _PC_NAME_MAX         -}
      | PathNameLimit                 {- _PC_PATH_MAX         -}
      | PipeBufferLimit               {- _PC_PIPE_BUF         -}
                                      -- These are described as optional in POSIX:
                                      {- _PC_ALLOC_SIZE_MIN     -}
                                      {- _PC_REC_INCR_XFER_SIZE -}
                                      {- _PC_REC_MAX_XFER_SIZE  -}
                                      {- _PC_REC_MIN_XFER_SIZE  -}
                                      {- _PC_REC_XFER_ALIGN     -}
      | SymbolicLinkLimit             {- _PC_SYMLINK_MAX      -}
      | SetOwnerAndGroupIsRestricted  {- _PC_CHOWN_RESTRICTED -}
      | FileNamesAreNotTruncated      {- _PC_NO_TRUNC         -}
      | VDisableChar                  {- _PC_VDISABLE         -}
      | AsyncIOAvailable              {- _PC_ASYNC_IO         -}
      | PrioIOAvailable               {- _PC_PRIO_IO          -}
      | SyncIOAvailable               {- _PC_SYNC_IO          -}

    pathVarConst :: PathVar -> CInt
    pathVarConst :: PathVar -> CInt
    pathVarConst PathVar
    v = case PathVar
    v of
            PathVar
    LinkLimit                       -> (CInt
    0)
    {-# LINE 707 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    InputLineLimit                  -> (CInt
    1)
    {-# LINE 708 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    InputQueueLimit                 -> (CInt
    2)
    {-# LINE 709 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    FileNameLimit                   -> (CInt
    3)
    {-# LINE 710 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    PathNameLimit                   -> (CInt
    4)
    {-# LINE 711 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    PipeBufferLimit                 -> (CInt
    5)
    {-# LINE 712 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    SetOwnerAndGroupIsRestricted    -> (CInt
    6)
    {-# LINE 713 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    FileNamesAreNotTruncated        -> (CInt
    7)
    {-# LINE 714 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    VDisableChar                    -> (CInt
    8)
    {-# LINE 715 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 717 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    SyncIOAvailable         -> (CInt
    9)
    {-# LINE 718 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 721 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 723 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    AsyncIOAvailable        -> (CInt
    10)
    {-# LINE 724 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 727 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 729 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    PrioIOAvailable         -> (CInt
    11)
    {-# LINE 730 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 733 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 737 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    FileSizeBits            -> String -> CInt
    forall a. HasCallStack => String -> a
    error String
    "_PC_FILESIZEBITS not available"

    {-# LINE 739 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 743 "libraries/unix/System/Posix/Files/Common.hsc" #-}
            PathVar
    SymbolicLinkLimit       -> String -> CInt
    forall a. HasCallStack => String -> a
    error String
    "_PC_SYMLINK_MAX not available"

    {-# LINE 745 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | @getFdPathVar var fd@ obtains the dynamic value of the requested
    -- configurable file limit or option associated with the file or directory
    -- attached to the open channel @fd@. For defined file limits, @getFdPathVar@
    -- returns the associated value.  For defined file options, the result of
    -- @getFdPathVar@ is undefined, but not failure.
    --
    -- Note: calls @fpathconf@.
    getFdPathVar :: Fd -> PathVar -> IO Limit
    getFdPathVar :: Fd -> PathVar -> IO CLong
    getFdPathVar (Fd CInt
    fd) PathVar
    v =
        String -> IO CLong -> IO CLong
    forall a. (Eq a, Num a) => String -> IO a -> IO a
    throwErrnoIfMinus1 String
    "getFdPathVar" (IO CLong -> IO CLong) -> IO CLong -> IO CLong
    forall a b. (a -> b) -> a -> b
    $
          CInt -> CInt -> IO CLong
    c_fpathconf CInt
    fd (PathVar -> CInt
    pathVarConst PathVar
    v)

    foreign import ccall unsafe "fpathconf"
      c_fpathconf :: CInt -> CInt -> IO CLong

    -- -----------------------------------------------------------------------------
    -- statx
    --

    newtype {-# CTYPE "__u64" #-} CAttributes = CAttributes Word64
     deriving (ReadPrec [CAttributes]
    ReadPrec CAttributes
    Int -> ReadS CAttributes
    ReadS [CAttributes]
    (Int -> ReadS CAttributes)
    -> ReadS [CAttributes]
    -> ReadPrec CAttributes
    -> ReadPrec [CAttributes]
    -> Read CAttributes
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS CAttributes
    readsPrec :: Int -> ReadS CAttributes
    $creadList :: ReadS [CAttributes]
    readList :: ReadS [CAttributes]
    $creadPrec :: ReadPrec CAttributes
    readPrec :: ReadPrec CAttributes
    $creadListPrec :: ReadPrec [CAttributes]
    readListPrec :: ReadPrec [CAttributes]
    Read, Int -> CAttributes -> ShowS
    [CAttributes] -> ShowS
    CAttributes -> String
    (Int -> CAttributes -> ShowS)
    -> (CAttributes -> String)
    -> ([CAttributes] -> ShowS)
    -> Show CAttributes
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CAttributes -> ShowS
    showsPrec :: Int -> CAttributes -> ShowS
    $cshow :: CAttributes -> String
    show :: CAttributes -> String
    $cshowList :: [CAttributes] -> ShowS
    showList :: [CAttributes] -> ShowS
    Show, CAttributes -> CAttributes -> Bool
    (CAttributes -> CAttributes -> Bool)
    -> (CAttributes -> CAttributes -> Bool) -> Eq CAttributes
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CAttributes -> CAttributes -> Bool
    == :: CAttributes -> CAttributes -> Bool
    $c/= :: CAttributes -> CAttributes -> Bool
    /= :: CAttributes -> CAttributes -> Bool
    Eq, Eq CAttributes
    Eq CAttributes =>
    (CAttributes -> CAttributes -> Ordering)
    -> (CAttributes -> CAttributes -> Bool)
    -> (CAttributes -> CAttributes -> Bool)
    -> (CAttributes -> CAttributes -> Bool)
    -> (CAttributes -> CAttributes -> Bool)
    -> (CAttributes -> CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes -> CAttributes)
    -> Ord CAttributes
    CAttributes -> CAttributes -> Bool
    CAttributes -> CAttributes -> Ordering
    CAttributes -> CAttributes -> CAttributes
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: CAttributes -> CAttributes -> Ordering
    compare :: CAttributes -> CAttributes -> Ordering
    $c< :: CAttributes -> CAttributes -> Bool
    < :: CAttributes -> CAttributes -> Bool
    $c<= :: CAttributes -> CAttributes -> Bool
    <= :: CAttributes -> CAttributes -> Bool
    $c> :: CAttributes -> CAttributes -> Bool
    > :: CAttributes -> CAttributes -> Bool
    $c>= :: CAttributes -> CAttributes -> Bool
    >= :: CAttributes -> CAttributes -> Bool
    $cmax :: CAttributes -> CAttributes -> CAttributes
    max :: CAttributes -> CAttributes -> CAttributes
    $cmin :: CAttributes -> CAttributes -> CAttributes
    min :: CAttributes -> CAttributes -> CAttributes
    Ord, Ptr CAttributes -> IO CAttributes
    Ptr CAttributes -> Int -> IO CAttributes
    Ptr CAttributes -> Int -> CAttributes -> IO ()
    Ptr CAttributes -> CAttributes -> IO ()
    CAttributes -> Int
    (CAttributes -> Int)
    -> (CAttributes -> Int)
    -> (Ptr CAttributes -> Int -> IO CAttributes)
    -> (Ptr CAttributes -> Int -> CAttributes -> IO ())
    -> (forall b. Ptr b -> Int -> IO CAttributes)
    -> (forall b. Ptr b -> Int -> CAttributes -> IO ())
    -> (Ptr CAttributes -> IO CAttributes)
    -> (Ptr CAttributes -> CAttributes -> IO ())
    -> Storable CAttributes
    forall b. Ptr b -> Int -> IO CAttributes
    forall b. Ptr b -> Int -> CAttributes -> IO ()
    forall a.
    (a -> Int)
    -> (a -> Int)
    -> (Ptr a -> Int -> IO a)
    -> (Ptr a -> Int -> a -> IO ())
    -> (forall b. Ptr b -> Int -> IO a)
    -> (forall b. Ptr b -> Int -> a -> IO ())
    -> (Ptr a -> IO a)
    -> (Ptr a -> a -> IO ())
    -> Storable a
    $csizeOf :: CAttributes -> Int
    sizeOf :: CAttributes -> Int
    $calignment :: CAttributes -> Int
    alignment :: CAttributes -> Int
    $cpeekElemOff :: Ptr CAttributes -> Int -> IO CAttributes
    peekElemOff :: Ptr CAttributes -> Int -> IO CAttributes
    $cpokeElemOff :: Ptr CAttributes -> Int -> CAttributes -> IO ()
    pokeElemOff :: Ptr CAttributes -> Int -> CAttributes -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO CAttributes
    peekByteOff :: forall b. Ptr b -> Int -> IO CAttributes
    $cpokeByteOff :: forall b. Ptr b -> Int -> CAttributes -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> CAttributes -> IO ()
    $cpeek :: Ptr CAttributes -> IO CAttributes
    peek :: Ptr CAttributes -> IO CAttributes
    $cpoke :: Ptr CAttributes -> CAttributes -> IO ()
    poke :: Ptr CAttributes -> CAttributes -> IO ()
    Storable, Integer -> CAttributes
    CAttributes -> CAttributes
    CAttributes -> CAttributes -> CAttributes
    (CAttributes -> CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes)
    -> (Integer -> CAttributes)
    -> Num CAttributes
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: CAttributes -> CAttributes -> CAttributes
    + :: CAttributes -> CAttributes -> CAttributes
    $c- :: CAttributes -> CAttributes -> CAttributes
    - :: CAttributes -> CAttributes -> CAttributes
    $c* :: CAttributes -> CAttributes -> CAttributes
    * :: CAttributes -> CAttributes -> CAttributes
    $cnegate :: CAttributes -> CAttributes
    negate :: CAttributes -> CAttributes
    $cabs :: CAttributes -> CAttributes
    abs :: CAttributes -> CAttributes
    $csignum :: CAttributes -> CAttributes
    signum :: CAttributes -> CAttributes
    $cfromInteger :: Integer -> CAttributes
    fromInteger :: Integer -> CAttributes
    Num, Eq CAttributes
    CAttributes
    Eq CAttributes =>
    (CAttributes -> CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes -> CAttributes)
    -> (CAttributes -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> CAttributes
    -> (Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> Bool)
    -> (CAttributes -> Maybe Int)
    -> (CAttributes -> Int)
    -> (CAttributes -> Bool)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int -> CAttributes)
    -> (CAttributes -> Int)
    -> Bits CAttributes
    Int -> CAttributes
    CAttributes -> Bool
    CAttributes -> Int
    CAttributes -> Maybe Int
    CAttributes -> CAttributes
    CAttributes -> Int -> Bool
    CAttributes -> Int -> CAttributes
    CAttributes -> CAttributes -> CAttributes
    forall a.
    Eq a =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> a
    -> (Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> Bool)
    -> (a -> Maybe Int)
    -> (a -> Int)
    -> (a -> Bool)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int)
    -> Bits a
    $c.&. :: CAttributes -> CAttributes -> CAttributes
    .&. :: CAttributes -> CAttributes -> CAttributes
    $c.|. :: CAttributes -> CAttributes -> CAttributes
    .|. :: CAttributes -> CAttributes -> CAttributes
    $cxor :: CAttributes -> CAttributes -> CAttributes
    xor :: CAttributes -> CAttributes -> CAttributes
    $ccomplement :: CAttributes -> CAttributes
    complement :: CAttributes -> CAttributes
    $cshift :: CAttributes -> Int -> CAttributes
    shift :: CAttributes -> Int -> CAttributes
    $crotate :: CAttributes -> Int -> CAttributes
    rotate :: CAttributes -> Int -> CAttributes
    $czeroBits :: CAttributes
    zeroBits :: CAttributes
    $cbit :: Int -> CAttributes
    bit :: Int -> CAttributes
    $csetBit :: CAttributes -> Int -> CAttributes
    setBit :: CAttributes -> Int -> CAttributes
    $cclearBit :: CAttributes -> Int -> CAttributes
    clearBit :: CAttributes -> Int -> CAttributes
    $ccomplementBit :: CAttributes -> Int -> CAttributes
    complementBit :: CAttributes -> Int -> CAttributes
    $ctestBit :: CAttributes -> Int -> Bool
    testBit :: CAttributes -> Int -> Bool
    $cbitSizeMaybe :: CAttributes -> Maybe Int
    bitSizeMaybe :: CAttributes -> Maybe Int
    $cbitSize :: CAttributes -> Int
    bitSize :: CAttributes -> Int
    $cisSigned :: CAttributes -> Bool
    isSigned :: CAttributes -> Bool
    $cshiftL :: CAttributes -> Int -> CAttributes
    shiftL :: CAttributes -> Int -> CAttributes
    $cunsafeShiftL :: CAttributes -> Int -> CAttributes
    unsafeShiftL :: CAttributes -> Int -> CAttributes
    $cshiftR :: CAttributes -> Int -> CAttributes
    shiftR :: CAttributes -> Int -> CAttributes
    $cunsafeShiftR :: CAttributes -> Int -> CAttributes
    unsafeShiftR :: CAttributes -> Int -> CAttributes
    $crotateL :: CAttributes -> Int -> CAttributes
    rotateL :: CAttributes -> Int -> CAttributes
    $crotateR :: CAttributes -> Int -> CAttributes
    rotateR :: CAttributes -> Int -> CAttributes
    $cpopCount :: CAttributes -> Int
    popCount :: CAttributes -> Int
    Bits)

    -- | Statx flags.
    --
    -- See the pattern synonyms for possible flags. These are combined via `(<>)`.
    -- Flags can be tested via `(.&.)`.
    --
    -- The following flags influence pathname-based lookup:
    --
    -- - 'EmptyPath'
    -- - 'NoAutoMount'
    -- - 'SymlinkNoFollow'
    --
    -- The following flags can be used to control what sort of synchronization the kernel will do when querying a file on a remote filesystem:
    --
    -- - 'SyncAsStat'
    -- - 'ForceSync'
    -- - 'DontSync'
    newtype StatxFlags = StatxFlags CInt deriving (ReadPrec [StatxFlags]
    ReadPrec StatxFlags
    Int -> ReadS StatxFlags
    ReadS [StatxFlags]
    (Int -> ReadS StatxFlags)
    -> ReadS [StatxFlags]
    -> ReadPrec StatxFlags
    -> ReadPrec [StatxFlags]
    -> Read StatxFlags
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS StatxFlags
    readsPrec :: Int -> ReadS StatxFlags
    $creadList :: ReadS [StatxFlags]
    readList :: ReadS [StatxFlags]
    $creadPrec :: ReadPrec StatxFlags
    readPrec :: ReadPrec StatxFlags
    $creadListPrec :: ReadPrec [StatxFlags]
    readListPrec :: ReadPrec [StatxFlags]
    Read, Int -> StatxFlags -> ShowS
    [StatxFlags] -> ShowS
    StatxFlags -> String
    (Int -> StatxFlags -> ShowS)
    -> (StatxFlags -> String)
    -> ([StatxFlags] -> ShowS)
    -> Show StatxFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StatxFlags -> ShowS
    showsPrec :: Int -> StatxFlags -> ShowS
    $cshow :: StatxFlags -> String
    show :: StatxFlags -> String
    $cshowList :: [StatxFlags] -> ShowS
    showList :: [StatxFlags] -> ShowS
    Show, StatxFlags -> StatxFlags -> Bool
    (StatxFlags -> StatxFlags -> Bool)
    -> (StatxFlags -> StatxFlags -> Bool) -> Eq StatxFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StatxFlags -> StatxFlags -> Bool
    == :: StatxFlags -> StatxFlags -> Bool
    $c/= :: StatxFlags -> StatxFlags -> Bool
    /= :: StatxFlags -> StatxFlags -> Bool
    Eq, Eq StatxFlags
    Eq StatxFlags =>
    (StatxFlags -> StatxFlags -> Ordering)
    -> (StatxFlags -> StatxFlags -> Bool)
    -> (StatxFlags -> StatxFlags -> Bool)
    -> (StatxFlags -> StatxFlags -> Bool)
    -> (StatxFlags -> StatxFlags -> Bool)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> Ord StatxFlags
    StatxFlags -> StatxFlags -> Bool
    StatxFlags -> StatxFlags -> Ordering
    StatxFlags -> StatxFlags -> StatxFlags
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: StatxFlags -> StatxFlags -> Ordering
    compare :: StatxFlags -> StatxFlags -> Ordering
    $c< :: StatxFlags -> StatxFlags -> Bool
    < :: StatxFlags -> StatxFlags -> Bool
    $c<= :: StatxFlags -> StatxFlags -> Bool
    <= :: StatxFlags -> StatxFlags -> Bool
    $c> :: StatxFlags -> StatxFlags -> Bool
    > :: StatxFlags -> StatxFlags -> Bool
    $c>= :: StatxFlags -> StatxFlags -> Bool
    >= :: StatxFlags -> StatxFlags -> Bool
    $cmax :: StatxFlags -> StatxFlags -> StatxFlags
    max :: StatxFlags -> StatxFlags -> StatxFlags
    $cmin :: StatxFlags -> StatxFlags -> StatxFlags
    min :: StatxFlags -> StatxFlags -> StatxFlags
    Ord, Enum StatxFlags
    Real StatxFlags
    (Real StatxFlags, Enum StatxFlags) =>
    (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> (StatxFlags, StatxFlags))
    -> (StatxFlags -> StatxFlags -> (StatxFlags, StatxFlags))
    -> (StatxFlags -> Integer)
    -> Integral StatxFlags
    StatxFlags -> Integer
    StatxFlags -> StatxFlags -> (StatxFlags, StatxFlags)
    StatxFlags -> StatxFlags -> StatxFlags
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: StatxFlags -> StatxFlags -> StatxFlags
    quot :: StatxFlags -> StatxFlags -> StatxFlags
    $crem :: StatxFlags -> StatxFlags -> StatxFlags
    rem :: StatxFlags -> StatxFlags -> StatxFlags
    $cdiv :: StatxFlags -> StatxFlags -> StatxFlags
    div :: StatxFlags -> StatxFlags -> StatxFlags
    $cmod :: StatxFlags -> StatxFlags -> StatxFlags
    mod :: StatxFlags -> StatxFlags -> StatxFlags
    $cquotRem :: StatxFlags -> StatxFlags -> (StatxFlags, StatxFlags)
    quotRem :: StatxFlags -> StatxFlags -> (StatxFlags, StatxFlags)
    $cdivMod :: StatxFlags -> StatxFlags -> (StatxFlags, StatxFlags)
    divMod :: StatxFlags -> StatxFlags -> (StatxFlags, StatxFlags)
    $ctoInteger :: StatxFlags -> Integer
    toInteger :: StatxFlags -> Integer
    Integral, Integer -> StatxFlags
    StatxFlags -> StatxFlags
    StatxFlags -> StatxFlags -> StatxFlags
    (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags)
    -> (Integer -> StatxFlags)
    -> Num StatxFlags
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: StatxFlags -> StatxFlags -> StatxFlags
    + :: StatxFlags -> StatxFlags -> StatxFlags
    $c- :: StatxFlags -> StatxFlags -> StatxFlags
    - :: StatxFlags -> StatxFlags -> StatxFlags
    $c* :: StatxFlags -> StatxFlags -> StatxFlags
    * :: StatxFlags -> StatxFlags -> StatxFlags
    $cnegate :: StatxFlags -> StatxFlags
    negate :: StatxFlags -> StatxFlags
    $cabs :: StatxFlags -> StatxFlags
    abs :: StatxFlags -> StatxFlags
    $csignum :: StatxFlags -> StatxFlags
    signum :: StatxFlags -> StatxFlags
    $cfromInteger :: Integer -> StatxFlags
    fromInteger :: Integer -> StatxFlags
    Num, Int -> StatxFlags
    StatxFlags -> Int
    StatxFlags -> [StatxFlags]
    StatxFlags -> StatxFlags
    StatxFlags -> StatxFlags -> [StatxFlags]
    StatxFlags -> StatxFlags -> StatxFlags -> [StatxFlags]
    (StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags)
    -> (Int -> StatxFlags)
    -> (StatxFlags -> Int)
    -> (StatxFlags -> [StatxFlags])
    -> (StatxFlags -> StatxFlags -> [StatxFlags])
    -> (StatxFlags -> StatxFlags -> [StatxFlags])
    -> (StatxFlags -> StatxFlags -> StatxFlags -> [StatxFlags])
    -> Enum StatxFlags
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: StatxFlags -> StatxFlags
    succ :: StatxFlags -> StatxFlags
    $cpred :: StatxFlags -> StatxFlags
    pred :: StatxFlags -> StatxFlags
    $ctoEnum :: Int -> StatxFlags
    toEnum :: Int -> StatxFlags
    $cfromEnum :: StatxFlags -> Int
    fromEnum :: StatxFlags -> Int
    $cenumFrom :: StatxFlags -> [StatxFlags]
    enumFrom :: StatxFlags -> [StatxFlags]
    $cenumFromThen :: StatxFlags -> StatxFlags -> [StatxFlags]
    enumFromThen :: StatxFlags -> StatxFlags -> [StatxFlags]
    $cenumFromTo :: StatxFlags -> StatxFlags -> [StatxFlags]
    enumFromTo :: StatxFlags -> StatxFlags -> [StatxFlags]
    $cenumFromThenTo :: StatxFlags -> StatxFlags -> StatxFlags -> [StatxFlags]
    enumFromThenTo :: StatxFlags -> StatxFlags -> StatxFlags -> [StatxFlags]
    Enum, Eq StatxFlags
    StatxFlags
    Eq StatxFlags =>
    (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags -> StatxFlags)
    -> (StatxFlags -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> StatxFlags
    -> (Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> Bool)
    -> (StatxFlags -> Maybe Int)
    -> (StatxFlags -> Int)
    -> (StatxFlags -> Bool)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int -> StatxFlags)
    -> (StatxFlags -> Int)
    -> Bits StatxFlags
    Int -> StatxFlags
    StatxFlags -> Bool
    StatxFlags -> Int
    StatxFlags -> Maybe Int
    StatxFlags -> StatxFlags
    StatxFlags -> Int -> Bool
    StatxFlags -> Int -> StatxFlags
    StatxFlags -> StatxFlags -> StatxFlags
    forall a.
    Eq a =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> a
    -> (Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> Bool)
    -> (a -> Maybe Int)
    -> (a -> Int)
    -> (a -> Bool)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int)
    -> Bits a
    $c.&. :: StatxFlags -> StatxFlags -> StatxFlags
    .&. :: StatxFlags -> StatxFlags -> StatxFlags
    $c.|. :: StatxFlags -> StatxFlags -> StatxFlags
    .|. :: StatxFlags -> StatxFlags -> StatxFlags
    $cxor :: StatxFlags -> StatxFlags -> StatxFlags
    xor :: StatxFlags -> StatxFlags -> StatxFlags
    $ccomplement :: StatxFlags -> StatxFlags
    complement :: StatxFlags -> StatxFlags
    $cshift :: StatxFlags -> Int -> StatxFlags
    shift :: StatxFlags -> Int -> StatxFlags
    $crotate :: StatxFlags -> Int -> StatxFlags
    rotate :: StatxFlags -> Int -> StatxFlags
    $czeroBits :: StatxFlags
    zeroBits :: StatxFlags
    $cbit :: Int -> StatxFlags
    bit :: Int -> StatxFlags
    $csetBit :: StatxFlags -> Int -> StatxFlags
    setBit :: StatxFlags -> Int -> StatxFlags
    $cclearBit :: StatxFlags -> Int -> StatxFlags
    clearBit :: StatxFlags -> Int -> StatxFlags
    $ccomplementBit :: StatxFlags -> Int -> StatxFlags
    complementBit :: StatxFlags -> Int -> StatxFlags
    $ctestBit :: StatxFlags -> Int -> Bool
    testBit :: StatxFlags -> Int -> Bool
    $cbitSizeMaybe :: StatxFlags -> Maybe Int
    bitSizeMaybe :: StatxFlags -> Maybe Int
    $cbitSize :: StatxFlags -> Int
    bitSize :: StatxFlags -> Int
    $cisSigned :: StatxFlags -> Bool
    isSigned :: StatxFlags -> Bool
    $cshiftL :: StatxFlags -> Int -> StatxFlags
    shiftL :: StatxFlags -> Int -> StatxFlags
    $cunsafeShiftL :: StatxFlags -> Int -> StatxFlags
    unsafeShiftL :: StatxFlags -> Int -> StatxFlags
    $cshiftR :: StatxFlags -> Int -> StatxFlags
    shiftR :: StatxFlags -> Int -> StatxFlags
    $cunsafeShiftR :: StatxFlags -> Int -> StatxFlags
    unsafeShiftR :: StatxFlags -> Int -> StatxFlags
    $crotateL :: StatxFlags -> Int -> StatxFlags
    rotateL :: StatxFlags -> Int -> StatxFlags
    $crotateR :: StatxFlags -> Int -> StatxFlags
    rotateR :: StatxFlags -> Int -> StatxFlags
    $cpopCount :: StatxFlags -> Int
    popCount :: StatxFlags -> Int
    Bits, Num StatxFlags
    Ord StatxFlags
    (Num StatxFlags, Ord StatxFlags) =>
    (StatxFlags -> Ratio Integer) -> Real StatxFlags
    StatxFlags -> Ratio Integer
    forall a. (Num a, Ord a) => (a -> Ratio Integer) -> Real a
    $ctoRational :: StatxFlags -> Ratio Integer
    toRational :: StatxFlags -> Ratio Integer
    Real)

    -- | ORs the flags.
    instance Semigroup StatxFlags where
       StatxFlags
    a <> :: StatxFlags -> StatxFlags -> StatxFlags
    <> StatxFlags
    b = StatxFlags
    a StatxFlags -> StatxFlags -> StatxFlags
    forall a. Bits a => a -> a -> a
    .|. StatxFlags
    b

    instance Monoid StatxFlags where
      mappend :: StatxFlags -> StatxFlags -> StatxFlags
    mappend = StatxFlags -> StatxFlags -> StatxFlags
    forall a. Semigroup a => a -> a -> a
    (<>)
      mempty :: StatxFlags
    mempty = StatxFlags
    0

    -- | If pathname to 'getExtendedFileStatus' is an empty string, operate on the file referred to by
    -- the 'Maybe Fd' argument.
    --
    -- In this case, it can refer to any type of file, not just a directory.
    pattern EmptyPath :: StatxFlags

    {-# LINE 801 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern EmptyPath = StatxFlags (4096)
    {-# LINE 802 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 805 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Don't automount the terminal ("basename") component of pathname if it is a directory that is an automount point.
    -- This allows the caller to gather attributes of an automount point (rather than the location it would mount).
    -- This flag can be used in tools that scan directories to prevent mass-automounting of a directory of automount points.
    -- This flag has no effect if the mount point has already been mounted over.
    pattern NoAutoMount :: StatxFlags

    {-# LINE 812 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern NoAutoMount = StatxFlags (2048)
    {-# LINE 813 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 816 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | If pathname is a symbolic link, do not dereference it: instead return information about the link itself, like @lstat(2)@.
    pattern SymlinkNoFollow :: StatxFlags

    {-# LINE 820 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern SymlinkNoFollow = StatxFlags (256)
    {-# LINE 821 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 824 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Do whatever @stat(2)@ does. This is the default and is very much filesystem-specific.
    pattern SyncAsStat :: StatxFlags

    {-# LINE 828 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern SyncAsStat = StatxFlags (0)
    {-# LINE 829 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 832 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Force the attributes to be synchronized with the server.
    -- This may require that a network filesystem perform a data writeback to get the timestamps correct.
    pattern ForceSync :: StatxFlags

    {-# LINE 837 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern ForceSync = StatxFlags (8192)
    {-# LINE 838 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 841 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Don't synchronize anything, but rather just take whatever the system has cached if possible.
    -- This may mean that the information returned is approximate, but, on a network filesystem,
    -- it may not involve a round trip to the server - even if no lease is held.
    pattern DontSync :: StatxFlags

    {-# LINE 847 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern DontSync = StatxFlags (16384)
    {-# LINE 848 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 851 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    defaultStatxFlags :: StatxFlags
    defaultStatxFlags :: StatxFlags
    defaultStatxFlags = StatxFlags
    forall a. Monoid a => a
    mempty

    -- | Mask argument to 'statx'. It's used to tell the kernel which fields the caller is interested in.
    --
    -- See the pattern synonyms for possible masks. These are combined via @(<>)@.
    -- Masks can be tested via `(.&.)`.
    newtype StatxMask = StatxMask CInt deriving (ReadPrec [StatxMask]
    ReadPrec StatxMask
    Int -> ReadS StatxMask
    ReadS [StatxMask]
    (Int -> ReadS StatxMask)
    -> ReadS [StatxMask]
    -> ReadPrec StatxMask
    -> ReadPrec [StatxMask]
    -> Read StatxMask
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS StatxMask
    readsPrec :: Int -> ReadS StatxMask
    $creadList :: ReadS [StatxMask]
    readList :: ReadS [StatxMask]
    $creadPrec :: ReadPrec StatxMask
    readPrec :: ReadPrec StatxMask
    $creadListPrec :: ReadPrec [StatxMask]
    readListPrec :: ReadPrec [StatxMask]
    Read, Int -> StatxMask -> ShowS
    [StatxMask] -> ShowS
    StatxMask -> String
    (Int -> StatxMask -> ShowS)
    -> (StatxMask -> String)
    -> ([StatxMask] -> ShowS)
    -> Show StatxMask
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> StatxMask -> ShowS
    showsPrec :: Int -> StatxMask -> ShowS
    $cshow :: StatxMask -> String
    show :: StatxMask -> String
    $cshowList :: [StatxMask] -> ShowS
    showList :: [StatxMask] -> ShowS
    Show, StatxMask -> StatxMask -> Bool
    (StatxMask -> StatxMask -> Bool)
    -> (StatxMask -> StatxMask -> Bool) -> Eq StatxMask
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StatxMask -> StatxMask -> Bool
    == :: StatxMask -> StatxMask -> Bool
    $c/= :: StatxMask -> StatxMask -> Bool
    /= :: StatxMask -> StatxMask -> Bool
    Eq, Eq StatxMask
    Eq StatxMask =>
    (StatxMask -> StatxMask -> Ordering)
    -> (StatxMask -> StatxMask -> Bool)
    -> (StatxMask -> StatxMask -> Bool)
    -> (StatxMask -> StatxMask -> Bool)
    -> (StatxMask -> StatxMask -> Bool)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> Ord StatxMask
    StatxMask -> StatxMask -> Bool
    StatxMask -> StatxMask -> Ordering
    StatxMask -> StatxMask -> StatxMask
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: StatxMask -> StatxMask -> Ordering
    compare :: StatxMask -> StatxMask -> Ordering
    $c< :: StatxMask -> StatxMask -> Bool
    < :: StatxMask -> StatxMask -> Bool
    $c<= :: StatxMask -> StatxMask -> Bool
    <= :: StatxMask -> StatxMask -> Bool
    $c> :: StatxMask -> StatxMask -> Bool
    > :: StatxMask -> StatxMask -> Bool
    $c>= :: StatxMask -> StatxMask -> Bool
    >= :: StatxMask -> StatxMask -> Bool
    $cmax :: StatxMask -> StatxMask -> StatxMask
    max :: StatxMask -> StatxMask -> StatxMask
    $cmin :: StatxMask -> StatxMask -> StatxMask
    min :: StatxMask -> StatxMask -> StatxMask
    Ord, Enum StatxMask
    Real StatxMask
    (Real StatxMask, Enum StatxMask) =>
    (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> (StatxMask, StatxMask))
    -> (StatxMask -> StatxMask -> (StatxMask, StatxMask))
    -> (StatxMask -> Integer)
    -> Integral StatxMask
    StatxMask -> Integer
    StatxMask -> StatxMask -> (StatxMask, StatxMask)
    StatxMask -> StatxMask -> StatxMask
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: StatxMask -> StatxMask -> StatxMask
    quot :: StatxMask -> StatxMask -> StatxMask
    $crem :: StatxMask -> StatxMask -> StatxMask
    rem :: StatxMask -> StatxMask -> StatxMask
    $cdiv :: StatxMask -> StatxMask -> StatxMask
    div :: StatxMask -> StatxMask -> StatxMask
    $cmod :: StatxMask -> StatxMask -> StatxMask
    mod :: StatxMask -> StatxMask -> StatxMask
    $cquotRem :: StatxMask -> StatxMask -> (StatxMask, StatxMask)
    quotRem :: StatxMask -> StatxMask -> (StatxMask, StatxMask)
    $cdivMod :: StatxMask -> StatxMask -> (StatxMask, StatxMask)
    divMod :: StatxMask -> StatxMask -> (StatxMask, StatxMask)
    $ctoInteger :: StatxMask -> Integer
    toInteger :: StatxMask -> Integer
    Integral, Integer -> StatxMask
    StatxMask -> StatxMask
    StatxMask -> StatxMask -> StatxMask
    (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask)
    -> (Integer -> StatxMask)
    -> Num StatxMask
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: StatxMask -> StatxMask -> StatxMask
    + :: StatxMask -> StatxMask -> StatxMask
    $c- :: StatxMask -> StatxMask -> StatxMask
    - :: StatxMask -> StatxMask -> StatxMask
    $c* :: StatxMask -> StatxMask -> StatxMask
    * :: StatxMask -> StatxMask -> StatxMask
    $cnegate :: StatxMask -> StatxMask
    negate :: StatxMask -> StatxMask
    $cabs :: StatxMask -> StatxMask
    abs :: StatxMask -> StatxMask
    $csignum :: StatxMask -> StatxMask
    signum :: StatxMask -> StatxMask
    $cfromInteger :: Integer -> StatxMask
    fromInteger :: Integer -> StatxMask
    Num, Int -> StatxMask
    StatxMask -> Int
    StatxMask -> [StatxMask]
    StatxMask -> StatxMask
    StatxMask -> StatxMask -> [StatxMask]
    StatxMask -> StatxMask -> StatxMask -> [StatxMask]
    (StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask)
    -> (Int -> StatxMask)
    -> (StatxMask -> Int)
    -> (StatxMask -> [StatxMask])
    -> (StatxMask -> StatxMask -> [StatxMask])
    -> (StatxMask -> StatxMask -> [StatxMask])
    -> (StatxMask -> StatxMask -> StatxMask -> [StatxMask])
    -> Enum StatxMask
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: StatxMask -> StatxMask
    succ :: StatxMask -> StatxMask
    $cpred :: StatxMask -> StatxMask
    pred :: StatxMask -> StatxMask
    $ctoEnum :: Int -> StatxMask
    toEnum :: Int -> StatxMask
    $cfromEnum :: StatxMask -> Int
    fromEnum :: StatxMask -> Int
    $cenumFrom :: StatxMask -> [StatxMask]
    enumFrom :: StatxMask -> [StatxMask]
    $cenumFromThen :: StatxMask -> StatxMask -> [StatxMask]
    enumFromThen :: StatxMask -> StatxMask -> [StatxMask]
    $cenumFromTo :: StatxMask -> StatxMask -> [StatxMask]
    enumFromTo :: StatxMask -> StatxMask -> [StatxMask]
    $cenumFromThenTo :: StatxMask -> StatxMask -> StatxMask -> [StatxMask]
    enumFromThenTo :: StatxMask -> StatxMask -> StatxMask -> [StatxMask]
    Enum, Eq StatxMask
    StatxMask
    Eq StatxMask =>
    (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask -> StatxMask)
    -> (StatxMask -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> StatxMask
    -> (Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> Bool)
    -> (StatxMask -> Maybe Int)
    -> (StatxMask -> Int)
    -> (StatxMask -> Bool)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int -> StatxMask)
    -> (StatxMask -> Int)
    -> Bits StatxMask
    Int -> StatxMask
    StatxMask -> Bool
    StatxMask -> Int
    StatxMask -> Maybe Int
    StatxMask -> StatxMask
    StatxMask -> Int -> Bool
    StatxMask -> Int -> StatxMask
    StatxMask -> StatxMask -> StatxMask
    forall a.
    Eq a =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> a
    -> (Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> Bool)
    -> (a -> Maybe Int)
    -> (a -> Int)
    -> (a -> Bool)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int -> a)
    -> (a -> Int)
    -> Bits a
    $c.&. :: StatxMask -> StatxMask -> StatxMask
    .&. :: StatxMask -> StatxMask -> StatxMask
    $c.|. :: StatxMask -> StatxMask -> StatxMask
    .|. :: StatxMask -> StatxMask -> StatxMask
    $cxor :: StatxMask -> StatxMask -> StatxMask
    xor :: StatxMask -> StatxMask -> StatxMask
    $ccomplement :: StatxMask -> StatxMask
    complement :: StatxMask -> StatxMask
    $cshift :: StatxMask -> Int -> StatxMask
    shift :: StatxMask -> Int -> StatxMask
    $crotate :: StatxMask -> Int -> StatxMask
    rotate :: StatxMask -> Int -> StatxMask
    $czeroBits :: StatxMask
    zeroBits :: StatxMask
    $cbit :: Int -> StatxMask
    bit :: Int -> StatxMask
    $csetBit :: StatxMask -> Int -> StatxMask
    setBit :: StatxMask -> Int -> StatxMask
    $cclearBit :: StatxMask -> Int -> StatxMask
    clearBit :: StatxMask -> Int -> StatxMask
    $ccomplementBit :: StatxMask -> Int -> StatxMask
    complementBit :: StatxMask -> Int -> StatxMask
    $ctestBit :: StatxMask -> Int -> Bool
    testBit :: StatxMask -> Int -> Bool
    $cbitSizeMaybe :: StatxMask -> Maybe Int
    bitSizeMaybe :: StatxMask -> Maybe Int
    $cbitSize :: StatxMask -> Int
    bitSize :: StatxMask -> Int
    $cisSigned :: StatxMask -> Bool
    isSigned :: StatxMask -> Bool
    $cshiftL :: StatxMask -> Int -> StatxMask
    shiftL :: StatxMask -> Int -> StatxMask
    $cunsafeShiftL :: StatxMask -> Int -> StatxMask
    unsafeShiftL :: StatxMask -> Int -> StatxMask
    $cshiftR :: StatxMask -> Int -> StatxMask
    shiftR :: StatxMask -> Int -> StatxMask
    $cunsafeShiftR :: StatxMask -> Int -> StatxMask
    unsafeShiftR :: StatxMask -> Int -> StatxMask
    $crotateL :: StatxMask -> Int -> StatxMask
    rotateL :: StatxMask -> Int -> StatxMask
    $crotateR :: StatxMask -> Int -> StatxMask
    rotateR :: StatxMask -> Int -> StatxMask
    $cpopCount :: StatxMask -> Int
    popCount :: StatxMask -> Int
    Bits, Num StatxMask
    Ord StatxMask
    (Num StatxMask, Ord StatxMask) =>
    (StatxMask -> Ratio Integer) -> Real StatxMask
    StatxMask -> Ratio Integer
    forall a. (Num a, Ord a) => (a -> Ratio Integer) -> Real a
    $ctoRational :: StatxMask -> Ratio Integer
    toRational :: StatxMask -> Ratio Integer
    Real)

    -- | ORs the masks.
    instance Semigroup StatxMask where
       StatxMask
    a <> :: StatxMask -> StatxMask -> StatxMask
    <> StatxMask
    b = StatxMask
    a StatxMask -> StatxMask -> StatxMask
    forall a. Bits a => a -> a -> a
    .|. StatxMask
    b

    instance Monoid StatxMask where
      mappend :: StatxMask -> StatxMask -> StatxMask
    mappend = StatxMask -> StatxMask -> StatxMask
    forall a. Semigroup a => a -> a -> a
    (<>)
      mempty :: StatxMask
    mempty = StatxMask
    0

    -- | Want @stx_mode & S_IFMT@.
    pattern StatxType :: StatxMask

    {-# LINE 872 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxType = StatxMask (1)
    {-# LINE 873 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 876 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_mode & ~S_IFMT@.
    pattern StatxMode :: StatxMask

    {-# LINE 880 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxMode = StatxMask (2)
    {-# LINE 881 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 884 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_nlink@.
    pattern StatxNlink :: StatxMask

    {-# LINE 888 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxNlink = StatxMask (4)
    {-# LINE 889 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 892 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_uid@.
    pattern StatxUid :: StatxMask

    {-# LINE 896 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxUid = StatxMask (8)
    {-# LINE 897 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 900 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_gid@.
    pattern StatxGid :: StatxMask

    {-# LINE 904 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxGid = StatxMask (16)
    {-# LINE 905 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 908 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_atime@.
    pattern StatxAtime :: StatxMask

    {-# LINE 912 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxAtime = StatxMask (32)
    {-# LINE 913 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 916 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_mtime@.
    pattern StatxMtime :: StatxMask

    {-# LINE 920 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxMtime = StatxMask (64)
    {-# LINE 921 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 924 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_ctime@.
    pattern StatxCtime :: StatxMask

    {-# LINE 928 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxCtime = StatxMask (128)
    {-# LINE 929 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 932 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_btime@.
    pattern StatxBtime :: StatxMask

    {-# LINE 936 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxBtime = StatxMask (2048)
    {-# LINE 937 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 940 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_mnt_id@.
    pattern StatxMntId :: StatxMask

    {-# LINE 944 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxMntId = StatxMask (4096)
    {-# LINE 945 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 948 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_ino@.
    pattern StatxIno :: StatxMask

    {-# LINE 952 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxIno = StatxMask (256)
    {-# LINE 953 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 956 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_size@.
    pattern StatxSize :: StatxMask

    {-# LINE 960 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxSize = StatxMask (512)
    {-# LINE 961 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 964 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want @stx_blocks@.
    pattern StatxBlocks :: StatxMask

    {-# LINE 968 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxBlocks = StatxMask (1024)
    {-# LINE 969 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 972 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want all of the above.
    pattern StatxBasicStats :: StatxMask

    {-# LINE 976 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxBasicStats = StatxMask (2047)
    {-# LINE 977 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 980 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Want all currently available fields.
    pattern StatxAll :: StatxMask

    {-# LINE 984 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    pattern StatxAll = StatxMask (4095)
    {-# LINE 985 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 988 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    defaultStatxMask :: StatxMask
    defaultStatxMask :: StatxMask
    defaultStatxMask = StatxMask
    forall a. Monoid a => a
    mempty

    newtype ExtendedFileStatus = ExtendedFileStatus (ForeignPtr CStatx) -- ^ The constructor is considered internal and may change.

    -- | The "preferred" block size for efficient filesystem I/O.
    -- (Writing to a file in smaller chunks may cause an inefficient read-modify-rewrite.)
    fileBlockSizeX             :: ExtendedFileStatus -> CBlkSize

    {-# LINE 999 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    -- | Further status information about the file.
    fileAttributesX            :: ExtendedFileStatus -> CAttributes

    {-# LINE 1002 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    -- | The number of hard links on a file.
    linkCountX                 :: ExtendedFileStatus -> CNlink
    -- | Te user ID of the owner of the file.
    fileOwnerX                 :: ExtendedFileStatus -> UserID
    -- | The ID of the group owner of the file.
    fileGroupX                 :: ExtendedFileStatus -> GroupID
    -- | The file type and mode.  See @inode(7)@ for details.
    fileModeX                  :: ExtendedFileStatus -> FileMode
    -- | The inode number of the file.
    fileIDX                    :: ExtendedFileStatus -> FileID
    -- | The size of the file (if it is a regular file or a symbolic link) in bytes.
    -- The size of a symbolic link is the length of the pathname it contains,
    -- without a terminating null byte.
    fileSizeX                  :: ExtendedFileStatus -> Word64
    -- | The  number of blocks allocated to the file on the medium, in 512-byte units.
    -- (This may be smaller than stx_size/512 when the file has holes.)
    fileBlocksX                :: ExtendedFileStatus -> Word64

    {-# LINE 1020 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    -- | A mask indicating which bits in 'fileAttributesX' are supported by the VFS and the filesystem.
    fileAttributesMaskX        :: ExtendedFileStatus -> CAttributes

    {-# LINE 1023 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    -- | The file's last access timestamp.
    accessTimeHiResX           :: ExtendedFileStatus -> POSIXTime
    -- | The file's creation timestamp.
    creationTimeHiResX         :: ExtendedFileStatus -> POSIXTime
    -- | The file's last status change timestamp.
    statusChangeTimeHiResX     :: ExtendedFileStatus -> POSIXTime
    -- | The file's last modification timestamp.
    modificationTimeHiResX     :: ExtendedFileStatus -> POSIXTime
    -- | ID of the device on which this file resides.
    deviceIDX                  :: ExtendedFileStatus -> DeviceID
    -- | Describes the device that this file represents.
    specialDeviceIDX       :: ExtendedFileStatus -> DeviceID
    -- | The mount ID of the mount containing the file. This is the same number
    -- reported by name_to_handle_at(2) and corresponds to the number in the
    -- first field in one of the records in /proc/self/mountinfo.
    mountIDX               :: ExtendedFileStatus -> Word64
    -- | The file is compressed by the filesystem and may take extra resources to access.
    -- This is an extended attribute.
    fileCompressedX            :: ExtendedFileStatus -> Bool
    -- | The file cannot be modified: it cannot be deleted or renamed, no hard links can
    -- be created to this file and no data can be written to it. See @chattr(1)@.
    -- This is an extended attribute.
    fileImmutableX             :: ExtendedFileStatus -> Bool
    -- | The file can only be opened in append mode for writing. Random access writing is not permitted. See @chattr(1)@.
    -- This is an extended attribute.
    fileAppendX                :: ExtendedFileStatus -> Bool
    -- | File is not a candidate for backup when a backup program such as @dump(8)@ is run. See @chattr(1)@.
    -- This is an extended attribute.
    fileNoDumpX                :: ExtendedFileStatus -> Bool
    -- | A key is required for the file to be encrypted by the filesystem.
    -- This is an extended attribute.
    fileEncryptedX             :: ExtendedFileStatus -> Bool
    -- | The file has fs-verity enabled.  It cannot be written to, and all reads from it
    -- will be verified  against a cryptographic hash that covers the entire file (e.g., via a Merkle tree).
    -- This is an extended attribute.
    -- Since Linux 5.5.
    fileVerityX                :: ExtendedFileStatus -> Bool
    -- | The  file is in the DAX (cpu direct access) state.
    -- This is an extended attribute.
    -- Since Linux 5.8.
    fileDaxX                   :: ExtendedFileStatus -> Bool

    -- | Checks if this file is a block device.
    isBlockDeviceX     :: ExtendedFileStatus -> Bool
    -- | Checks if this file is a character device.
    isCharacterDeviceX :: ExtendedFileStatus -> Bool
    -- | Checks if this file is a named pipe device.
    isNamedPipeX       :: ExtendedFileStatus -> Bool
    -- | Checks if this file is a regular file device.
    isRegularFileX     :: ExtendedFileStatus -> Bool
    -- | Checks if this file is a directory device.
    isDirectoryX       :: ExtendedFileStatus -> Bool
    -- | Checks if this file is a symbolic link device.
    isSymbolicLinkX    :: ExtendedFileStatus -> Bool
    -- | Checks if this file is a socket device.
    isSocketX          :: ExtendedFileStatus -> Bool

    isBlockDeviceX :: ExtendedFileStatus -> Bool
    isBlockDeviceX ExtendedFileStatus
    statx =
      (ExtendedFileStatus -> FileMode
    fileModeX ExtendedFileStatus
    statx FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    blockSpecialMode
    isCharacterDeviceX :: ExtendedFileStatus -> Bool
    isCharacterDeviceX ExtendedFileStatus
    statx =
      (ExtendedFileStatus -> FileMode
    fileModeX ExtendedFileStatus
    statx FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    characterSpecialMode
    isNamedPipeX :: ExtendedFileStatus -> Bool
    isNamedPipeX ExtendedFileStatus
    statx =
      (ExtendedFileStatus -> FileMode
    fileModeX ExtendedFileStatus
    statx FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    namedPipeMode
    isRegularFileX :: ExtendedFileStatus -> Bool
    isRegularFileX ExtendedFileStatus
    statx =
      (ExtendedFileStatus -> FileMode
    fileModeX ExtendedFileStatus
    statx FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    regularFileMode
    isDirectoryX :: ExtendedFileStatus -> Bool
    isDirectoryX ExtendedFileStatus
    statx =
      (ExtendedFileStatus -> FileMode
    fileModeX ExtendedFileStatus
    statx FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    directoryMode
    isSymbolicLinkX :: ExtendedFileStatus -> Bool
    isSymbolicLinkX ExtendedFileStatus
    statx =
      (ExtendedFileStatus -> FileMode
    fileModeX ExtendedFileStatus
    statx FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    symbolicLinkMode
    isSocketX :: ExtendedFileStatus -> Bool
    isSocketX ExtendedFileStatus
    statx =
      (ExtendedFileStatus -> FileMode
    fileModeX ExtendedFileStatus
    statx FileMode -> FileMode -> FileMode
    `intersectFileModes` FileMode
    fileTypeModes) FileMode -> FileMode -> Bool
    forall a. Eq a => a -> a -> Bool
    == FileMode
    socketMode

    {-# LINE 1096 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    testFlag :: ExtendedFileStatus -> CAttributes -> Bool
    testFlag :: ExtendedFileStatus -> CAttributes -> Bool
    testFlag ExtendedFileStatus
    ex CAttributes
    flag =
      let attributes :: CAttributes
    attributes = ExtendedFileStatus -> CAttributes
    fileAttributesX ExtendedFileStatus
    ex
          attributes_mask :: CAttributes
    attributes_mask = ExtendedFileStatus -> CAttributes
    fileAttributesMaskX ExtendedFileStatus
    ex
      in (CAttributes
    attributes CAttributes -> CAttributes -> CAttributes
    forall a. Bits a => a -> a -> a
    .&. CAttributes
    attributes_mask CAttributes -> CAttributes -> CAttributes
    forall a. Bits a => a -> a -> a
    .&. CAttributes
    flag) CAttributes -> CAttributes -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CAttributes
    0

    {-# LINE 1103 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileCompressedX ex = testFlag ex (4)
    {-# LINE 1104 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1108 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1109 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileImmutableX ex = testFlag ex (16)
    {-# LINE 1110 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1114 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1115 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileAppendX ex = testFlag ex (32)
    {-# LINE 1116 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1120 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1121 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileNoDumpX ex = testFlag ex (64)
    {-# LINE 1122 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1126 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1127 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileEncryptedX ex = testFlag ex (2048)
    {-# LINE 1128 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1132 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1133 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileVerityX ex = testFlag ex (1048576)
    {-# LINE 1134 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1138 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    fileDaxX :: ExtendedFileStatus -> Bool
    {-# LINE 1139 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileDaxX ex = testFlag ex (2097152)
    {-# LINE 1140 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1144 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1146 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    deviceIDX (ExtendedFileStatus statx) = unsafePerformIO $ do
      major <- withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 136)) :: IO CUInt
    {-# LINE 1148 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      minor <- withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 140)) :: IO CUInt
    {-# LINE 1149 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      c_makedev major minor

    {-# LINE 1154 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1155 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    specialDeviceIDX (ExtendedFileStatus statx) = unsafePerformIO $ do
      major <- withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 128)) :: IO CUInt
    {-# LINE 1157 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      minor <- withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 132)) :: IO CUInt
    {-# LINE 1158 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      c_makedev major minor

    {-# LINE 1163 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    mountIDX :: ExtendedFileStatus -> Word64
    {-# LINE 1164 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    mountIDX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 144))
    {-# LINE 1166 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1170 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileBlockSizeX :: ExtendedFileStatus -> CBlkSize
    fileBlockSizeX (ExtendedFileStatus ForeignPtr CStatx
    statx) = IO CBlkSize -> CBlkSize
    forall a. IO a -> a
    unsafePerformIO (IO CBlkSize -> CBlkSize) -> IO CBlkSize -> CBlkSize
    forall a b. (a -> b) -> a -> b
    $ do
      r <- ForeignPtr CStatx -> (Ptr CStatx -> IO Word32) -> IO Word32
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr CStatx
    statx ((Ptr CStatx -> IO Word32) -> IO Word32)
    -> (Ptr CStatx -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ ((\Ptr CStatx
    hsc_ptr -> Ptr CStatx -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr CStatx
    hsc_ptr Int
    4)) :: IO Word32
    {-# LINE 1172 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      return $ CBlkSize (fromIntegral r)
    fileAttributesX :: ExtendedFileStatus -> CAttributes
    fileAttributesX (ExtendedFileStatus ForeignPtr CStatx
    statx) =
      IO CAttributes -> CAttributes
    forall a. IO a -> a
    unsafePerformIO (IO CAttributes -> CAttributes) -> IO CAttributes -> CAttributes
    forall a b. (a -> b) -> a -> b
    $ ForeignPtr CStatx
    -> (Ptr CStatx -> IO CAttributes) -> IO CAttributes
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr CStatx
    statx ((Ptr CStatx -> IO CAttributes) -> IO CAttributes)
    -> (Ptr CStatx -> IO CAttributes) -> IO CAttributes
    forall a b. (a -> b) -> a -> b
    $ ((\Ptr CStatx
    hsc_ptr -> Ptr CStatx -> Int -> IO CAttributes
    forall b. Ptr b -> Int -> IO CAttributes
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr CStatx
    hsc_ptr Int
    8))
    {-# LINE 1175 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1176 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    linkCountX (ExtendedFileStatus statx) = unsafePerformIO $ do
      links <- withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 16)) :: IO Word32
    {-# LINE 1178 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      return $ CNlink (fromIntegral links)

    {-# LINE 1183 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1184 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileOwnerX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 20))
    {-# LINE 1186 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1190 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1191 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileGroupX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 24))
    {-# LINE 1193 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1197 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1198 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileModeX (ExtendedFileStatus statx) = unsafePerformIO $ do
      r <- withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 28)) :: IO Word16
    {-# LINE 1200 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      return $ CMode $ fromIntegral r

    {-# LINE 1205 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1206 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileIDX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 32))
    {-# LINE 1208 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1212 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1213 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileSizeX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 40)) :: Word64
    {-# LINE 1215 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1219 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1220 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileBlocksX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ ((\hsc_ptr -> peekByteOff hsc_ptr 48)) :: Word64
    {-# LINE 1222 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1226 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    fileAttributesMaskX :: ExtendedFileStatus -> CAttributes
    fileAttributesMaskX (ExtendedFileStatus ForeignPtr CStatx
    statx) =
      IO CAttributes -> CAttributes
    forall a. IO a -> a
    unsafePerformIO (IO CAttributes -> CAttributes) -> IO CAttributes -> CAttributes
    forall a b. (a -> b) -> a -> b
    $ ForeignPtr CStatx
    -> (Ptr CStatx -> IO CAttributes) -> IO CAttributes
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr CStatx
    statx ((Ptr CStatx -> IO CAttributes) -> IO CAttributes)
    -> (Ptr CStatx -> IO CAttributes) -> IO CAttributes
    forall a b. (a -> b) -> a -> b
    $ ((\Ptr CStatx
    hsc_ptr -> Ptr CStatx -> Int -> IO CAttributes
    forall b. Ptr b -> Int -> IO CAttributes
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr CStatx
    hsc_ptr Int
    56))
    {-# LINE 1228 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1229 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    accessTimeHiResX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ \statx_ptr -> do
        sec  <- ((\hsc_ptr -> peekByteOff hsc_ptr 64)) statx_ptr :: IO EpochTime
    {-# LINE 1232 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        nsec <- ((\hsc_ptr -> peekByteOff hsc_ptr 72)) statx_ptr :: IO (Int32)
    {-# LINE 1233 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        return $ timeHiResToNominalDiffTime sec nsec

    {-# LINE 1238 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1239 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    creationTimeHiResX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ \statx_ptr -> do
        sec  <- ((\hsc_ptr -> peekByteOff hsc_ptr 80)) statx_ptr :: IO EpochTime
    {-# LINE 1242 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        nsec <- ((\hsc_ptr -> peekByteOff hsc_ptr 88)) statx_ptr :: IO (Int32)
    {-# LINE 1243 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        return $ timeHiResToNominalDiffTime sec nsec

    {-# LINE 1248 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1249 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    statusChangeTimeHiResX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ \statx_ptr -> do
        sec  <- ((\hsc_ptr -> peekByteOff hsc_ptr 96)) statx_ptr :: IO EpochTime
    {-# LINE 1252 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        nsec <- ((\hsc_ptr -> peekByteOff hsc_ptr 104)) statx_ptr :: IO (Int32)
    {-# LINE 1253 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        return $ timeHiResToNominalDiffTime sec nsec

    {-# LINE 1258 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1259 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    modificationTimeHiResX (ExtendedFileStatus statx) =
      unsafePerformIO $ withForeignPtr statx $ \statx_ptr -> do
        sec  <- ((\hsc_ptr -> peekByteOff hsc_ptr 112)) statx_ptr :: IO EpochTime
    {-# LINE 1262 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        nsec <- ((\hsc_ptr -> peekByteOff hsc_ptr 120)) statx_ptr :: IO (Int32)
    {-# LINE 1263 "libraries/unix/System/Posix/Files/Common.hsc" #-}
        return $ timeHiResToNominalDiffTime sec nsec

    {-# LINE 1268 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    timeHiResToNominalDiffTime :: EpochTime -> Int32 -> POSIXTime
    timeHiResToNominalDiffTime :: EpochTime -> Int32 -> POSIXTime
    timeHiResToNominalDiffTime (CTime Int64
    sec) Int32
    nsec = Pico -> POSIXTime
    secondsToNominalDiffTime (Pico -> POSIXTime) -> Pico -> POSIXTime
    forall a b. (a -> b) -> a -> b
    $ Integer -> Pico
    forall k (a :: k). Integer -> Fixed a
    MkFixed (Integer -> Pico) -> Integer -> Pico
    forall a b. (a -> b) -> a -> b
    $ Int64 -> Integer
    forall a. Integral a => a -> Integer
    toInteger Int64
    sec Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    * Integer
    1e12 Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    + Int32 -> Integer
    forall a. Integral a => a -> Integer
    toInteger Int32
    nsec Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    * Integer
    1e3

    {-# LINE 1318 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    data {-# CTYPE "struct statx" #-} CStatx

    {-# LINE 1322 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    foreign import capi unsafe "sys/stat.h statx"
       c_statx :: CInt -> CFilePath -> CInt -> CInt -> Ptr CStatx -> IO CInt

    {-# LINE 1326 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    foreign import capi unsafe "sys/sysmacros.h makedev"
      c_makedev :: CUInt -> CUInt -> IO CDev

    {-# LINE 1329 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1330 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    getExtendedFileStatus_ :: Maybe Fd  -- ^ Optional directory file descriptor
                           -> CString   -- ^ Pathname to open
                           -> StatxFlags
                           -> StatxMask
                           -> IO ExtendedFileStatus

    {-# LINE 1338 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    getExtendedFileStatus_ fdMay str (StatxFlags flags) (StatxMask masks) = do
      fp <- mallocForeignPtrBytes (256)
    {-# LINE 1340 "libraries/unix/System/Posix/Files/Common.hsc" #-}
      withForeignPtr fp $ \p ->
          throwErrnoIfMinus1_ "getExtendedFileStatus_" (c_statx c_fd str flags masks p)
      return (ExtendedFileStatus fp)
     where
      c_fd = maybe (-100) (\ (Fd fd) -> fd) fdMay
    {-# LINE 1345 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    {-# LINE 1349 "libraries/unix/System/Posix/Files/Common.hsc" #-}

    -- | Whether 'statx' is available on this platform and 'getExtendedFileStatus' and
    -- related functions will work.
    haveStatx :: Bool

    {-# LINE 1354 "libraries/unix/System/Posix/Files/Common.hsc" #-}
    haveStatx = True

    {-# LINE 1358 "libraries/unix/System/Posix/Files/Common.hsc" #-}