-- GENERATED by C->Haskell Compiler, version 0.28.6 Switcheroo, 25 November 2017 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "src/Codec/Lzip.chs" #-}
module Codec.Lzip ( -- * Prolegomena
                    LZErrno (..)
                  , lZVersion
                  , lZStrerror
                  , lZMinDictionaryBits
                  , lZMinDictionarySize
                  , lZMaxDictionaryBits
                  , lZMaxDictionarySize
                  , lZMinMatchLenLimit
                  , lZMaxMatchLenLimit
                  , UInt8
                  -- * Compression functions
                  , LZEncoder
                  , LZEncoderPtr
                  , lZCompressOpen
                  , lZCompressClose
                  , lZCompressFinish
                  , lZCompressRestartMember
                  , lZCompressSyncFlush
                  , lZCompressRead
                  , lZCompressWrite
                  , lZCompressWriteSize
                  , lZCompressErrno
                  , lZCompressFinished
                  , lZCompressMemberFinished
                  , lZCompressDataPosition
                  , lZCompressMemberPosition
                  , lZCompressTotalInSize
                  , lZCompressTotalOutSize
                  -- * Decompression functions
                  , LZDecoder
                  , LZDecoderPtr
                  , lZDecompressOpen
                  , lZDecompressClose
                  , lZDecompressFinish
                  , lZDecompressReset
                  , lZDecompressSyncToMember
                  , lZDecompressRead
                  , lZDecompressWrite
                  , lZDecompressWriteSize
                  , lZDecompressErrno
                  , lZDecompressFinished
                  , lZDecompressMemberFinished
                  , lZDecompressDictionarySize
                  , lZDecompressDataCrc
                  , lZDecompressDataPosition
                  , lZDecompressMemberPosition
                  , lZDecompressTotalInSize
                  , lZDecompressTotalOutSize
                  ) where
import qualified Foreign.C.Types as C2HSImp
import qualified Foreign.Ptr as C2HSImp



import Foreign.C.String
import Foreign.C.Types
import Foreign.Ptr (Ptr)




type UInt8 = (C2HSImp.CUChar)
{-# LINE 59 "src/Codec/Lzip.chs" #-}


data LZErrno = LzOk
             | LzBadArgument
             | LzMemError
             | LzSequenceError
             | LzHeaderError
             | LzUnexpectedEof
             | LzDataError
             | LzLibraryError
instance Enum LZErrno where
  succ LzOk = LzBadArgument
  succ LzBadArgument = LzMemError
  succ LzMemError = LzSequenceError
  succ LzSequenceError = LzHeaderError
  succ LzHeaderError = LzUnexpectedEof
  succ LzUnexpectedEof = LzDataError
  succ LzDataError = LzLibraryError
  succ LzLibraryError = error "LZErrno.succ: LzLibraryError has no successor"

  pred LzBadArgument = LzOk
  pred LzMemError = LzBadArgument
  pred LzSequenceError = LzMemError
  pred LzHeaderError = LzSequenceError
  pred LzUnexpectedEof = LzHeaderError
  pred LzDataError = LzUnexpectedEof
  pred LzLibraryError = LzDataError
  pred LzOk = error "LZErrno.pred: LzOk has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from LzLibraryError

  fromEnum LzOk = 0
  fromEnum LzBadArgument = 1
  fromEnum LzMemError = 2
  fromEnum LzSequenceError = 3
  fromEnum LzHeaderError = 4
  fromEnum LzUnexpectedEof = 5
  fromEnum LzDataError = 6
  fromEnum LzLibraryError = 7

  toEnum 0 = LzOk
  toEnum 1 = LzBadArgument
  toEnum 2 = LzMemError
  toEnum 3 = LzSequenceError
  toEnum 4 = LzHeaderError
  toEnum 5 = LzUnexpectedEof
  toEnum 6 = LzDataError
  toEnum 7 = LzLibraryError
  toEnum unmatched = error ("LZErrno.toEnum: Cannot match " ++ show unmatched)

{-# LINE 61 "src/Codec/Lzip.chs" #-}


lZVersion :: IO ((CString))
lZVersion =
  lZVersion'_ >>= \res ->
  return res >>= \res' ->
  return (res')

{-# LINE 63 "src/Codec/Lzip.chs" #-}

lZStrerror :: (LZErrno) -> IO ((CString))
lZStrerror a1 =
  let {a1' = (fromIntegral . fromEnum) a1} in
  lZStrerror'_ a1' >>= \res ->
  return res >>= \res' ->
  return (res')

{-# LINE 64 "src/Codec/Lzip.chs" #-}

lZMinDictionaryBits :: IO ((CInt))
lZMinDictionaryBits =
  lZMinDictionaryBits'_ >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 65 "src/Codec/Lzip.chs" #-}

lZMinDictionarySize :: IO ((CInt))
lZMinDictionarySize =
  lZMinDictionarySize'_ >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 66 "src/Codec/Lzip.chs" #-}

lZMaxDictionaryBits :: IO ((CInt))
lZMaxDictionaryBits =
  lZMaxDictionaryBits'_ >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 67 "src/Codec/Lzip.chs" #-}

lZMaxDictionarySize :: IO ((CInt))
lZMaxDictionarySize =
  lZMaxDictionarySize'_ >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 68 "src/Codec/Lzip.chs" #-}

lZMinMatchLenLimit :: IO ((CInt))
lZMinMatchLenLimit =
  lZMinMatchLenLimit'_ >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 69 "src/Codec/Lzip.chs" #-}

lZMaxMatchLenLimit :: IO ((CInt))
lZMaxMatchLenLimit =
  lZMaxMatchLenLimit'_ >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 70 "src/Codec/Lzip.chs" #-}


-- | Abstract data type
data LZEncoder

type LZEncoderPtr = C2HSImp.Ptr (LZEncoder)
{-# LINE 75 "src/Codec/Lzip.chs" #-}


lZCompressOpen :: (CInt) -> (CInt) -> (CULLong) -> IO ((LZEncoderPtr))
lZCompressOpen a1 a2 a3 =
  let {a1' = fromIntegral a1} in
  let {a2' = fromIntegral a2} in
  let {a3' = id a3} in
  lZCompressOpen'_ a1' a2' a3' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 77 "src/Codec/Lzip.chs" #-}

lZCompressClose :: (LZEncoderPtr) -> IO ((CInt))
lZCompressClose a1 =
  let {a1' = id a1} in
  lZCompressClose'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 78 "src/Codec/Lzip.chs" #-}

lZCompressFinish :: (LZEncoderPtr) -> IO ((CInt))
lZCompressFinish a1 =
  let {a1' = id a1} in
  lZCompressFinish'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 79 "src/Codec/Lzip.chs" #-}

lZCompressRestartMember :: (LZEncoderPtr) -> (CULLong) -> IO ((CInt))
lZCompressRestartMember a1 a2 =
  let {a1' = id a1} in
  let {a2' = id a2} in
  lZCompressRestartMember'_ a1' a2' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 80 "src/Codec/Lzip.chs" #-}

lZCompressSyncFlush :: (LZEncoderPtr) -> IO ((CInt))
lZCompressSyncFlush a1 =
  let {a1' = id a1} in
  lZCompressSyncFlush'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 81 "src/Codec/Lzip.chs" #-}

lZCompressRead :: (LZEncoderPtr) -> (Ptr UInt8) -> (CInt) -> IO ((CInt))
lZCompressRead a1 a2 a3 =
  let {a1' = id a1} in
  let {a2' = id a2} in
  let {a3' = fromIntegral a3} in
  lZCompressRead'_ a1' a2' a3' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 82 "src/Codec/Lzip.chs" #-}

lZCompressWrite :: (LZEncoderPtr) -> (Ptr UInt8) -> (CInt) -> IO ((CInt))
lZCompressWrite a1 a2 a3 =
  let {a1' = id a1} in
  let {a2' = id a2} in
  let {a3' = fromIntegral a3} in
  lZCompressWrite'_ a1' a2' a3' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 83 "src/Codec/Lzip.chs" #-}

lZCompressWriteSize :: (LZEncoderPtr) -> IO ((CInt))
lZCompressWriteSize a1 =
  let {a1' = id a1} in
  lZCompressWriteSize'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 84 "src/Codec/Lzip.chs" #-}

lZCompressErrno :: (LZEncoderPtr) -> IO ((LZErrno))
lZCompressErrno a1 =
  let {a1' = id a1} in
  lZCompressErrno'_ a1' >>= \res ->
  let {res' = (toEnum . fromIntegral) res} in
  return (res')

{-# LINE 85 "src/Codec/Lzip.chs" #-}

lZCompressFinished :: (LZEncoderPtr) -> IO ((CInt))
lZCompressFinished a1 =
  let {a1' = id a1} in
  lZCompressFinished'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 86 "src/Codec/Lzip.chs" #-}

lZCompressMemberFinished :: (LZEncoderPtr) -> IO ((CInt))
lZCompressMemberFinished a1 =
  let {a1' = id a1} in
  lZCompressMemberFinished'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 87 "src/Codec/Lzip.chs" #-}

lZCompressDataPosition :: (LZEncoderPtr) -> IO ((CULLong))
lZCompressDataPosition a1 =
  let {a1' = id a1} in
  lZCompressDataPosition'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 88 "src/Codec/Lzip.chs" #-}

lZCompressMemberPosition :: (LZEncoderPtr) -> IO ((CULLong))
lZCompressMemberPosition a1 =
  let {a1' = id a1} in
  lZCompressMemberPosition'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 89 "src/Codec/Lzip.chs" #-}

lZCompressTotalInSize :: (LZEncoderPtr) -> IO ((CULLong))
lZCompressTotalInSize a1 =
  let {a1' = id a1} in
  lZCompressTotalInSize'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 90 "src/Codec/Lzip.chs" #-}

lZCompressTotalOutSize :: (LZEncoderPtr) -> IO ((CULLong))
lZCompressTotalOutSize a1 =
  let {a1' = id a1} in
  lZCompressTotalOutSize'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 91 "src/Codec/Lzip.chs" #-}


-- | Abstract data type
data LZDecoder

type LZDecoderPtr = C2HSImp.Ptr (LZDecoder)
{-# LINE 96 "src/Codec/Lzip.chs" #-}


lZDecompressOpen :: IO ((LZDecoderPtr))
lZDecompressOpen =
  lZDecompressOpen'_ >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 98 "src/Codec/Lzip.chs" #-}

lZDecompressClose :: (LZDecoderPtr) -> IO ((CInt))
lZDecompressClose a1 =
  let {a1' = id a1} in
  lZDecompressClose'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 99 "src/Codec/Lzip.chs" #-}

lZDecompressFinish :: (LZDecoderPtr) -> IO ((CInt))
lZDecompressFinish a1 =
  let {a1' = id a1} in
  lZDecompressFinish'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 100 "src/Codec/Lzip.chs" #-}

lZDecompressReset :: (LZDecoderPtr) -> IO ((CInt))
lZDecompressReset a1 =
  let {a1' = id a1} in
  lZDecompressReset'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 101 "src/Codec/Lzip.chs" #-}

lZDecompressSyncToMember :: (LZDecoderPtr) -> IO ((CInt))
lZDecompressSyncToMember a1 =
  let {a1' = id a1} in
  lZDecompressSyncToMember'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 102 "src/Codec/Lzip.chs" #-}

lZDecompressRead :: (LZDecoderPtr) -> (Ptr UInt8) -> (CInt) -> IO ((CInt))
lZDecompressRead a1 a2 a3 =
  let {a1' = id a1} in
  let {a2' = id a2} in
  let {a3' = fromIntegral a3} in
  lZDecompressRead'_ a1' a2' a3' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 103 "src/Codec/Lzip.chs" #-}

lZDecompressWrite :: (LZDecoderPtr) -> (Ptr UInt8) -> (CInt) -> IO ((CInt))
lZDecompressWrite a1 a2 a3 =
  let {a1' = id a1} in
  let {a2' = id a2} in
  let {a3' = fromIntegral a3} in
  lZDecompressWrite'_ a1' a2' a3' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 104 "src/Codec/Lzip.chs" #-}

lZDecompressWriteSize :: (LZDecoderPtr) -> IO ((CInt))
lZDecompressWriteSize a1 =
  let {a1' = id a1} in
  lZDecompressWriteSize'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 105 "src/Codec/Lzip.chs" #-}

lZDecompressErrno :: (LZDecoderPtr) -> IO ((LZErrno))
lZDecompressErrno a1 =
  let {a1' = id a1} in
  lZDecompressErrno'_ a1' >>= \res ->
  let {res' = (toEnum . fromIntegral) res} in
  return (res')

{-# LINE 106 "src/Codec/Lzip.chs" #-}

lZDecompressFinished :: (LZDecoderPtr) -> IO ((CInt))
lZDecompressFinished a1 =
  let {a1' = id a1} in
  lZDecompressFinished'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 107 "src/Codec/Lzip.chs" #-}

lZDecompressMemberFinished :: (LZDecoderPtr) -> IO ((CInt))
lZDecompressMemberFinished a1 =
  let {a1' = id a1} in
  lZDecompressMemberFinished'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 108 "src/Codec/Lzip.chs" #-}

lZDecompressDictionarySize :: (LZDecoderPtr) -> IO ((CInt))
lZDecompressDictionarySize a1 =
  let {a1' = id a1} in
  lZDecompressDictionarySize'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 109 "src/Codec/Lzip.chs" #-}

lZDecompressDataCrc :: (LZDecoderPtr) -> IO ((CUInt))
lZDecompressDataCrc a1 =
  let {a1' = id a1} in
  lZDecompressDataCrc'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 110 "src/Codec/Lzip.chs" #-}

lZDecompressDataPosition :: (LZDecoderPtr) -> IO ((CULLong))
lZDecompressDataPosition a1 =
  let {a1' = id a1} in
  lZDecompressDataPosition'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 111 "src/Codec/Lzip.chs" #-}

lZDecompressMemberPosition :: (LZDecoderPtr) -> IO ((CULLong))
lZDecompressMemberPosition a1 =
  let {a1' = id a1} in
  lZDecompressMemberPosition'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 112 "src/Codec/Lzip.chs" #-}

lZDecompressTotalInSize :: (LZDecoderPtr) -> IO ((CULLong))
lZDecompressTotalInSize a1 =
  let {a1' = id a1} in
  lZDecompressTotalInSize'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 113 "src/Codec/Lzip.chs" #-}

lZDecompressTotalOutSize :: (LZDecoderPtr) -> IO ((CULLong))
lZDecompressTotalOutSize a1 =
  let {a1' = id a1} in
  lZDecompressTotalOutSize'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 114 "src/Codec/Lzip.chs" #-}


foreign import ccall safe "Codec/Lzip.chs.h LZ_version"
  lZVersion'_ :: (IO (C2HSImp.Ptr C2HSImp.CChar))

foreign import ccall safe "Codec/Lzip.chs.h LZ_strerror"
  lZStrerror'_ :: (C2HSImp.CInt -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "Codec/Lzip.chs.h LZ_min_dictionary_bits"
  lZMinDictionaryBits'_ :: (IO C2HSImp.CInt)

foreign import ccall safe "Codec/Lzip.chs.h LZ_min_dictionary_size"
  lZMinDictionarySize'_ :: (IO C2HSImp.CInt)

foreign import ccall safe "Codec/Lzip.chs.h LZ_max_dictionary_bits"
  lZMaxDictionaryBits'_ :: (IO C2HSImp.CInt)

foreign import ccall safe "Codec/Lzip.chs.h LZ_max_dictionary_size"
  lZMaxDictionarySize'_ :: (IO C2HSImp.CInt)

foreign import ccall safe "Codec/Lzip.chs.h LZ_min_match_len_limit"
  lZMinMatchLenLimit'_ :: (IO C2HSImp.CInt)

foreign import ccall safe "Codec/Lzip.chs.h LZ_max_match_len_limit"
  lZMaxMatchLenLimit'_ :: (IO C2HSImp.CInt)

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_open"
  lZCompressOpen'_ :: (C2HSImp.CInt -> (C2HSImp.CInt -> (C2HSImp.CULLong -> (IO (LZEncoderPtr)))))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_close"
  lZCompressClose'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_finish"
  lZCompressFinish'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_restart_member"
  lZCompressRestartMember'_ :: ((LZEncoderPtr) -> (C2HSImp.CULLong -> (IO C2HSImp.CInt)))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_sync_flush"
  lZCompressSyncFlush'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_read"
  lZCompressRead'_ :: ((LZEncoderPtr) -> ((C2HSImp.Ptr C2HSImp.CUChar) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_write"
  lZCompressWrite'_ :: ((LZEncoderPtr) -> ((C2HSImp.Ptr C2HSImp.CUChar) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_write_size"
  lZCompressWriteSize'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_errno"
  lZCompressErrno'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_finished"
  lZCompressFinished'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_member_finished"
  lZCompressMemberFinished'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_data_position"
  lZCompressDataPosition'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CULLong))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_member_position"
  lZCompressMemberPosition'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CULLong))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_total_in_size"
  lZCompressTotalInSize'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CULLong))

foreign import ccall safe "Codec/Lzip.chs.h LZ_compress_total_out_size"
  lZCompressTotalOutSize'_ :: ((LZEncoderPtr) -> (IO C2HSImp.CULLong))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_open"
  lZDecompressOpen'_ :: (IO (LZDecoderPtr))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_close"
  lZDecompressClose'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_finish"
  lZDecompressFinish'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_reset"
  lZDecompressReset'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_sync_to_member"
  lZDecompressSyncToMember'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_read"
  lZDecompressRead'_ :: ((LZDecoderPtr) -> ((C2HSImp.Ptr C2HSImp.CUChar) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_write"
  lZDecompressWrite'_ :: ((LZDecoderPtr) -> ((C2HSImp.Ptr C2HSImp.CUChar) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_write_size"
  lZDecompressWriteSize'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_errno"
  lZDecompressErrno'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_finished"
  lZDecompressFinished'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_member_finished"
  lZDecompressMemberFinished'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_dictionary_size"
  lZDecompressDictionarySize'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_data_crc"
  lZDecompressDataCrc'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CUInt))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_data_position"
  lZDecompressDataPosition'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CULLong))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_member_position"
  lZDecompressMemberPosition'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CULLong))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_total_in_size"
  lZDecompressTotalInSize'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CULLong))

foreign import ccall safe "Codec/Lzip.chs.h LZ_decompress_total_out_size"
  lZDecompressTotalOutSize'_ :: ((LZDecoderPtr) -> (IO C2HSImp.CULLong))