    {-# LINE 1 "src/Bindings/HDF5/Raw/H5.hsc" #-}
    module Bindings.HDF5.Raw.H5 where

    import Data.Bits
    import Data.Int
    import Data.Version
    import Data.Word
    import Foreign.C.Types
    import Foreign.Ptr
    import Foreign.Storable

    import Foreign.Ptr.Conventions

    -- *Version numbers

    -- |For major interface/format changes
    h5_VERS_MAJOR :: forall a. Num a => a
    h5_VERS_MAJOR = a
    1
    h5_VERS_MAJOR :: (Num a) => a

    {-# LINE 19 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |For minor interface/format changes
    h5_VERS_MINOR = 14
    h5_VERS_MINOR :: (Num a) => a

    {-# LINE 22 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |For tweaks, bug-fixes, or development
    h5_VERS_RELEASE = 6
    h5_VERS_RELEASE :: (Num a) => a

    {-# LINE 25 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |For pre-releases like snap0
    h5_VERS_SUBRELEASE :: String
    h5_VERS_SUBRELEASE :: String
    h5_VERS_SUBRELEASE = String
    ""

    {-# LINE 28 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |'h5_VERS_MAJOR', et al., wrapped up as a 'Version'
    vers :: Version
    vers :: Version
    vers = [Int] -> [String] -> Version
    Version
        [ Int
    forall a. Num a => a
    h5_VERS_MAJOR
        , Int
    forall a. Num a => a
    h5_VERS_MINOR
        , Int
    forall a. Num a => a
    h5_VERS_RELEASE
        ]
        ((String -> Bool) -> [String] -> [String]
    forall a. (a -> Bool) -> [a] -> [a]
    filter (Bool -> Bool
    not(Bool -> Bool) -> (String -> Bool) -> String -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .String -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null) [ String
    h5_VERS_SUBRELEASE ])

    -- |Full version string
    h5_VERS_INFO :: String
    h5_VERS_INFO :: String
    h5_VERS_INFO = String
    "HDF5 library version: 1.14.6"

    {-# LINE 40 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Check that the HDF5 library that is linked with the current executable is
    -- the same version that these bindings were compiled against.  Returns 0 on
    -- success, calls abort() on failure.
    foreign import ccall "inline_H5check" h5_check
      :: HErr_t

    {-# LINE 45 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- * Types and constants

    -- |Status return values.  Failed integer functions in HDF5 result almost
    -- always in a negative value (unsigned failing functions sometimes return
    -- zero for failure) while successfull return is non-negative (often zero).
    -- The negative failure value is most commonly -1, but don't bet on it.  The
    -- proper way to detect failure is something like:
    --
    -- @
    -- if((dset = H5Dopen2(file, name)) < 0)
    --    fprintf(stderr, "unable to open the requested dataset\n");
    -- @
    newtype HErr_t = HErr_t Int32 deriving (Ptr HErr_t -> IO HErr_t
    Ptr HErr_t -> Int -> IO HErr_t
    Ptr HErr_t -> Int -> HErr_t -> IO ()
    Ptr HErr_t -> HErr_t -> IO ()
    HErr_t -> Int
    (HErr_t -> Int)
    -> (HErr_t -> Int)
    -> (Ptr HErr_t -> Int -> IO HErr_t)
    -> (Ptr HErr_t -> Int -> HErr_t -> IO ())
    -> (forall b. Ptr b -> Int -> IO HErr_t)
    -> (forall b. Ptr b -> Int -> HErr_t -> IO ())
    -> (Ptr HErr_t -> IO HErr_t)
    -> (Ptr HErr_t -> HErr_t -> IO ())
    -> Storable HErr_t
    forall b. Ptr b -> Int -> IO HErr_t
    forall b. Ptr b -> Int -> HErr_t -> 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 :: HErr_t -> Int
    sizeOf :: HErr_t -> Int
    $calignment :: HErr_t -> Int
    alignment :: HErr_t -> Int
    $cpeekElemOff :: Ptr HErr_t -> Int -> IO HErr_t
    peekElemOff :: Ptr HErr_t -> Int -> IO HErr_t
    $cpokeElemOff :: Ptr HErr_t -> Int -> HErr_t -> IO ()
    pokeElemOff :: Ptr HErr_t -> Int -> HErr_t -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO HErr_t
    peekByteOff :: forall b. Ptr b -> Int -> IO HErr_t
    $cpokeByteOff :: forall b. Ptr b -> Int -> HErr_t -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> HErr_t -> IO ()
    $cpeek :: Ptr HErr_t -> IO HErr_t
    peek :: Ptr HErr_t -> IO HErr_t
    $cpoke :: Ptr HErr_t -> HErr_t -> IO ()
    poke :: Ptr HErr_t -> HErr_t -> IO ()
    Storable, Int -> HErr_t -> ShowS
    [HErr_t] -> ShowS
    HErr_t -> String
    (Int -> HErr_t -> ShowS)
    -> (HErr_t -> String) -> ([HErr_t] -> ShowS) -> Show HErr_t
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HErr_t -> ShowS
    showsPrec :: Int -> HErr_t -> ShowS
    $cshow :: HErr_t -> String
    show :: HErr_t -> String
    $cshowList :: [HErr_t] -> ShowS
    showList :: [HErr_t] -> ShowS
    Show, HErr_t -> HErr_t -> Bool
    (HErr_t -> HErr_t -> Bool)
    -> (HErr_t -> HErr_t -> Bool) -> Eq HErr_t
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HErr_t -> HErr_t -> Bool
    == :: HErr_t -> HErr_t -> Bool
    $c/= :: HErr_t -> HErr_t -> Bool
    /= :: HErr_t -> HErr_t -> Bool
    Eq, Eq HErr_t
    Eq HErr_t =>
    (HErr_t -> HErr_t -> Ordering)
    -> (HErr_t -> HErr_t -> Bool)
    -> (HErr_t -> HErr_t -> Bool)
    -> (HErr_t -> HErr_t -> Bool)
    -> (HErr_t -> HErr_t -> Bool)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> Ord HErr_t
    HErr_t -> HErr_t -> Bool
    HErr_t -> HErr_t -> Ordering
    HErr_t -> HErr_t -> HErr_t
    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 :: HErr_t -> HErr_t -> Ordering
    compare :: HErr_t -> HErr_t -> Ordering
    $c< :: HErr_t -> HErr_t -> Bool
    < :: HErr_t -> HErr_t -> Bool
    $c<= :: HErr_t -> HErr_t -> Bool
    <= :: HErr_t -> HErr_t -> Bool
    $c> :: HErr_t -> HErr_t -> Bool
    > :: HErr_t -> HErr_t -> Bool
    $c>= :: HErr_t -> HErr_t -> Bool
    >= :: HErr_t -> HErr_t -> Bool
    $cmax :: HErr_t -> HErr_t -> HErr_t
    max :: HErr_t -> HErr_t -> HErr_t
    $cmin :: HErr_t -> HErr_t -> HErr_t
    min :: HErr_t -> HErr_t -> HErr_t
    Ord, Integer -> HErr_t
    HErr_t -> HErr_t
    HErr_t -> HErr_t -> HErr_t
    (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t)
    -> (Integer -> HErr_t)
    -> Num HErr_t
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: HErr_t -> HErr_t -> HErr_t
    + :: HErr_t -> HErr_t -> HErr_t
    $c- :: HErr_t -> HErr_t -> HErr_t
    - :: HErr_t -> HErr_t -> HErr_t
    $c* :: HErr_t -> HErr_t -> HErr_t
    * :: HErr_t -> HErr_t -> HErr_t
    $cnegate :: HErr_t -> HErr_t
    negate :: HErr_t -> HErr_t
    $cabs :: HErr_t -> HErr_t
    abs :: HErr_t -> HErr_t
    $csignum :: HErr_t -> HErr_t
    signum :: HErr_t -> HErr_t
    $cfromInteger :: Integer -> HErr_t
    fromInteger :: Integer -> HErr_t
    Num, Num HErr_t
    Ord HErr_t
    (Num HErr_t, Ord HErr_t) => (HErr_t -> Rational) -> Real HErr_t
    HErr_t -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: HErr_t -> Rational
    toRational :: HErr_t -> Rational
    Real, Eq HErr_t
    HErr_t
    Eq HErr_t =>
    (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> HErr_t
    -> (Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> Bool)
    -> (HErr_t -> Maybe Int)
    -> (HErr_t -> Int)
    -> (HErr_t -> Bool)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int -> HErr_t)
    -> (HErr_t -> Int)
    -> Bits HErr_t
    Int -> HErr_t
    HErr_t -> Bool
    HErr_t -> Int
    HErr_t -> Maybe Int
    HErr_t -> HErr_t
    HErr_t -> Int -> Bool
    HErr_t -> Int -> HErr_t
    HErr_t -> HErr_t -> HErr_t
    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.&. :: HErr_t -> HErr_t -> HErr_t
    .&. :: HErr_t -> HErr_t -> HErr_t
    $c.|. :: HErr_t -> HErr_t -> HErr_t
    .|. :: HErr_t -> HErr_t -> HErr_t
    $cxor :: HErr_t -> HErr_t -> HErr_t
    xor :: HErr_t -> HErr_t -> HErr_t
    $ccomplement :: HErr_t -> HErr_t
    complement :: HErr_t -> HErr_t
    $cshift :: HErr_t -> Int -> HErr_t
    shift :: HErr_t -> Int -> HErr_t
    $crotate :: HErr_t -> Int -> HErr_t
    rotate :: HErr_t -> Int -> HErr_t
    $czeroBits :: HErr_t
    zeroBits :: HErr_t
    $cbit :: Int -> HErr_t
    bit :: Int -> HErr_t
    $csetBit :: HErr_t -> Int -> HErr_t
    setBit :: HErr_t -> Int -> HErr_t
    $cclearBit :: HErr_t -> Int -> HErr_t
    clearBit :: HErr_t -> Int -> HErr_t
    $ccomplementBit :: HErr_t -> Int -> HErr_t
    complementBit :: HErr_t -> Int -> HErr_t
    $ctestBit :: HErr_t -> Int -> Bool
    testBit :: HErr_t -> Int -> Bool
    $cbitSizeMaybe :: HErr_t -> Maybe Int
    bitSizeMaybe :: HErr_t -> Maybe Int
    $cbitSize :: HErr_t -> Int
    bitSize :: HErr_t -> Int
    $cisSigned :: HErr_t -> Bool
    isSigned :: HErr_t -> Bool
    $cshiftL :: HErr_t -> Int -> HErr_t
    shiftL :: HErr_t -> Int -> HErr_t
    $cunsafeShiftL :: HErr_t -> Int -> HErr_t
    unsafeShiftL :: HErr_t -> Int -> HErr_t
    $cshiftR :: HErr_t -> Int -> HErr_t
    shiftR :: HErr_t -> Int -> HErr_t
    $cunsafeShiftR :: HErr_t -> Int -> HErr_t
    unsafeShiftR :: HErr_t -> Int -> HErr_t
    $crotateL :: HErr_t -> Int -> HErr_t
    rotateL :: HErr_t -> Int -> HErr_t
    $crotateR :: HErr_t -> Int -> HErr_t
    rotateR :: HErr_t -> Int -> HErr_t
    $cpopCount :: HErr_t -> Int
    popCount :: HErr_t -> Int
    Bits, Int -> HErr_t
    HErr_t -> Int
    HErr_t -> [HErr_t]
    HErr_t -> HErr_t
    HErr_t -> HErr_t -> [HErr_t]
    HErr_t -> HErr_t -> HErr_t -> [HErr_t]
    (HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t)
    -> (Int -> HErr_t)
    -> (HErr_t -> Int)
    -> (HErr_t -> [HErr_t])
    -> (HErr_t -> HErr_t -> [HErr_t])
    -> (HErr_t -> HErr_t -> [HErr_t])
    -> (HErr_t -> HErr_t -> HErr_t -> [HErr_t])
    -> Enum HErr_t
    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 :: HErr_t -> HErr_t
    succ :: HErr_t -> HErr_t
    $cpred :: HErr_t -> HErr_t
    pred :: HErr_t -> HErr_t
    $ctoEnum :: Int -> HErr_t
    toEnum :: Int -> HErr_t
    $cfromEnum :: HErr_t -> Int
    fromEnum :: HErr_t -> Int
    $cenumFrom :: HErr_t -> [HErr_t]
    enumFrom :: HErr_t -> [HErr_t]
    $cenumFromThen :: HErr_t -> HErr_t -> [HErr_t]
    enumFromThen :: HErr_t -> HErr_t -> [HErr_t]
    $cenumFromTo :: HErr_t -> HErr_t -> [HErr_t]
    enumFromTo :: HErr_t -> HErr_t -> [HErr_t]
    $cenumFromThenTo :: HErr_t -> HErr_t -> HErr_t -> [HErr_t]
    enumFromThenTo :: HErr_t -> HErr_t -> HErr_t -> [HErr_t]
    Enum, HErr_t
    HErr_t -> HErr_t -> Bounded HErr_t
    forall a. a -> a -> Bounded a
    $cminBound :: HErr_t
    minBound :: HErr_t
    $cmaxBound :: HErr_t
    maxBound :: HErr_t
    Bounded, Enum HErr_t
    Real HErr_t
    (Real HErr_t, Enum HErr_t) =>
    (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> HErr_t)
    -> (HErr_t -> HErr_t -> (HErr_t, HErr_t))
    -> (HErr_t -> HErr_t -> (HErr_t, HErr_t))
    -> (HErr_t -> Integer)
    -> Integral HErr_t
    HErr_t -> Integer
    HErr_t -> HErr_t -> (HErr_t, HErr_t)
    HErr_t -> HErr_t -> HErr_t
    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 :: HErr_t -> HErr_t -> HErr_t
    quot :: HErr_t -> HErr_t -> HErr_t
    $crem :: HErr_t -> HErr_t -> HErr_t
    rem :: HErr_t -> HErr_t -> HErr_t
    $cdiv :: HErr_t -> HErr_t -> HErr_t
    div :: HErr_t -> HErr_t -> HErr_t
    $cmod :: HErr_t -> HErr_t -> HErr_t
    mod :: HErr_t -> HErr_t -> HErr_t
    $cquotRem :: HErr_t -> HErr_t -> (HErr_t, HErr_t)
    quotRem :: HErr_t -> HErr_t -> (HErr_t, HErr_t)
    $cdivMod :: HErr_t -> HErr_t -> (HErr_t, HErr_t)
    divMod :: HErr_t -> HErr_t -> (HErr_t, HErr_t)
    $ctoInteger :: HErr_t -> Integer
    toInteger :: HErr_t -> Integer
    Integral)

    {-# LINE 59 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Boolean type.  Successful return values are zero (false) or positive
    -- (true). The typical true value is 1 but don't bet on it.  Boolean
    -- functions cannot fail.  Functions that return `htri_t' however return zero
    -- (false), positive (true), or negative (failure). The proper way to test
    -- for truth from a htri_t function is:
    --
    -- @
    --  if ((retval = H5Tcommitted(type))>0) {
    --    printf("data type is committed\n");
    --  } else if (!retval) {
    --    printf("data type is not committed\n");
    --  } else {
    --    printf("error determining whether data type is committed\n");
    --  }
    -- @
    newtype HBool_t = HBool_t Word8 deriving (Ptr HBool_t -> IO HBool_t
    Ptr HBool_t -> Int -> IO HBool_t
    Ptr HBool_t -> Int -> HBool_t -> IO ()
    Ptr HBool_t -> HBool_t -> IO ()
    HBool_t -> Int
    (HBool_t -> Int)
    -> (HBool_t -> Int)
    -> (Ptr HBool_t -> Int -> IO HBool_t)
    -> (Ptr HBool_t -> Int -> HBool_t -> IO ())
    -> (forall b. Ptr b -> Int -> IO HBool_t)
    -> (forall b. Ptr b -> Int -> HBool_t -> IO ())
    -> (Ptr HBool_t -> IO HBool_t)
    -> (Ptr HBool_t -> HBool_t -> IO ())
    -> Storable HBool_t
    forall b. Ptr b -> Int -> IO HBool_t
    forall b. Ptr b -> Int -> HBool_t -> 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 :: HBool_t -> Int
    sizeOf :: HBool_t -> Int
    $calignment :: HBool_t -> Int
    alignment :: HBool_t -> Int
    $cpeekElemOff :: Ptr HBool_t -> Int -> IO HBool_t
    peekElemOff :: Ptr HBool_t -> Int -> IO HBool_t
    $cpokeElemOff :: Ptr HBool_t -> Int -> HBool_t -> IO ()
    pokeElemOff :: Ptr HBool_t -> Int -> HBool_t -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO HBool_t
    peekByteOff :: forall b. Ptr b -> Int -> IO HBool_t
    $cpokeByteOff :: forall b. Ptr b -> Int -> HBool_t -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> HBool_t -> IO ()
    $cpeek :: Ptr HBool_t -> IO HBool_t
    peek :: Ptr HBool_t -> IO HBool_t
    $cpoke :: Ptr HBool_t -> HBool_t -> IO ()
    poke :: Ptr HBool_t -> HBool_t -> IO ()
    Storable, Int -> HBool_t -> ShowS
    [HBool_t] -> ShowS
    HBool_t -> String
    (Int -> HBool_t -> ShowS)
    -> (HBool_t -> String) -> ([HBool_t] -> ShowS) -> Show HBool_t
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HBool_t -> ShowS
    showsPrec :: Int -> HBool_t -> ShowS
    $cshow :: HBool_t -> String
    show :: HBool_t -> String
    $cshowList :: [HBool_t] -> ShowS
    showList :: [HBool_t] -> ShowS
    Show)

    {-# LINE 76 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    instance Eq HBool_t where
        HBool_t x == HBool_t y
            = (x /= 0) == (y /= 0)

    newtype HTri_t = HTri_t Int32 deriving (Ptr HTri_t -> IO HTri_t
    Ptr HTri_t -> Int -> IO HTri_t
    Ptr HTri_t -> Int -> HTri_t -> IO ()
    Ptr HTri_t -> HTri_t -> IO ()
    HTri_t -> Int
    (HTri_t -> Int)
    -> (HTri_t -> Int)
    -> (Ptr HTri_t -> Int -> IO HTri_t)
    -> (Ptr HTri_t -> Int -> HTri_t -> IO ())
    -> (forall b. Ptr b -> Int -> IO HTri_t)
    -> (forall b. Ptr b -> Int -> HTri_t -> IO ())
    -> (Ptr HTri_t -> IO HTri_t)
    -> (Ptr HTri_t -> HTri_t -> IO ())
    -> Storable HTri_t
    forall b. Ptr b -> Int -> IO HTri_t
    forall b. Ptr b -> Int -> HTri_t -> 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 :: HTri_t -> Int
    sizeOf :: HTri_t -> Int
    $calignment :: HTri_t -> Int
    alignment :: HTri_t -> Int
    $cpeekElemOff :: Ptr HTri_t -> Int -> IO HTri_t
    peekElemOff :: Ptr HTri_t -> Int -> IO HTri_t
    $cpokeElemOff :: Ptr HTri_t -> Int -> HTri_t -> IO ()
    pokeElemOff :: Ptr HTri_t -> Int -> HTri_t -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO HTri_t
    peekByteOff :: forall b. Ptr b -> Int -> IO HTri_t
    $cpokeByteOff :: forall b. Ptr b -> Int -> HTri_t -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> HTri_t -> IO ()
    $cpeek :: Ptr HTri_t -> IO HTri_t
    peek :: Ptr HTri_t -> IO HTri_t
    $cpoke :: Ptr HTri_t -> HTri_t -> IO ()
    poke :: Ptr HTri_t -> HTri_t -> IO ()
    Storable, Int -> HTri_t -> ShowS
    [HTri_t] -> ShowS
    HTri_t -> String
    (Int -> HTri_t -> ShowS)
    -> (HTri_t -> String) -> ([HTri_t] -> ShowS) -> Show HTri_t
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HTri_t -> ShowS
    showsPrec :: Int -> HTri_t -> ShowS
    $cshow :: HTri_t -> String
    show :: HTri_t -> String
    $cshowList :: [HTri_t] -> ShowS
    showList :: [HTri_t] -> ShowS
    Show)

    {-# LINE 82 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    instance Eq HTri_t where
        HTri_t x == HTri_t y
            = compare x 0 == compare y 0

    -- |C signed size type.  This is a semi-standard POSIX type that isn't in
    -- the "Foreign.C.Types" module.  It is in "System.Posix.Types", but I'm not
    -- sure whether that module is available on all platforms.
    newtype CSSize = CSSize Int64 deriving (Ptr CSSize -> IO CSSize
    Ptr CSSize -> Int -> IO CSSize
    Ptr CSSize -> Int -> CSSize -> IO ()
    Ptr CSSize -> CSSize -> IO ()
    CSSize -> Int
    (CSSize -> Int)
    -> (CSSize -> Int)
    -> (Ptr CSSize -> Int -> IO CSSize)
    -> (Ptr CSSize -> Int -> CSSize -> IO ())
    -> (forall b. Ptr b -> Int -> IO CSSize)
    -> (forall b. Ptr b -> Int -> CSSize -> IO ())
    -> (Ptr CSSize -> IO CSSize)
    -> (Ptr CSSize -> CSSize -> IO ())
    -> Storable CSSize
    forall b. Ptr b -> Int -> IO CSSize
    forall b. Ptr b -> Int -> CSSize -> 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 :: CSSize -> Int
    sizeOf :: CSSize -> Int
    $calignment :: CSSize -> Int
    alignment :: CSSize -> Int
    $cpeekElemOff :: Ptr CSSize -> Int -> IO CSSize
    peekElemOff :: Ptr CSSize -> Int -> IO CSSize
    $cpokeElemOff :: Ptr CSSize -> Int -> CSSize -> IO ()
    pokeElemOff :: Ptr CSSize -> Int -> CSSize -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO CSSize
    peekByteOff :: forall b. Ptr b -> Int -> IO CSSize
    $cpokeByteOff :: forall b. Ptr b -> Int -> CSSize -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> CSSize -> IO ()
    $cpeek :: Ptr CSSize -> IO CSSize
    peek :: Ptr CSSize -> IO CSSize
    $cpoke :: Ptr CSSize -> CSSize -> IO ()
    poke :: Ptr CSSize -> CSSize -> IO ()
    Storable, Int -> CSSize -> ShowS
    [CSSize] -> ShowS
    CSSize -> String
    (Int -> CSSize -> ShowS)
    -> (CSSize -> String) -> ([CSSize] -> ShowS) -> Show CSSize
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CSSize -> ShowS
    showsPrec :: Int -> CSSize -> ShowS
    $cshow :: CSSize -> String
    show :: CSSize -> String
    $cshowList :: [CSSize] -> ShowS
    showList :: [CSSize] -> ShowS
    Show, CSSize -> CSSize -> Bool
    (CSSize -> CSSize -> Bool)
    -> (CSSize -> CSSize -> Bool) -> Eq CSSize
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CSSize -> CSSize -> Bool
    == :: CSSize -> CSSize -> Bool
    $c/= :: CSSize -> CSSize -> Bool
    /= :: CSSize -> CSSize -> Bool
    Eq, Eq CSSize
    Eq CSSize =>
    (CSSize -> CSSize -> Ordering)
    -> (CSSize -> CSSize -> Bool)
    -> (CSSize -> CSSize -> Bool)
    -> (CSSize -> CSSize -> Bool)
    -> (CSSize -> CSSize -> Bool)
    -> (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> CSSize)
    -> Ord CSSize
    CSSize -> CSSize -> Bool
    CSSize -> CSSize -> Ordering
    CSSize -> CSSize -> CSSize
    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 :: CSSize -> CSSize -> Ordering
    compare :: CSSize -> CSSize -> Ordering
    $c< :: CSSize -> CSSize -> Bool
    < :: CSSize -> CSSize -> Bool
    $c<= :: CSSize -> CSSize -> Bool
    <= :: CSSize -> CSSize -> Bool
    $c> :: CSSize -> CSSize -> Bool
    > :: CSSize -> CSSize -> Bool
    $c>= :: CSSize -> CSSize -> Bool
    >= :: CSSize -> CSSize -> Bool
    $cmax :: CSSize -> CSSize -> CSSize
    max :: CSSize -> CSSize -> CSSize
    $cmin :: CSSize -> CSSize -> CSSize
    min :: CSSize -> CSSize -> CSSize
    Ord, Integer -> CSSize
    CSSize -> CSSize
    CSSize -> CSSize -> CSSize
    (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize)
    -> (CSSize -> CSSize)
    -> (CSSize -> CSSize)
    -> (Integer -> CSSize)
    -> Num CSSize
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: CSSize -> CSSize -> CSSize
    + :: CSSize -> CSSize -> CSSize
    $c- :: CSSize -> CSSize -> CSSize
    - :: CSSize -> CSSize -> CSSize
    $c* :: CSSize -> CSSize -> CSSize
    * :: CSSize -> CSSize -> CSSize
    $cnegate :: CSSize -> CSSize
    negate :: CSSize -> CSSize
    $cabs :: CSSize -> CSSize
    abs :: CSSize -> CSSize
    $csignum :: CSSize -> CSSize
    signum :: CSSize -> CSSize
    $cfromInteger :: Integer -> CSSize
    fromInteger :: Integer -> CSSize
    Num, Eq CSSize
    CSSize
    Eq CSSize =>
    (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> CSSize
    -> (Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> Bool)
    -> (CSSize -> Maybe Int)
    -> (CSSize -> Int)
    -> (CSSize -> Bool)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int -> CSSize)
    -> (CSSize -> Int)
    -> Bits CSSize
    Int -> CSSize
    CSSize -> Bool
    CSSize -> Int
    CSSize -> Maybe Int
    CSSize -> CSSize
    CSSize -> Int -> Bool
    CSSize -> Int -> CSSize
    CSSize -> CSSize -> CSSize
    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.&. :: CSSize -> CSSize -> CSSize
    .&. :: CSSize -> CSSize -> CSSize
    $c.|. :: CSSize -> CSSize -> CSSize
    .|. :: CSSize -> CSSize -> CSSize
    $cxor :: CSSize -> CSSize -> CSSize
    xor :: CSSize -> CSSize -> CSSize
    $ccomplement :: CSSize -> CSSize
    complement :: CSSize -> CSSize
    $cshift :: CSSize -> Int -> CSSize
    shift :: CSSize -> Int -> CSSize
    $crotate :: CSSize -> Int -> CSSize
    rotate :: CSSize -> Int -> CSSize
    $czeroBits :: CSSize
    zeroBits :: CSSize
    $cbit :: Int -> CSSize
    bit :: Int -> CSSize
    $csetBit :: CSSize -> Int -> CSSize
    setBit :: CSSize -> Int -> CSSize
    $cclearBit :: CSSize -> Int -> CSSize
    clearBit :: CSSize -> Int -> CSSize
    $ccomplementBit :: CSSize -> Int -> CSSize
    complementBit :: CSSize -> Int -> CSSize
    $ctestBit :: CSSize -> Int -> Bool
    testBit :: CSSize -> Int -> Bool
    $cbitSizeMaybe :: CSSize -> Maybe Int
    bitSizeMaybe :: CSSize -> Maybe Int
    $cbitSize :: CSSize -> Int
    bitSize :: CSSize -> Int
    $cisSigned :: CSSize -> Bool
    isSigned :: CSSize -> Bool
    $cshiftL :: CSSize -> Int -> CSSize
    shiftL :: CSSize -> Int -> CSSize
    $cunsafeShiftL :: CSSize -> Int -> CSSize
    unsafeShiftL :: CSSize -> Int -> CSSize
    $cshiftR :: CSSize -> Int -> CSSize
    shiftR :: CSSize -> Int -> CSSize
    $cunsafeShiftR :: CSSize -> Int -> CSSize
    unsafeShiftR :: CSSize -> Int -> CSSize
    $crotateL :: CSSize -> Int -> CSSize
    rotateL :: CSSize -> Int -> CSSize
    $crotateR :: CSSize -> Int -> CSSize
    rotateR :: CSSize -> Int -> CSSize
    $cpopCount :: CSSize -> Int
    popCount :: CSSize -> Int
    Bits, Int -> CSSize
    CSSize -> Int
    CSSize -> [CSSize]
    CSSize -> CSSize
    CSSize -> CSSize -> [CSSize]
    CSSize -> CSSize -> CSSize -> [CSSize]
    (CSSize -> CSSize)
    -> (CSSize -> CSSize)
    -> (Int -> CSSize)
    -> (CSSize -> Int)
    -> (CSSize -> [CSSize])
    -> (CSSize -> CSSize -> [CSSize])
    -> (CSSize -> CSSize -> [CSSize])
    -> (CSSize -> CSSize -> CSSize -> [CSSize])
    -> Enum CSSize
    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 :: CSSize -> CSSize
    succ :: CSSize -> CSSize
    $cpred :: CSSize -> CSSize
    pred :: CSSize -> CSSize
    $ctoEnum :: Int -> CSSize
    toEnum :: Int -> CSSize
    $cfromEnum :: CSSize -> Int
    fromEnum :: CSSize -> Int
    $cenumFrom :: CSSize -> [CSSize]
    enumFrom :: CSSize -> [CSSize]
    $cenumFromThen :: CSSize -> CSSize -> [CSSize]
    enumFromThen :: CSSize -> CSSize -> [CSSize]
    $cenumFromTo :: CSSize -> CSSize -> [CSSize]
    enumFromTo :: CSSize -> CSSize -> [CSSize]
    $cenumFromThenTo :: CSSize -> CSSize -> CSSize -> [CSSize]
    enumFromThenTo :: CSSize -> CSSize -> CSSize -> [CSSize]
    Enum, CSSize
    CSSize -> CSSize -> Bounded CSSize
    forall a. a -> a -> Bounded a
    $cminBound :: CSSize
    minBound :: CSSize
    $cmaxBound :: CSSize
    maxBound :: CSSize
    Bounded, Num CSSize
    Ord CSSize
    (Num CSSize, Ord CSSize) => (CSSize -> Rational) -> Real CSSize
    CSSize -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: CSSize -> Rational
    toRational :: CSSize -> Rational
    Real, Enum CSSize
    Real CSSize
    (Real CSSize, Enum CSSize) =>
    (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> CSSize)
    -> (CSSize -> CSSize -> (CSSize, CSSize))
    -> (CSSize -> CSSize -> (CSSize, CSSize))
    -> (CSSize -> Integer)
    -> Integral CSSize
    CSSize -> Integer
    CSSize -> CSSize -> (CSSize, CSSize)
    CSSize -> CSSize -> CSSize
    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 :: CSSize -> CSSize -> CSSize
    quot :: CSSize -> CSSize -> CSSize
    $crem :: CSSize -> CSSize -> CSSize
    rem :: CSSize -> CSSize -> CSSize
    $cdiv :: CSSize -> CSSize -> CSSize
    div :: CSSize -> CSSize -> CSSize
    $cmod :: CSSize -> CSSize -> CSSize
    mod :: CSSize -> CSSize -> CSSize
    $cquotRem :: CSSize -> CSSize -> (CSSize, CSSize)
    quotRem :: CSSize -> CSSize -> (CSSize, CSSize)
    $cdivMod :: CSSize -> CSSize -> (CSSize, CSSize)
    divMod :: CSSize -> CSSize -> (CSSize, CSSize)
    $ctoInteger :: CSSize -> Integer
    toInteger :: CSSize -> Integer
    Integral)

    {-# LINE 91 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    h5_SIZEOF_SSIZE_T :: CSize
    h5_SIZEOF_SSIZE_T :: CSize
    h5_SIZEOF_SSIZE_T = CSize
    8
    {-# LINE 94 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    newtype HSize_t = HSize_t Word64 deriving (Ptr HSize_t -> IO HSize_t
    Ptr HSize_t -> Int -> IO HSize_t
    Ptr HSize_t -> Int -> HSize_t -> IO ()
    Ptr HSize_t -> HSize_t -> IO ()
    HSize_t -> Int
    (HSize_t -> Int)
    -> (HSize_t -> Int)
    -> (Ptr HSize_t -> Int -> IO HSize_t)
    -> (Ptr HSize_t -> Int -> HSize_t -> IO ())
    -> (forall b. Ptr b -> Int -> IO HSize_t)
    -> (forall b. Ptr b -> Int -> HSize_t -> IO ())
    -> (Ptr HSize_t -> IO HSize_t)
    -> (Ptr HSize_t -> HSize_t -> IO ())
    -> Storable HSize_t
    forall b. Ptr b -> Int -> IO HSize_t
    forall b. Ptr b -> Int -> HSize_t -> 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 :: HSize_t -> Int
    sizeOf :: HSize_t -> Int
    $calignment :: HSize_t -> Int
    alignment :: HSize_t -> Int
    $cpeekElemOff :: Ptr HSize_t -> Int -> IO HSize_t
    peekElemOff :: Ptr HSize_t -> Int -> IO HSize_t
    $cpokeElemOff :: Ptr HSize_t -> Int -> HSize_t -> IO ()
    pokeElemOff :: Ptr HSize_t -> Int -> HSize_t -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO HSize_t
    peekByteOff :: forall b. Ptr b -> Int -> IO HSize_t
    $cpokeByteOff :: forall b. Ptr b -> Int -> HSize_t -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> HSize_t -> IO ()
    $cpeek :: Ptr HSize_t -> IO HSize_t
    peek :: Ptr HSize_t -> IO HSize_t
    $cpoke :: Ptr HSize_t -> HSize_t -> IO ()
    poke :: Ptr HSize_t -> HSize_t -> IO ()
    Storable, Int -> HSize_t -> ShowS
    [HSize_t] -> ShowS
    HSize_t -> String
    (Int -> HSize_t -> ShowS)
    -> (HSize_t -> String) -> ([HSize_t] -> ShowS) -> Show HSize_t
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HSize_t -> ShowS
    showsPrec :: Int -> HSize_t -> ShowS
    $cshow :: HSize_t -> String
    show :: HSize_t -> String
    $cshowList :: [HSize_t] -> ShowS
    showList :: [HSize_t] -> ShowS
    Show, HSize_t -> HSize_t -> Bool
    (HSize_t -> HSize_t -> Bool)
    -> (HSize_t -> HSize_t -> Bool) -> Eq HSize_t
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HSize_t -> HSize_t -> Bool
    == :: HSize_t -> HSize_t -> Bool
    $c/= :: HSize_t -> HSize_t -> Bool
    /= :: HSize_t -> HSize_t -> Bool
    Eq, Eq HSize_t
    Eq HSize_t =>
    (HSize_t -> HSize_t -> Ordering)
    -> (HSize_t -> HSize_t -> Bool)
    -> (HSize_t -> HSize_t -> Bool)
    -> (HSize_t -> HSize_t -> Bool)
    -> (HSize_t -> HSize_t -> Bool)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> Ord HSize_t
    HSize_t -> HSize_t -> Bool
    HSize_t -> HSize_t -> Ordering
    HSize_t -> HSize_t -> HSize_t
    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 :: HSize_t -> HSize_t -> Ordering
    compare :: HSize_t -> HSize_t -> Ordering
    $c< :: HSize_t -> HSize_t -> Bool
    < :: HSize_t -> HSize_t -> Bool
    $c<= :: HSize_t -> HSize_t -> Bool
    <= :: HSize_t -> HSize_t -> Bool
    $c> :: HSize_t -> HSize_t -> Bool
    > :: HSize_t -> HSize_t -> Bool
    $c>= :: HSize_t -> HSize_t -> Bool
    >= :: HSize_t -> HSize_t -> Bool
    $cmax :: HSize_t -> HSize_t -> HSize_t
    max :: HSize_t -> HSize_t -> HSize_t
    $cmin :: HSize_t -> HSize_t -> HSize_t
    min :: HSize_t -> HSize_t -> HSize_t
    Ord, Integer -> HSize_t
    HSize_t -> HSize_t
    HSize_t -> HSize_t -> HSize_t
    (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t)
    -> (Integer -> HSize_t)
    -> Num HSize_t
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: HSize_t -> HSize_t -> HSize_t
    + :: HSize_t -> HSize_t -> HSize_t
    $c- :: HSize_t -> HSize_t -> HSize_t
    - :: HSize_t -> HSize_t -> HSize_t
    $c* :: HSize_t -> HSize_t -> HSize_t
    * :: HSize_t -> HSize_t -> HSize_t
    $cnegate :: HSize_t -> HSize_t
    negate :: HSize_t -> HSize_t
    $cabs :: HSize_t -> HSize_t
    abs :: HSize_t -> HSize_t
    $csignum :: HSize_t -> HSize_t
    signum :: HSize_t -> HSize_t
    $cfromInteger :: Integer -> HSize_t
    fromInteger :: Integer -> HSize_t
    Num, Eq HSize_t
    HSize_t
    Eq HSize_t =>
    (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> HSize_t
    -> (Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> Bool)
    -> (HSize_t -> Maybe Int)
    -> (HSize_t -> Int)
    -> (HSize_t -> Bool)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int -> HSize_t)
    -> (HSize_t -> Int)
    -> Bits HSize_t
    Int -> HSize_t
    HSize_t -> Bool
    HSize_t -> Int
    HSize_t -> Maybe Int
    HSize_t -> HSize_t
    HSize_t -> Int -> Bool
    HSize_t -> Int -> HSize_t
    HSize_t -> HSize_t -> HSize_t
    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.&. :: HSize_t -> HSize_t -> HSize_t
    .&. :: HSize_t -> HSize_t -> HSize_t
    $c.|. :: HSize_t -> HSize_t -> HSize_t
    .|. :: HSize_t -> HSize_t -> HSize_t
    $cxor :: HSize_t -> HSize_t -> HSize_t
    xor :: HSize_t -> HSize_t -> HSize_t
    $ccomplement :: HSize_t -> HSize_t
    complement :: HSize_t -> HSize_t
    $cshift :: HSize_t -> Int -> HSize_t
    shift :: HSize_t -> Int -> HSize_t
    $crotate :: HSize_t -> Int -> HSize_t
    rotate :: HSize_t -> Int -> HSize_t
    $czeroBits :: HSize_t
    zeroBits :: HSize_t
    $cbit :: Int -> HSize_t
    bit :: Int -> HSize_t
    $csetBit :: HSize_t -> Int -> HSize_t
    setBit :: HSize_t -> Int -> HSize_t
    $cclearBit :: HSize_t -> Int -> HSize_t
    clearBit :: HSize_t -> Int -> HSize_t
    $ccomplementBit :: HSize_t -> Int -> HSize_t
    complementBit :: HSize_t -> Int -> HSize_t
    $ctestBit :: HSize_t -> Int -> Bool
    testBit :: HSize_t -> Int -> Bool
    $cbitSizeMaybe :: HSize_t -> Maybe Int
    bitSizeMaybe :: HSize_t -> Maybe Int
    $cbitSize :: HSize_t -> Int
    bitSize :: HSize_t -> Int
    $cisSigned :: HSize_t -> Bool
    isSigned :: HSize_t -> Bool
    $cshiftL :: HSize_t -> Int -> HSize_t
    shiftL :: HSize_t -> Int -> HSize_t
    $cunsafeShiftL :: HSize_t -> Int -> HSize_t
    unsafeShiftL :: HSize_t -> Int -> HSize_t
    $cshiftR :: HSize_t -> Int -> HSize_t
    shiftR :: HSize_t -> Int -> HSize_t
    $cunsafeShiftR :: HSize_t -> Int -> HSize_t
    unsafeShiftR :: HSize_t -> Int -> HSize_t
    $crotateL :: HSize_t -> Int -> HSize_t
    rotateL :: HSize_t -> Int -> HSize_t
    $crotateR :: HSize_t -> Int -> HSize_t
    rotateR :: HSize_t -> Int -> HSize_t
    $cpopCount :: HSize_t -> Int
    popCount :: HSize_t -> Int
    Bits, Int -> HSize_t
    HSize_t -> Int
    HSize_t -> [HSize_t]
    HSize_t -> HSize_t
    HSize_t -> HSize_t -> [HSize_t]
    HSize_t -> HSize_t -> HSize_t -> [HSize_t]
    (HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t)
    -> (Int -> HSize_t)
    -> (HSize_t -> Int)
    -> (HSize_t -> [HSize_t])
    -> (HSize_t -> HSize_t -> [HSize_t])
    -> (HSize_t -> HSize_t -> [HSize_t])
    -> (HSize_t -> HSize_t -> HSize_t -> [HSize_t])
    -> Enum HSize_t
    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 :: HSize_t -> HSize_t
    succ :: HSize_t -> HSize_t
    $cpred :: HSize_t -> HSize_t
    pred :: HSize_t -> HSize_t
    $ctoEnum :: Int -> HSize_t
    toEnum :: Int -> HSize_t
    $cfromEnum :: HSize_t -> Int
    fromEnum :: HSize_t -> Int
    $cenumFrom :: HSize_t -> [HSize_t]
    enumFrom :: HSize_t -> [HSize_t]
    $cenumFromThen :: HSize_t -> HSize_t -> [HSize_t]
    enumFromThen :: HSize_t -> HSize_t -> [HSize_t]
    $cenumFromTo :: HSize_t -> HSize_t -> [HSize_t]
    enumFromTo :: HSize_t -> HSize_t -> [HSize_t]
    $cenumFromThenTo :: HSize_t -> HSize_t -> HSize_t -> [HSize_t]
    enumFromThenTo :: HSize_t -> HSize_t -> HSize_t -> [HSize_t]
    Enum, HSize_t
    HSize_t -> HSize_t -> Bounded HSize_t
    forall a. a -> a -> Bounded a
    $cminBound :: HSize_t
    minBound :: HSize_t
    $cmaxBound :: HSize_t
    maxBound :: HSize_t
    Bounded, Num HSize_t
    Ord HSize_t
    (Num HSize_t, Ord HSize_t) => (HSize_t -> Rational) -> Real HSize_t
    HSize_t -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: HSize_t -> Rational
    toRational :: HSize_t -> Rational
    Real, Enum HSize_t
    Real HSize_t
    (Real HSize_t, Enum HSize_t) =>
    (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> HSize_t)
    -> (HSize_t -> HSize_t -> (HSize_t, HSize_t))
    -> (HSize_t -> HSize_t -> (HSize_t, HSize_t))
    -> (HSize_t -> Integer)
    -> Integral HSize_t
    HSize_t -> Integer
    HSize_t -> HSize_t -> (HSize_t, HSize_t)
    HSize_t -> HSize_t -> HSize_t
    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 :: HSize_t -> HSize_t -> HSize_t
    quot :: HSize_t -> HSize_t -> HSize_t
    $crem :: HSize_t -> HSize_t -> HSize_t
    rem :: HSize_t -> HSize_t -> HSize_t
    $cdiv :: HSize_t -> HSize_t -> HSize_t
    div :: HSize_t -> HSize_t -> HSize_t
    $cmod :: HSize_t -> HSize_t -> HSize_t
    mod :: HSize_t -> HSize_t -> HSize_t
    $cquotRem :: HSize_t -> HSize_t -> (HSize_t, HSize_t)
    quotRem :: HSize_t -> HSize_t -> (HSize_t, HSize_t)
    $cdivMod :: HSize_t -> HSize_t -> (HSize_t, HSize_t)
    divMod :: HSize_t -> HSize_t -> (HSize_t, HSize_t)
    $ctoInteger :: HSize_t -> Integer
    toInteger :: HSize_t -> Integer
    Integral)

    {-# LINE 96 "src/Bindings/HDF5/Raw/H5.hsc" #-}
    newtype HSSize_t = HSSize_t Int64 deriving (Storable, Show, Eq, Ord, Num, Bits, Enum, Bounded, Real, Integral)

    {-# LINE 97 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    h5_SIZEOF_HSIZE_T, h5_SIZEOF_HSSIZE_T :: CSize
    h5_SIZEOF_HSIZE_T :: CSize
    h5_SIZEOF_HSIZE_T  = CSize
    8
    {-# LINE 100 "src/Bindings/HDF5/Raw/H5.hsc" #-}
    h5_SIZEOF_HSSIZE_T = 8
    {-# LINE 101 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    hSIZE_UNDEF :: HSize_t
    hSIZE_UNDEF :: HSize_t
    hSIZE_UNDEF = HSize_t
    18446744073709551615
    {-# LINE 104 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    newtype HAddr_t = HAddr_t Word64 deriving (Ptr HAddr_t -> IO HAddr_t
    Ptr HAddr_t -> Int -> IO HAddr_t
    Ptr HAddr_t -> Int -> HAddr_t -> IO ()
    Ptr HAddr_t -> HAddr_t -> IO ()
    HAddr_t -> Int
    (HAddr_t -> Int)
    -> (HAddr_t -> Int)
    -> (Ptr HAddr_t -> Int -> IO HAddr_t)
    -> (Ptr HAddr_t -> Int -> HAddr_t -> IO ())
    -> (forall b. Ptr b -> Int -> IO HAddr_t)
    -> (forall b. Ptr b -> Int -> HAddr_t -> IO ())
    -> (Ptr HAddr_t -> IO HAddr_t)
    -> (Ptr HAddr_t -> HAddr_t -> IO ())
    -> Storable HAddr_t
    forall b. Ptr b -> Int -> IO HAddr_t
    forall b. Ptr b -> Int -> HAddr_t -> 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 :: HAddr_t -> Int
    sizeOf :: HAddr_t -> Int
    $calignment :: HAddr_t -> Int
    alignment :: HAddr_t -> Int
    $cpeekElemOff :: Ptr HAddr_t -> Int -> IO HAddr_t
    peekElemOff :: Ptr HAddr_t -> Int -> IO HAddr_t
    $cpokeElemOff :: Ptr HAddr_t -> Int -> HAddr_t -> IO ()
    pokeElemOff :: Ptr HAddr_t -> Int -> HAddr_t -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO HAddr_t
    peekByteOff :: forall b. Ptr b -> Int -> IO HAddr_t
    $cpokeByteOff :: forall b. Ptr b -> Int -> HAddr_t -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> HAddr_t -> IO ()
    $cpeek :: Ptr HAddr_t -> IO HAddr_t
    peek :: Ptr HAddr_t -> IO HAddr_t
    $cpoke :: Ptr HAddr_t -> HAddr_t -> IO ()
    poke :: Ptr HAddr_t -> HAddr_t -> IO ()
    Storable, Int -> HAddr_t -> ShowS
    [HAddr_t] -> ShowS
    HAddr_t -> String
    (Int -> HAddr_t -> ShowS)
    -> (HAddr_t -> String) -> ([HAddr_t] -> ShowS) -> Show HAddr_t
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HAddr_t -> ShowS
    showsPrec :: Int -> HAddr_t -> ShowS
    $cshow :: HAddr_t -> String
    show :: HAddr_t -> String
    $cshowList :: [HAddr_t] -> ShowS
    showList :: [HAddr_t] -> ShowS
    Show, HAddr_t -> HAddr_t -> Bool
    (HAddr_t -> HAddr_t -> Bool)
    -> (HAddr_t -> HAddr_t -> Bool) -> Eq HAddr_t
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HAddr_t -> HAddr_t -> Bool
    == :: HAddr_t -> HAddr_t -> Bool
    $c/= :: HAddr_t -> HAddr_t -> Bool
    /= :: HAddr_t -> HAddr_t -> Bool
    Eq, Eq HAddr_t
    Eq HAddr_t =>
    (HAddr_t -> HAddr_t -> Ordering)
    -> (HAddr_t -> HAddr_t -> Bool)
    -> (HAddr_t -> HAddr_t -> Bool)
    -> (HAddr_t -> HAddr_t -> Bool)
    -> (HAddr_t -> HAddr_t -> Bool)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> Ord HAddr_t
    HAddr_t -> HAddr_t -> Bool
    HAddr_t -> HAddr_t -> Ordering
    HAddr_t -> HAddr_t -> HAddr_t
    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 :: HAddr_t -> HAddr_t -> Ordering
    compare :: HAddr_t -> HAddr_t -> Ordering
    $c< :: HAddr_t -> HAddr_t -> Bool
    < :: HAddr_t -> HAddr_t -> Bool
    $c<= :: HAddr_t -> HAddr_t -> Bool
    <= :: HAddr_t -> HAddr_t -> Bool
    $c> :: HAddr_t -> HAddr_t -> Bool
    > :: HAddr_t -> HAddr_t -> Bool
    $c>= :: HAddr_t -> HAddr_t -> Bool
    >= :: HAddr_t -> HAddr_t -> Bool
    $cmax :: HAddr_t -> HAddr_t -> HAddr_t
    max :: HAddr_t -> HAddr_t -> HAddr_t
    $cmin :: HAddr_t -> HAddr_t -> HAddr_t
    min :: HAddr_t -> HAddr_t -> HAddr_t
    Ord, Integer -> HAddr_t
    HAddr_t -> HAddr_t
    HAddr_t -> HAddr_t -> HAddr_t
    (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t)
    -> (Integer -> HAddr_t)
    -> Num HAddr_t
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: HAddr_t -> HAddr_t -> HAddr_t
    + :: HAddr_t -> HAddr_t -> HAddr_t
    $c- :: HAddr_t -> HAddr_t -> HAddr_t
    - :: HAddr_t -> HAddr_t -> HAddr_t
    $c* :: HAddr_t -> HAddr_t -> HAddr_t
    * :: HAddr_t -> HAddr_t -> HAddr_t
    $cnegate :: HAddr_t -> HAddr_t
    negate :: HAddr_t -> HAddr_t
    $cabs :: HAddr_t -> HAddr_t
    abs :: HAddr_t -> HAddr_t
    $csignum :: HAddr_t -> HAddr_t
    signum :: HAddr_t -> HAddr_t
    $cfromInteger :: Integer -> HAddr_t
    fromInteger :: Integer -> HAddr_t
    Num, Eq HAddr_t
    HAddr_t
    Eq HAddr_t =>
    (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> HAddr_t
    -> (Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> Bool)
    -> (HAddr_t -> Maybe Int)
    -> (HAddr_t -> Int)
    -> (HAddr_t -> Bool)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int -> HAddr_t)
    -> (HAddr_t -> Int)
    -> Bits HAddr_t
    Int -> HAddr_t
    HAddr_t -> Bool
    HAddr_t -> Int
    HAddr_t -> Maybe Int
    HAddr_t -> HAddr_t
    HAddr_t -> Int -> Bool
    HAddr_t -> Int -> HAddr_t
    HAddr_t -> HAddr_t -> HAddr_t
    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.&. :: HAddr_t -> HAddr_t -> HAddr_t
    .&. :: HAddr_t -> HAddr_t -> HAddr_t
    $c.|. :: HAddr_t -> HAddr_t -> HAddr_t
    .|. :: HAddr_t -> HAddr_t -> HAddr_t
    $cxor :: HAddr_t -> HAddr_t -> HAddr_t
    xor :: HAddr_t -> HAddr_t -> HAddr_t
    $ccomplement :: HAddr_t -> HAddr_t
    complement :: HAddr_t -> HAddr_t
    $cshift :: HAddr_t -> Int -> HAddr_t
    shift :: HAddr_t -> Int -> HAddr_t
    $crotate :: HAddr_t -> Int -> HAddr_t
    rotate :: HAddr_t -> Int -> HAddr_t
    $czeroBits :: HAddr_t
    zeroBits :: HAddr_t
    $cbit :: Int -> HAddr_t
    bit :: Int -> HAddr_t
    $csetBit :: HAddr_t -> Int -> HAddr_t
    setBit :: HAddr_t -> Int -> HAddr_t
    $cclearBit :: HAddr_t -> Int -> HAddr_t
    clearBit :: HAddr_t -> Int -> HAddr_t
    $ccomplementBit :: HAddr_t -> Int -> HAddr_t
    complementBit :: HAddr_t -> Int -> HAddr_t
    $ctestBit :: HAddr_t -> Int -> Bool
    testBit :: HAddr_t -> Int -> Bool
    $cbitSizeMaybe :: HAddr_t -> Maybe Int
    bitSizeMaybe :: HAddr_t -> Maybe Int
    $cbitSize :: HAddr_t -> Int
    bitSize :: HAddr_t -> Int
    $cisSigned :: HAddr_t -> Bool
    isSigned :: HAddr_t -> Bool
    $cshiftL :: HAddr_t -> Int -> HAddr_t
    shiftL :: HAddr_t -> Int -> HAddr_t
    $cunsafeShiftL :: HAddr_t -> Int -> HAddr_t
    unsafeShiftL :: HAddr_t -> Int -> HAddr_t
    $cshiftR :: HAddr_t -> Int -> HAddr_t
    shiftR :: HAddr_t -> Int -> HAddr_t
    $cunsafeShiftR :: HAddr_t -> Int -> HAddr_t
    unsafeShiftR :: HAddr_t -> Int -> HAddr_t
    $crotateL :: HAddr_t -> Int -> HAddr_t
    rotateL :: HAddr_t -> Int -> HAddr_t
    $crotateR :: HAddr_t -> Int -> HAddr_t
    rotateR :: HAddr_t -> Int -> HAddr_t
    $cpopCount :: HAddr_t -> Int
    popCount :: HAddr_t -> Int
    Bits, Int -> HAddr_t
    HAddr_t -> Int
    HAddr_t -> [HAddr_t]
    HAddr_t -> HAddr_t
    HAddr_t -> HAddr_t -> [HAddr_t]
    HAddr_t -> HAddr_t -> HAddr_t -> [HAddr_t]
    (HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t)
    -> (Int -> HAddr_t)
    -> (HAddr_t -> Int)
    -> (HAddr_t -> [HAddr_t])
    -> (HAddr_t -> HAddr_t -> [HAddr_t])
    -> (HAddr_t -> HAddr_t -> [HAddr_t])
    -> (HAddr_t -> HAddr_t -> HAddr_t -> [HAddr_t])
    -> Enum HAddr_t
    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 :: HAddr_t -> HAddr_t
    succ :: HAddr_t -> HAddr_t
    $cpred :: HAddr_t -> HAddr_t
    pred :: HAddr_t -> HAddr_t
    $ctoEnum :: Int -> HAddr_t
    toEnum :: Int -> HAddr_t
    $cfromEnum :: HAddr_t -> Int
    fromEnum :: HAddr_t -> Int
    $cenumFrom :: HAddr_t -> [HAddr_t]
    enumFrom :: HAddr_t -> [HAddr_t]
    $cenumFromThen :: HAddr_t -> HAddr_t -> [HAddr_t]
    enumFromThen :: HAddr_t -> HAddr_t -> [HAddr_t]
    $cenumFromTo :: HAddr_t -> HAddr_t -> [HAddr_t]
    enumFromTo :: HAddr_t -> HAddr_t -> [HAddr_t]
    $cenumFromThenTo :: HAddr_t -> HAddr_t -> HAddr_t -> [HAddr_t]
    enumFromThenTo :: HAddr_t -> HAddr_t -> HAddr_t -> [HAddr_t]
    Enum, HAddr_t
    HAddr_t -> HAddr_t -> Bounded HAddr_t
    forall a. a -> a -> Bounded a
    $cminBound :: HAddr_t
    minBound :: HAddr_t
    $cmaxBound :: HAddr_t
    maxBound :: HAddr_t
    Bounded, Num HAddr_t
    Ord HAddr_t
    (Num HAddr_t, Ord HAddr_t) => (HAddr_t -> Rational) -> Real HAddr_t
    HAddr_t -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: HAddr_t -> Rational
    toRational :: HAddr_t -> Rational
    Real, Enum HAddr_t
    Real HAddr_t
    (Real HAddr_t, Enum HAddr_t) =>
    (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> HAddr_t)
    -> (HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t))
    -> (HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t))
    -> (HAddr_t -> Integer)
    -> Integral HAddr_t
    HAddr_t -> Integer
    HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
    HAddr_t -> HAddr_t -> HAddr_t
    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 :: HAddr_t -> HAddr_t -> HAddr_t
    quot :: HAddr_t -> HAddr_t -> HAddr_t
    $crem :: HAddr_t -> HAddr_t -> HAddr_t
    rem :: HAddr_t -> HAddr_t -> HAddr_t
    $cdiv :: HAddr_t -> HAddr_t -> HAddr_t
    div :: HAddr_t -> HAddr_t -> HAddr_t
    $cmod :: HAddr_t -> HAddr_t -> HAddr_t
    mod :: HAddr_t -> HAddr_t -> HAddr_t
    $cquotRem :: HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
    quotRem :: HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
    $cdivMod :: HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
    divMod :: HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
    $ctoInteger :: HAddr_t -> Integer
    toInteger :: HAddr_t -> Integer
    Integral)

    {-# LINE 106 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    hADDR_UNDEF :: HAddr_t
    hADDR_UNDEF :: HAddr_t
    hADDR_UNDEF = Word64 -> HAddr_t
    HAddr_t (Word64
    18446744073709551615)
    {-# LINE 109 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    h5_SIZEOF_HADDR_T :: CSize
    h5_SIZEOF_HADDR_T :: CSize
    h5_SIZEOF_HADDR_T = CSize
    8
    {-# LINE 112 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    h5_PRINTF_HADDR_FMT :: String
    h5_PRINTF_HADDR_FMT :: String
    h5_PRINTF_HADDR_FMT = String
    "%lu"

    {-# LINE 114 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    hADDR_MAX :: HAddr_t
    hADDR_MAX = HAddr_t (18446744073709551614)
    {-# LINE 117 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Common iteration orders
    newtype H5_iter_order_t = H5_iter_order_t Int32 deriving (Ptr H5_iter_order_t -> IO H5_iter_order_t
    Ptr H5_iter_order_t -> Int -> IO H5_iter_order_t
    Ptr H5_iter_order_t -> Int -> H5_iter_order_t -> IO ()
    Ptr H5_iter_order_t -> H5_iter_order_t -> IO ()
    H5_iter_order_t -> Int
    (H5_iter_order_t -> Int)
    -> (H5_iter_order_t -> Int)
    -> (Ptr H5_iter_order_t -> Int -> IO H5_iter_order_t)
    -> (Ptr H5_iter_order_t -> Int -> H5_iter_order_t -> IO ())
    -> (forall b. Ptr b -> Int -> IO H5_iter_order_t)
    -> (forall b. Ptr b -> Int -> H5_iter_order_t -> IO ())
    -> (Ptr H5_iter_order_t -> IO H5_iter_order_t)
    -> (Ptr H5_iter_order_t -> H5_iter_order_t -> IO ())
    -> Storable H5_iter_order_t
    forall b. Ptr b -> Int -> IO H5_iter_order_t
    forall b. Ptr b -> Int -> H5_iter_order_t -> 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 :: H5_iter_order_t -> Int
    sizeOf :: H5_iter_order_t -> Int
    $calignment :: H5_iter_order_t -> Int
    alignment :: H5_iter_order_t -> Int
    $cpeekElemOff :: Ptr H5_iter_order_t -> Int -> IO H5_iter_order_t
    peekElemOff :: Ptr H5_iter_order_t -> Int -> IO H5_iter_order_t
    $cpokeElemOff :: Ptr H5_iter_order_t -> Int -> H5_iter_order_t -> IO ()
    pokeElemOff :: Ptr H5_iter_order_t -> Int -> H5_iter_order_t -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO H5_iter_order_t
    peekByteOff :: forall b. Ptr b -> Int -> IO H5_iter_order_t
    $cpokeByteOff :: forall b. Ptr b -> Int -> H5_iter_order_t -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> H5_iter_order_t -> IO ()
    $cpeek :: Ptr H5_iter_order_t -> IO H5_iter_order_t
    peek :: Ptr H5_iter_order_t -> IO H5_iter_order_t
    $cpoke :: Ptr H5_iter_order_t -> H5_iter_order_t -> IO ()
    poke :: Ptr H5_iter_order_t -> H5_iter_order_t -> IO ()
    Storable, Int -> H5_iter_order_t -> ShowS
    [H5_iter_order_t] -> ShowS
    H5_iter_order_t -> String
    (Int -> H5_iter_order_t -> ShowS)
    -> (H5_iter_order_t -> String)
    -> ([H5_iter_order_t] -> ShowS)
    -> Show H5_iter_order_t
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> H5_iter_order_t -> ShowS
    showsPrec :: Int -> H5_iter_order_t -> ShowS
    $cshow :: H5_iter_order_t -> String
    show :: H5_iter_order_t -> String
    $cshowList :: [H5_iter_order_t] -> ShowS
    showList :: [H5_iter_order_t] -> ShowS
    Show)

    {-# LINE 120 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Unknown order
    h5_ITER_UNKNOWN :: H5_iter_order_t
    h5_ITER_UNKNOWN :: H5_iter_order_t
    h5_ITER_UNKNOWN = Int32 -> H5_iter_order_t
    H5_iter_order_t (-Int32
    1)

    {-# LINE 123 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Increasing order
    h5_ITER_INC :: H5_iter_order_t
    h5_ITER_INC :: H5_iter_order_t
    h5_ITER_INC = Int32 -> H5_iter_order_t
    H5_iter_order_t (Int32
    0)

    {-# LINE 126 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Decreasing order
    h5_ITER_DEC :: H5_iter_order_t
    h5_ITER_DEC :: H5_iter_order_t
    h5_ITER_DEC = Int32 -> H5_iter_order_t
    H5_iter_order_t (Int32
    1)

    {-# LINE 129 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |No particular order, whatever is fastest
    h5_ITER_NATIVE :: H5_iter_order_t
    h5_ITER_NATIVE :: H5_iter_order_t
    h5_ITER_NATIVE = Int32 -> H5_iter_order_t
    H5_iter_order_t (Int32
    2)

    {-# LINE 132 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Number of iteration orders
    h5_ITER_N = 3
    h5_ITER_N :: (Num a) => a

    {-# LINE 135 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Iteration callback return value indicating that iteration should stop
    -- and report an error.
    h5_ITER_ERROR :: HErr_t
    h5_ITER_ERROR :: HErr_t
    h5_ITER_ERROR = Int32 -> HErr_t
    HErr_t (-Int32
    1)

    {-# LINE 139 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Iteration callback return value indicating that iteration should continue.
    h5_ITER_CONT :: HErr_t
    h5_ITER_CONT :: HErr_t
    h5_ITER_CONT = Int32 -> HErr_t
    HErr_t (Int32
    0)

    {-# LINE 142 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Iteration callback return value indicating that iteration should stop
    -- without error.
    --
    -- Actually, any postive value will cause the iterator to stop and pass back
    -- that positive value to the function that called the iterator
    h5_ITER_STOP :: HErr_t
    h5_ITER_STOP :: HErr_t
    h5_ITER_STOP = Int32 -> HErr_t
    HErr_t (Int32
    1)

    {-# LINE 149 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |The types of indices on links in groups/attributes on objects.
    -- Primarily used for \"\<do\> \<foo\> by index\" routines and for iterating over
    -- links in groups/attributes on objects.
    newtype H5_index_t = H5_index_t Int32 deriving (Ptr H5_index_t -> IO H5_index_t
    Ptr H5_index_t -> Int -> IO H5_index_t
    Ptr H5_index_t -> Int -> H5_index_t -> IO ()
    Ptr H5_index_t -> H5_index_t -> IO ()
    H5_index_t -> Int
    (H5_index_t -> Int)
    -> (H5_index_t -> Int)
    -> (Ptr H5_index_t -> Int -> IO H5_index_t)
    -> (Ptr H5_index_t -> Int -> H5_index_t -> IO ())
    -> (forall b. Ptr b -> Int -> IO H5_index_t)
    -> (forall b. Ptr b -> Int -> H5_index_t -> IO ())
    -> (Ptr H5_index_t -> IO H5_index_t)
    -> (Ptr H5_index_t -> H5_index_t -> IO ())
    -> Storable H5_index_t
    forall b. Ptr b -> Int -> IO H5_index_t
    forall b. Ptr b -> Int -> H5_index_t -> 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 :: H5_index_t -> Int
    sizeOf :: H5_index_t -> Int
    $calignment :: H5_index_t -> Int
    alignment :: H5_index_t -> Int
    $cpeekElemOff :: Ptr H5_index_t -> Int -> IO H5_index_t
    peekElemOff :: Ptr H5_index_t -> Int -> IO H5_index_t
    $cpokeElemOff :: Ptr H5_index_t -> Int -> H5_index_t -> IO ()
    pokeElemOff :: Ptr H5_index_t -> Int -> H5_index_t -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO H5_index_t
    peekByteOff :: forall b. Ptr b -> Int -> IO H5_index_t
    $cpokeByteOff :: forall b. Ptr b -> Int -> H5_index_t -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> H5_index_t -> IO ()
    $cpeek :: Ptr H5_index_t -> IO H5_index_t
    peek :: Ptr H5_index_t -> IO H5_index_t
    $cpoke :: Ptr H5_index_t -> H5_index_t -> IO ()
    poke :: Ptr H5_index_t -> H5_index_t -> IO ()
    Storable, Int -> H5_index_t -> ShowS
    [H5_index_t] -> ShowS
    H5_index_t -> String
    (Int -> H5_index_t -> ShowS)
    -> (H5_index_t -> String)
    -> ([H5_index_t] -> ShowS)
    -> Show H5_index_t
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> H5_index_t -> ShowS
    showsPrec :: Int -> H5_index_t -> ShowS
    $cshow :: H5_index_t -> String
    show :: H5_index_t -> String
    $cshowList :: [H5_index_t] -> ShowS
    showList :: [H5_index_t] -> ShowS
    Show)

    {-# LINE 154 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Unknown index type
    h5_INDEX_UNKNOWN :: H5_index_t
    h5_INDEX_UNKNOWN :: H5_index_t
    h5_INDEX_UNKNOWN = Int32 -> H5_index_t
    H5_index_t (-Int32
    1)

    {-# LINE 157 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Index on names
    h5_INDEX_NAME :: H5_index_t
    h5_INDEX_NAME :: H5_index_t
    h5_INDEX_NAME = Int32 -> H5_index_t
    H5_index_t (Int32
    0)

    {-# LINE 160 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Index on creation order
    h5_INDEX_CRT_ORDER :: H5_index_t
    h5_INDEX_CRT_ORDER :: H5_index_t
    h5_INDEX_CRT_ORDER = Int32 -> H5_index_t
    H5_index_t (Int32
    1)

    {-# LINE 163 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Number of indices defined
    h5_INDEX_N = 2
    h5_INDEX_N :: (Num a) => a

    {-# LINE 166 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Storage info struct used by 'H5O_info_t' and 'H5F_info_t'

    {-# LINE 169 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    {-# LINE 170 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    {-# LINE 171 "src/Bindings/HDF5/Raw/H5.hsc" #-}
    data H5_ih_info_t = H5_ih_info_t{
      h5_ih_info_t'index_size :: HSize_t,
      h5_ih_info_t'heap_size :: HSize_t
    } deriving (Eq,Show)
    p'H5_ih_info_t'index_size :: Ptr H5_ih_info_t -> Ptr HSize_t
    p'H5_ih_info_t'index_size Ptr H5_ih_info_t
    p = Ptr H5_ih_info_t -> Int -> Ptr HSize_t
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5_ih_info_t
    p Int
    0
    p'H5_ih_info_t'index_size :: Ptr (H5_ih_info_t) -> Ptr (HSize_t)
    p'H5_ih_info_t'heap_size :: Ptr H5_ih_info_t -> Ptr HSize_t
    p'H5_ih_info_t'heap_size Ptr H5_ih_info_t
    p = Ptr H5_ih_info_t -> Int -> Ptr HSize_t
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5_ih_info_t
    p Int
    8
    p'H5_ih_info_t'heap_size :: Ptr (H5_ih_info_t) -> Ptr (HSize_t)
    instance Storable H5_ih_info_t where
      sizeOf :: H5_ih_info_t -> Int
    sizeOf H5_ih_info_t
    _ = Int
    16
      alignment :: H5_ih_info_t -> Int
    alignment H5_ih_info_t
    _ = Int
    8
      peek _p = do
        v0 <- peekByteOff _p 0
        v1 <- peekByteOff _p 8
        return $ H5_ih_info_t v0 v1
      poke _p (H5_ih_info_t v0 v1) = do
        pokeByteOff _p 0 v0
        pokeByteOff _p 8 v1
        return ()

    {-# LINE 172 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- *Functions in H5.c

    -- |Initialize the library.  This is normally called automatically, but if you
    -- find that an HDF5 library function is failing inexplicably, then try
    -- calling this function first.
    --
    -- Return: Non-negative on success/Negative on failure
    --
    -- > herr_t H5open(void);
    foreign import ccall "H5open" h5_open
      :: IO HErr_t
    foreign import ccall "&H5open" p_H5open
      :: FunPtr (IO HErr_t)

    {-# LINE 183 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Terminate the library and release all resources.
    --
    -- Return: Non-negative on success/Negative on failure
    --
    -- > herr_t H5close(void);
    foreign import ccall "H5close" h5_close
      :: IO HErr_t
    foreign import ccall "&H5close" p_H5close
      :: FunPtr (IO HErr_t)

    {-# LINE 190 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Indicates that the library is not to clean up after itself
    -- when the application exits by calling exit() or returning
    -- from main().  This function must be called before any other
    -- HDF5 function or constant is used or it will have no effect.
    --
    -- If this function is used then certain memory buffers will not
    -- be de-allocated nor will open files be flushed automatically.
    -- The application may still call H5close() explicitly to
    -- accomplish these things.
    --
    -- Return:  non-negative on success,
    --          negative if this function is called more than
    --          once or if it is called too late.
    --
    -- > herr_t H5dont_atexit(void);
    foreign import ccall "H5dont_atexit" h5_dont_atexit
      :: IO HErr_t
    foreign import ccall "&H5dont_atexit" p_H5dont_atexit
      :: FunPtr (IO HErr_t)

    {-# LINE 207 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Walks through all the garbage collection routines for the
    -- library, which are supposed to free any unused memory they have
    -- allocated.
    --
    -- These should probably be registered dynamicly in a linked list of
    -- functions to call, but there aren't that many right now, so we
    -- hard-wire them...
    --
    -- Return: non-negative on success, negative on failure
    --
    -- > herr_t H5garbage_collect(void);
    foreign import ccall "H5garbage_collect" h5_garbage_collect
      :: IO HErr_t
    foreign import ccall "&H5garbage_collect" p_H5garbage_collect
      :: FunPtr (IO HErr_t)

    {-# LINE 220 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Sets limits on the different kinds of free lists.  Setting a value
    -- of -1 for a limit means no limit of that type.  These limits are global
    -- for the entire library.  Each \"global\" limit only applies to free lists
    -- of that type, so if an application sets a limit of 1 MB on each of the
    -- global lists, up to 3 MB of total storage might be allocated (1MB on
    -- each of regular, array and block type lists).
    --
    -- The settings for block free lists are duplicated to factory free lists.
    -- Factory free list limits cannot be set independently currently.
    --
    -- Parameters:
    --
    -- [@ reg_global_lim :: CInt @]  The limit on all \"regular\" free list memory used
    --
    -- [@ reg_list_lim   :: CInt @]  The limit on memory used in each \"regular\" free list
    --
    -- [@ arr_global_lim :: CInt @]  The limit on all \"array\" free list memory used
    --
    -- [@ arr_list_lim   :: CInt @]  The limit on memory used in each \"array\" free list
    --
    -- [@ blk_global_lim :: CInt @]  The limit on all \"block\" free list memory used
    --
    -- [@ blk_list_lim   :: CInt @]  The limit on memory used in each \"block\" free list
    --
    -- Return: non-negative on success, negative on failure
    --
    -- > herr_t H5set_free_list_limits (int reg_global_lim, int reg_list_lim,
    -- >         int arr_global_lim, int arr_list_lim, int blk_global_lim,
    -- >         int blk_list_lim);
    foreign import ccall "H5set_free_list_limits" h5_set_free_list_limits
      :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO HErr_t
    foreign import ccall "&H5set_free_list_limits" p_H5set_free_list_limits
      :: FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO HErr_t)

    {-# LINE 251 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Returns the library version numbers through arguments. MAJNUM
    -- will be the major revision number of the library, MINNUM the
    -- minor revision number, and RELNUM the release revision number.
    --
    -- Note: When printing an HDF5 version number it should be printed as
    --
    -- > printf("%u.%u.%u", maj, min, rel)		or
    -- > printf("version %u.%u release %u", maj, min, rel)
    --
    -- Return:	Non-negative on success/Negative on failure
    --
    -- > herr_t H5get_libversion(unsigned *majnum, unsigned *minnum,
    -- >         unsigned *relnum);
    foreign import ccall "H5get_libversion" h5_get_libversion
      :: Out CUInt -> Out CUInt -> Out CUInt -> IO HErr_t
    foreign import ccall "&H5get_libversion" p_H5get_libversion
      :: FunPtr (Out CUInt -> Out CUInt -> Out CUInt -> IO HErr_t)

    {-# LINE 266 "src/Bindings/HDF5/Raw/H5.hsc" #-}

    -- |Purpose:	Verifies that the arguments match the version numbers
    -- compiled into the library.  This function is intended to be
    -- called from user to verify that the versions of header files
    -- compiled into the application match the version of the hdf5
    -- library.
    --
    -- Return: Success: 0, Failure: calls abort()
    --
    -- > herr_t H5check_version(unsigned majnum, unsigned minnum,
    -- >         unsigned relnum);
    foreign import ccall "H5check_version" h5_check_version
      :: CUInt -> CUInt -> CUInt -> IO HErr_t
    foreign import ccall "&H5check_version" p_H5check_version
      :: FunPtr (CUInt -> CUInt -> CUInt -> IO HErr_t)

    {-# LINE 278 "src/Bindings/HDF5/Raw/H5.hsc" #-}