interface FFI where {

{-# NEED #-}
instance Prelude.Floating CLDouble;

{-# NEED #-}
instance Prelude.Floating CDouble;

{-# NEED #-}
instance Prelude.Floating CFloat;

{-# NEED #-}
instance Prelude.RealFloat CLDouble;

{-# NEED #-}
instance Prelude.RealFloat CDouble;

{-# NEED #-}
instance Prelude.RealFloat CFloat;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Fractional (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Fractional CLDouble;

{-# NEED #-}
instance Prelude.Fractional CDouble;

{-# NEED #-}
instance Prelude.Fractional CFloat;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.RealFrac (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.RealFrac CLDouble;

{-# NEED #-}
instance Prelude.RealFrac CDouble;

{-# NEED #-}
instance Prelude.RealFrac CFloat;

{-# NEED #-}
instance Storable Prelude.Float;

{-# NEED #-}
instance Storable Prelude.Double;

{-# NEED #-}
instance Storable (Ptr a);

{-# NEED #-}
instance Storable CLDouble;

{-# NEED #-}
instance Storable CDouble;

{-# NEED #-}
instance Storable CFloat;

{-# NEED #-}
instance Storable CChar;

{-# NEED #-}
instance Storable CULLong;

{-# NEED #-}
instance Storable CLLong;

{-# NEED #-}
instance Storable CULong;

{-# NEED #-}
instance Storable CLong;

{-# NEED #-}
instance Storable CUShort;

{-# NEED #-}
instance Storable CShort;

{-# NEED #-}
instance Storable CUChar;

{-# NEED #-}
instance Storable CSChar;

{-# NEED #-}
instance Storable FFIBuiltin.Word8;

{-# NEED #-}
instance Storable FFIBuiltin.Word16;

{-# NEED #-}
instance Storable FFIBuiltin.Word64;

{-# NEED #-}
instance Storable Prelude.Int;

{-# NEED #-}
instance Storable Prelude.Char;

{-# NEED #-}
instance Storable CInt;

{-# NEED #-}
instance Storable FFIBuiltin.Word32;

{-# NEED #-}
instance Storable CUInt;

{-# NEED #-}
instance Storable FFIBuiltin.Int64;

{-# NEED #-}
instance Storable FFIBuiltin.Int32;

{-# NEED #-}
instance Storable FFIBuiltin.Int16;

{-# NEED #-}
instance Storable FFIBuiltin.Int8;

{-# NEED #-}
instance Ix.Ix Prelude.Bool;

{-# NEED #-}
instance Ix.Ix FFIBuiltin.Word8;

{-# NEED #-}
instance Ix.Ix FFIBuiltin.Word16;

{-# NEED #-}
instance Ix.Ix FFIBuiltin.Word64;

{-# NEED #-}
instance Ix.Ix Prelude.Int;

{-# NEED #-}
instance Ix.Ix Prelude.Char;

{-# NEED #-}
instance Ix.Ix Prelude.Ordering;

{-# NEED #-}
instance Ix.Ix Prelude.Integer;

{-# NEED #-}
instance Ix.Ix FFIBuiltin.Word32;

{-# NEED #-}
instance Ix.Ix FFIBuiltin.Int64;

{-# NEED #-}
instance Ix.Ix FFIBuiltin.Int32;

{-# NEED #-}
instance Ix.Ix FFIBuiltin.Int16;

{-# NEED #-}
instance Ix.Ix FFIBuiltin.Int8;

{-# NEED #-}
instance Prelude.Bounded CULLong;

{-# NEED #-}
instance Prelude.Bounded CLLong;

{-# NEED #-}
instance Prelude.Bounded CULong;

{-# NEED #-}
instance Prelude.Bounded CLong;

{-# NEED #-}
instance Prelude.Bounded CUShort;

{-# NEED #-}
instance Prelude.Bounded CShort;

{-# NEED #-}
instance Prelude.Bounded CUChar;

{-# NEED #-}
instance Prelude.Bounded CSChar;

{-# NEED #-}
instance Prelude.Bounded FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Bounded FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Bounded FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Bounded CInt;

{-# NEED #-}
instance Prelude.Bounded FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Bounded CUInt;

{-# NEED #-}
instance Prelude.Bounded FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Bounded FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Bounded FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Bounded FFIBuiltin.Int8;

{-# NEED #-}
instance Prelude.Enum (FunPtr a);

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Addr;

{-# NEED #-}
instance Prelude.Enum (Ptr a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Enum (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Enum DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Enum CLDouble;

{-# NEED #-}
instance Prelude.Enum CDouble;

{-# NEED #-}
instance Prelude.Enum CFloat;

{-# NEED #-}
instance Prelude.Enum CChar;

{-# NEED #-}
instance Prelude.Enum CULLong;

{-# NEED #-}
instance Prelude.Enum CLLong;

{-# NEED #-}
instance Prelude.Enum CULong;

{-# NEED #-}
instance Prelude.Enum CLong;

{-# NEED #-}
instance Prelude.Enum CUShort;

{-# NEED #-}
instance Prelude.Enum CShort;

{-# NEED #-}
instance Prelude.Enum CUChar;

{-# NEED #-}
instance Prelude.Enum CSChar;

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Enum CInt;

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Enum CUInt;

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Int8;

{-# NEED #-}
instance Prelude.Read PackedString.PackedString;

{-# NEED #-}
instance (Prelude.Read a,Prelude.Integral a) => Prelude.Read (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Read CLDouble;

{-# NEED #-}
instance Prelude.Read CDouble;

{-# NEED #-}
instance Prelude.Read CFloat;

{-# NEED #-}
instance Prelude.Read CChar;

{-# NEED #-}
instance Prelude.Read CULLong;

{-# NEED #-}
instance Prelude.Read CLLong;

{-# NEED #-}
instance Prelude.Read CULong;

{-# NEED #-}
instance Prelude.Read CLong;

{-# NEED #-}
instance Prelude.Read CUShort;

{-# NEED #-}
instance Prelude.Read CShort;

{-# NEED #-}
instance Prelude.Read CUChar;

{-# NEED #-}
instance Prelude.Read CSChar;

{-# NEED #-}
instance Prelude.Read FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Read FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Read FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Read CInt;

{-# NEED #-}
instance Prelude.Read FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Read CUInt;

{-# NEED #-}
instance Prelude.Read FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Read FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Read FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Read FFIBuiltin.Int8;

{-# NEED #-}
instance Prelude.Eq (FunPtr a);

{-# NEED #-}
instance Prelude.Eq PackedString.PackedString;

{-# NEED #-}
instance Prelude.Eq IO.Handle;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Addr;

{-# NEED #-}
instance Prelude.Eq (Ptr a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Eq (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Eq DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Eq CLDouble;

{-# NEED #-}
instance Prelude.Eq CDouble;

{-# NEED #-}
instance Prelude.Eq CFloat;

{-# NEED #-}
instance Prelude.Eq CChar;

{-# NEED #-}
instance Prelude.Eq CULLong;

{-# NEED #-}
instance Prelude.Eq CLLong;

{-# NEED #-}
instance Prelude.Eq CULong;

{-# NEED #-}
instance Prelude.Eq CLong;

{-# NEED #-}
instance Prelude.Eq CUShort;

{-# NEED #-}
instance Prelude.Eq CShort;

{-# NEED #-}
instance Prelude.Eq CUChar;

{-# NEED #-}
instance Prelude.Eq CSChar;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Eq CInt;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Eq CUInt;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Int8;

{-# NEED #-}
instance Prelude.Show (FunPtr a);

{-# NEED #-}
instance Prelude.Show PackedString.PackedString;

{-# NEED #-}
instance Prelude.Show IO.Handle;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Addr;

{-# NEED #-}
instance Prelude.Show (Ptr a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Show (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Show DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Show CLDouble;

{-# NEED #-}
instance Prelude.Show CDouble;

{-# NEED #-}
instance Prelude.Show CFloat;

{-# NEED #-}
instance Prelude.Show CChar;

{-# NEED #-}
instance Prelude.Show CULLong;

{-# NEED #-}
instance Prelude.Show CLLong;

{-# NEED #-}
instance Prelude.Show CULong;

{-# NEED #-}
instance Prelude.Show CLong;

{-# NEED #-}
instance Prelude.Show CUShort;

{-# NEED #-}
instance Prelude.Show CShort;

{-# NEED #-}
instance Prelude.Show CUChar;

{-# NEED #-}
instance Prelude.Show CSChar;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Show CInt;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Show CUInt;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Int8;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Real (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Real CLDouble;

{-# NEED #-}
instance Prelude.Real CDouble;

{-# NEED #-}
instance Prelude.Real CFloat;

{-# NEED #-}
instance Prelude.Real CULLong;

{-# NEED #-}
instance Prelude.Real CLLong;

{-# NEED #-}
instance Prelude.Real CULong;

{-# NEED #-}
instance Prelude.Real CLong;

{-# NEED #-}
instance Prelude.Real CUShort;

{-# NEED #-}
instance Prelude.Real CShort;

{-# NEED #-}
instance Prelude.Real CUChar;

{-# NEED #-}
instance Prelude.Real CSChar;

{-# NEED #-}
instance Prelude.Real FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Real FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Real FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Real CInt;

{-# NEED #-}
instance Prelude.Real FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Real CUInt;

{-# NEED #-}
instance Prelude.Real FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Real FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Real FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Real FFIBuiltin.Int8;

{-# NEED #-}
instance Prelude.Ord (FunPtr a);

{-# NEED #-}
instance Prelude.Ord PackedString.PackedString;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Addr;

{-# NEED #-}
instance Prelude.Ord (Ptr a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Ord (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Ord CLDouble;

{-# NEED #-}
instance Prelude.Ord CDouble;

{-# NEED #-}
instance Prelude.Ord CFloat;

{-# NEED #-}
instance Prelude.Ord CChar;

{-# NEED #-}
instance Prelude.Ord CULLong;

{-# NEED #-}
instance Prelude.Ord CLLong;

{-# NEED #-}
instance Prelude.Ord CULong;

{-# NEED #-}
instance Prelude.Ord CLong;

{-# NEED #-}
instance Prelude.Ord CUShort;

{-# NEED #-}
instance Prelude.Ord CShort;

{-# NEED #-}
instance Prelude.Ord CUChar;

{-# NEED #-}
instance Prelude.Ord CSChar;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Ord CInt;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Ord CUInt;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Int8;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Num (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Num CLDouble;

{-# NEED #-}
instance Prelude.Num CDouble;

{-# NEED #-}
instance Prelude.Num CFloat;

{-# NEED #-}
instance Prelude.Num CULLong;

{-# NEED #-}
instance Prelude.Num CLLong;

{-# NEED #-}
instance Prelude.Num CULong;

{-# NEED #-}
instance Prelude.Num CLong;

{-# NEED #-}
instance Prelude.Num CUShort;

{-# NEED #-}
instance Prelude.Num CShort;

{-# NEED #-}
instance Prelude.Num CUChar;

{-# NEED #-}
instance Prelude.Num CSChar;

{-# NEED #-}
instance Prelude.Num FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Num FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Num FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Num CInt;

{-# NEED #-}
instance Prelude.Num FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Num CUInt;

{-# NEED #-}
instance Prelude.Num FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Num FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Num FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Num FFIBuiltin.Int8;

{-# NEED #-}
instance Prelude.Integral CULLong;

{-# NEED #-}
instance Prelude.Integral CLLong;

{-# NEED #-}
instance Prelude.Integral CULong;

{-# NEED #-}
instance Prelude.Integral CLong;

{-# NEED #-}
instance Prelude.Integral CUShort;

{-# NEED #-}
instance Prelude.Integral CShort;

{-# NEED #-}
instance Prelude.Integral CUChar;

{-# NEED #-}
instance Prelude.Integral CSChar;

{-# NEED #-}
instance Prelude.Integral FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.Integral FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.Integral FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.Integral CInt;

{-# NEED #-}
instance Prelude.Integral FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.Integral CUInt;

{-# NEED #-}
instance Prelude.Integral FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.Integral FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.Integral FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.Integral FFIBuiltin.Int8;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! FFI
{-# NEED mallocArray #-}
mallocArray{-# 0 #-}::(Storable a) => (Prelude.Int -> (Prelude.IO (Ptr a)));

{-# NEED mallocArray0 #-}
mallocArray0{-# 1 #-}::(Storable a) => (Prelude.Int -> (Prelude.IO (Ptr a)));

{-# NEED allocaArray #-}
allocaArray{-# 0 #-}::(Storable a) => (Prelude.Int -> (((Ptr a) -> (Prelude.IO b)) -> (Prelude.IO b)));

{-# NEED allocaArray0 #-}
allocaArray0{-# 1 #-}::(Storable a) => (Prelude.Int -> (((Ptr a) -> (Prelude.IO b)) -> (Prelude.IO b)));

{-# NEED reallocArray #-}
reallocArray{-# 0 #-}::(Storable a) => ((Ptr a) -> (Prelude.Int -> (Prelude.IO (Ptr a))));

{-# NEED reallocArray0 #-}
reallocArray0{-# 2 #-}::(Storable a) => ((Ptr a) -> (Prelude.Int -> (Prelude.IO (Ptr a))));

{-# NEED peekArray #-}
peekArray{-# 2 #-}::(Storable a) => (Prelude.Int -> ((Ptr a) -> (Prelude.IO [a])));

{-# NEED peekArray0 #-}
peekArray0{-# 2 #-}::(Storable a,Prelude.Eq a) => (a -> ((Ptr a) -> (Prelude.IO [a])));

{-# NEED pokeArray #-}
pokeArray{-# 2 #-}::(Storable a) => ((Ptr a) -> ([a] -> (Prelude.IO ())));

{-# NEED pokeArray0 #-}
pokeArray0{-# 3 #-}::(Storable a) => (a -> ((Ptr a) -> ([a] -> (Prelude.IO ()))));

{-# NEED newArray #-}
newArray{-# 1 #-}::(Storable a) => ([a] -> (Prelude.IO (Ptr a)));

{-# NEED newArray0 #-}
newArray0{-# 2 #-}::(Storable a) => (a -> ([a] -> (Prelude.IO (Ptr a))));

{-# NEED withArray #-}
withArray{-# 2 #-}::(Storable a) => ([a] -> (((Ptr a) -> (Prelude.IO b)) -> (Prelude.IO b)));

{-# NEED withArray0 #-}
withArray0{-# 3 #-}::(Storable a) => (a -> ([a] -> (((Ptr a) -> (Prelude.IO b)) -> (Prelude.IO b))));

{-# NEED destructArray #-}
destructArray{-# 2 #-}::(Storable a) => (Prelude.Int -> ((Ptr a) -> (Prelude.IO ())));

{-# NEED destructArray0 #-}
destructArray0{-# 2 #-}::(Storable a,Prelude.Eq a) => (a -> ((Ptr a) -> (Prelude.IO ())));

{-# NEED copyArray #-}
copyArray{-# 0 #-}::(Storable a) => ((Ptr a) -> ((Ptr a) -> (Prelude.Int -> (Prelude.IO ()))));

{-# NEED moveArray #-}
moveArray{-# 0 #-}::(Storable a) => ((Ptr a) -> ((Ptr a) -> (Prelude.Int -> (Prelude.IO ()))));

{-# NEED lengthArray0 #-}
lengthArray0{-# 2 #-}::(Storable a,Prelude.Eq a) => (a -> ((Ptr a) -> (Prelude.IO Prelude.Int)));

{-# NEED advancePtr #-}
advancePtr{-# 0 #-}::(Storable a) => ((Ptr a) -> (Prelude.Int -> (Ptr a)));

{-# NEED new #-}
new{-# 1 #-}::(Storable a) => (a -> (Prelude.IO (Ptr a)));

{-# NEED with #-}
with{-# 2 #-}::(Storable a) => (a -> (((Ptr a) -> (Prelude.IO b)) -> (Prelude.IO b)));

{-# NEED fromBool #-}
fromBool{-# 1 #-}::(Prelude.Num a) => (Prelude.Bool -> a);

{-# NEED toBool #-}
toBool{-# 0 #-}::(Prelude.Num a) => (a -> Prelude.Bool);

{-# NEED maybeNew #-}
maybeNew{-# 0 #-}::((a -> (Prelude.IO (Ptr a))) -> ((Prelude.Maybe a) -> (Prelude.IO (Ptr a))));

{-# NEED maybeWith #-}
maybeWith{-# 0 #-}::((a -> (((Ptr b) -> (Prelude.IO c)) -> (Prelude.IO c))) -> ((Prelude.Maybe a) -> (((Ptr b) -> (Prelude.IO c)) -> (Prelude.IO c))));

{-# NEED maybePeek #-}
maybePeek{-# 2 #-}::(((Ptr a) -> (Prelude.IO b)) -> ((Ptr a) -> (Prelude.IO (Prelude.Maybe b))));

{-# NEED withMany #-}
withMany{-# 3 #-}::((a -> ((b -> c) -> c)) -> ([a] -> (([b] -> c) -> c)));

{-# NEED copyBytes #-}
copyBytes{-# 3 #-}::((Ptr a) -> ((Ptr a) -> (Prelude.Int -> (Prelude.IO ()))));

{-# NEED moveBytes #-}
moveBytes{-# 3 #-}::((Ptr a) -> ((Ptr a) -> (Prelude.Int -> (Prelude.IO ()))));

{-# NEED peekCString #-}
peekCString{-# 1 #-}::(CString -> (Prelude.IO Prelude.String));

{-# NEED peekCStringLen #-}
peekCStringLen{-# 1 #-}::(CStringLen -> (Prelude.IO Prelude.String));

{-# NEED newCString #-}
newCString{-# 0 #-}::(Prelude.String -> (Prelude.IO CString));

{-# NEED newCStringLen #-}
newCStringLen{-# 1 #-}::(Prelude.String -> (Prelude.IO CStringLen));

{-# NEED withCString #-}
withCString{-# 0 #-}::(Prelude.String -> ((CString -> (Prelude.IO a)) -> (Prelude.IO a)));

{-# NEED withCStringLen #-}
withCStringLen{-# 2 #-}::(Prelude.String -> ((CStringLen -> (Prelude.IO a)) -> (Prelude.IO a)));

{-# NEED CStringLen #-}
type {-# 2 #-} CStringLen = (CString,Prelude.Int);

{-# NEED CString #-}
type {-# 1 #-} CString = (Ptr CChar);

{-# NEED castCCharToChar #-}
castCCharToChar{-# 1 #-}::(CChar -> Prelude.Char);

{-# NEED castCharToCChar #-}
castCharToCChar{-# 1 #-}::(Prelude.Char -> CChar);
interface ! IOExtras
{-# NEED unsafePerformIO #-}
unsafePerformIO{-# 1 #-}::((Prelude.IO a) -> a);
interface ! FFI
{-# NEED nullFunPtr #-}
nullFunPtr{-# 0 #-}::(FunPtr a);

{-# NEED castFunPtr #-}
castFunPtr{-# 1 #-}::((FunPtr a) -> (FunPtr b));

{-# NEED castFunPtrToPtr #-}
castFunPtrToPtr{-# 1 #-}::((FunPtr a) -> (Ptr b));

{-# NEED castPtrToFunPtr #-}
castPtrToFunPtr{-# 1 #-}::((Ptr a) -> (FunPtr b));

{-# NEED FunPtr #-}
newtype {-#  #-} FunPtr a;

{-# NEED newForeignPtr #-}
newForeignPtr{-# 2 #-}::((Ptr a) -> ((Prelude.IO ()) -> (Prelude.IO (ForeignPtr a))));

{-# NEED touchForeignPtr #-}
touchForeignPtr{-# 1 #-}::((ForeignPtr a) -> (Prelude.IO ()));

{-# NEED withForeignPtr #-}
withForeignPtr{-# 2 #-}::((ForeignPtr a) -> (((Ptr a) -> (Prelude.IO b)) -> (Prelude.IO b)));

{-# NEED foreignPtrToPtr #-}
foreignPtrToPtr{-# 1 #-}::((ForeignPtr a) -> (Ptr a));

{-# NEED castForeignPtr #-}
castForeignPtr{-# 1 #-}::((ForeignPtr a) -> (ForeignPtr b));

{-# NEED ForeignPtr #-}
newtype {-#  #-} ForeignPtr a;

{-# NEED newStablePtr #-}
newStablePtr{-# 0 #-}::(a -> (Prelude.IO (FFIBuiltin.StablePtr a)));

{-# NEED deRefStablePtr #-}
deRefStablePtr{-# 0 #-}::((FFIBuiltin.StablePtr a) -> (Prelude.IO a));

{-# NEED freeStablePtr #-}
freeStablePtr{-# 0 #-}::((FFIBuiltin.StablePtr a) -> (Prelude.IO ()));

{-# NEED castStablePtrToPtr #-}
castStablePtrToPtr{-# 1 #-}::((FFIBuiltin.StablePtr a) -> (Ptr ()));

{-# NEED castPtrToStablePtr #-}
castPtrToStablePtr{-# 1 #-}::((Ptr ()) -> (FFIBuiltin.StablePtr a));

{-# NEED stablePtrToAddr #-}
stablePtrToAddr{-# 1 #-}::((FFIBuiltin.StablePtr a) -> FFIBuiltin.Addr);

{-# NEED addrToStablePtr #-}
addrToStablePtr{-# 1 #-}::(FFIBuiltin.Addr -> (FFIBuiltin.StablePtr a));

{-# NEED makeStablePtr #-}
makeStablePtr{-# 0 #-}::(a -> (Prelude.IO (FFIBuiltin.StablePtr a)));
interface ! FFIBuiltin
{-# NEED StablePtr #-}
data StablePtr a;
interface ! FFI
{-# NEED nullPtr #-}
nullPtr{-# 0 #-}::(Ptr a);

{-# NEED castPtr #-}
castPtr{-# 1 #-}::((Ptr a) -> (Ptr b));

{-# NEED plusPtr #-}
plusPtr{-# 2 #-}::((Ptr a) -> (Prelude.Int -> (Ptr b)));

{-# NEED alignPtr #-}
alignPtr{-# 2 #-}::((Ptr a) -> (Prelude.Int -> (Ptr a)));

{-# NEED minusPtr #-}
minusPtr{-# 2 #-}::((Ptr a) -> ((Ptr b) -> Prelude.Int));

{-# NEED throwIf #-}
throwIf{-# 3 #-}::((a -> Prelude.Bool) -> ((a -> Prelude.String) -> ((Prelude.IO a) -> (Prelude.IO a))));

{-# NEED throwIf_ #-}
throwIf_{-# 3 #-}::((a -> Prelude.Bool) -> ((a -> Prelude.String) -> ((Prelude.IO a) -> (Prelude.IO ()))));

{-# NEED throwIfNeg #-}
throwIfNeg{-# 0 #-}::(Prelude.Ord a,Prelude.Num a) => ((a -> Prelude.String) -> ((Prelude.IO a) -> (Prelude.IO a)));

{-# NEED throwIfNeg_ #-}
throwIfNeg_{-# 0 #-}::(Prelude.Ord a,Prelude.Num a) => ((a -> Prelude.String) -> ((Prelude.IO a) -> (Prelude.IO ())));

{-# NEED throwIfNull #-}
throwIfNull{-# 0 #-}::(Prelude.String -> ((Prelude.IO (Ptr a)) -> (Prelude.IO (Ptr a))));

{-# NEED void #-}
void{-# 1 #-}::((Prelude.IO a) -> (Prelude.IO ()));

{-# NEED getErrNo #-}
getErrNo{-# 0 #-}::(Prelude.IO Prelude.Int);

{-# NEED mkIOError #-}
mkIOError{-# 4 #-}::(Prelude.String -> ((Prelude.Maybe Prelude.FilePath) -> ((Prelude.Maybe IO.Handle) -> (Prelude.Int -> Prelude.IOError))));

{-# NEED throwIOError #-}
throwIOError{-# 4 #-}::(Prelude.String -> ((Prelude.Maybe Prelude.FilePath) -> ((Prelude.Maybe IO.Handle) -> (Prelude.Int -> (Prelude.IO a)))));
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface ! FFI
{-# NEED nullAddr #-}
nullAddr{-# 0 #-}::FFIBuiltin.Addr;

{-# NEED plusAddr #-}
plusAddr{-# 2 #-}::(FFIBuiltin.Addr -> (Prelude.Int -> FFIBuiltin.Addr));

{-# NEED makeForeignObj #-}
makeForeignObj{-# 2 #-}::(FFIBuiltin.Addr -> ((Prelude.IO ()) -> (Prelude.IO FFIBuiltin.ForeignObj)));

{-# NEED newForeignObj #-}
newForeignObj{-# 0 #-}::(FFIBuiltin.Addr -> ((Prelude.IO ()) -> (Prelude.IO FFIBuiltin.ForeignObj)));

{-# NEED foreignObjToAddr #-}
foreignObjToAddr{-# 1 #-}::(FFIBuiltin.ForeignObj -> FFIBuiltin.Addr);

{-# NEED freeForeignObj #-}
freeForeignObj{-# 1 #-}::(FFIBuiltin.ForeignObj -> (Prelude.IO ()));

{-# NEED withForeignObj #-}
withForeignObj{-# 2 #-}::(FFIBuiltin.ForeignObj -> ((FFIBuiltin.Addr -> (Prelude.IO a)) -> (Prelude.IO a)));

{-# NEED touchForeignObj #-}
touchForeignObj{-# 1 #-}::(FFIBuiltin.ForeignObj -> (Prelude.IO ()));
interface ! FFIBuiltin
{-# NEED ForeignObj #-}
data ForeignObj;
interface ! CString
{-# NEED toCString #-}
toCString{-# 1 #-}::([Prelude.Char] -> PackedString.PackedString);

{-# NEED fromCString #-}
fromCString{-# 1 #-}::(PackedString.PackedString -> [Prelude.Char]);
interface ! PackedString
{-# NEED PackedString #-}
data PackedString;
interface ! FFI
{-# NEED malloc #-}
malloc{-# 0 #-}::(Storable a) => (Prelude.IO (Ptr a));

{-# NEED mallocBytes #-}
mallocBytes{-# 1 #-}::(Prelude.Int -> (Prelude.IO (Ptr a)));

{-# NEED alloca #-}
alloca{-# 0 #-}::(Storable a) => (((Ptr a) -> (Prelude.IO b)) -> (Prelude.IO b));

{-# NEED allocaBytes #-}
allocaBytes{-# 1 #-}::(Prelude.Int -> (((Ptr a) -> (Prelude.IO b)) -> (Prelude.IO b)));

{-# NEED reallocBytes #-}
reallocBytes{-# 2 #-}::((Ptr a) -> (Prelude.Int -> (Prelude.IO (Ptr a))));

{-# NEED free #-}
free{-# 0 #-}::((Ptr a) -> (Prelude.IO ()));

{-# NEED {Storable peekElemOff pokeElemOff peekByteOff pokeByteOff peek poke destruct sizeOf alignment} #-}
class Storable a where {
  peekElemOff{-# 2 #-}::((Ptr a) -> (Prelude.Int -> (Prelude.IO a)));
  pokeElemOff{-# 3 #-}::((Ptr a) -> (Prelude.Int -> (a -> (Prelude.IO ()))));
  peekByteOff{-# 2 #-}::((Ptr b) -> (Prelude.Int -> (Prelude.IO a)));
  pokeByteOff{-# 3 #-}::((Ptr b) -> (Prelude.Int -> (a -> (Prelude.IO ()))));
  peek{-# 1 #-}::((Ptr a) -> (Prelude.IO a));
  poke{-# 2 #-}::((Ptr a) -> (a -> (Prelude.IO ())));
  destruct{-# 1 #-}::((Ptr a) -> (Prelude.IO ()));
  sizeOf{-# 1 #-}::(a -> Prelude.Int);
  alignment{-# 1 #-}::(a -> Prelude.Int);
};

{-# NEED {Ptr Ptr} #-}
newtype {-#  #-} Ptr a
  = Ptr FFIBuiltin.Addr;
interface ! FFIBuiltin
{-# NEED Addr #-}
data Addr;
interface ! FFI
{-# NEED {CLDouble CLDouble} #-}
newtype {-#  #-} CLDouble
  = CLDouble Prelude.Double;

{-# NEED {CDouble CDouble} #-}
newtype {-#  #-} CDouble
  = CDouble Prelude.Double;

{-# NEED {CFloat CFloat} #-}
newtype {-#  #-} CFloat
  = CFloat Prelude.Float;

{-# NEED {CChar CChar} #-}
newtype {-#  #-} CChar
  = CChar Prelude.Char;

{-# NEED {CULLong CULLong} #-}
newtype {-#  #-} CULLong
  = CULLong FFIBuiltin.Word64;

{-# NEED {CLLong CLLong} #-}
newtype {-#  #-} CLLong
  = CLLong FFIBuiltin.Int64;

{-# NEED {CULong CULong} #-}
newtype {-#  #-} CULong
  = CULong FFIBuiltin.Word32;

{-# NEED {CLong CLong} #-}
newtype {-#  #-} CLong
  = CLong FFIBuiltin.Int32;

{-# NEED {CUShort CUShort} #-}
newtype {-#  #-} CUShort
  = CUShort FFIBuiltin.Word16;

{-# NEED {CShort CShort} #-}
newtype {-#  #-} CShort
  = CShort FFIBuiltin.Int16;

{-# NEED {CUChar CUChar} #-}
newtype {-#  #-} CUChar
  = CUChar FFIBuiltin.Word8;

{-# NEED {CSChar CSChar} #-}
newtype {-#  #-} CSChar
  = CSChar FFIBuiltin.Int8;
interface ! FFIBuiltin
{-# NEED Word8 #-}
data Word8;

{-# NEED Word16 #-}
data Word16;

{-# NEED Word64 #-}
data Word64;
interface ! FFI
{-# NEED {CPtrdiff CPtrdiff} #-}
newtype {-#  #-} CPtrdiff
  = CPtrdiff CInt;

{-# NEED {CWchar CWchar} #-}
newtype {-#  #-} CWchar
  = CWchar CInt;

{-# NEED {CSigAtomic CSigAtomic} #-}
newtype {-#  #-} CSigAtomic
  = CSigAtomic CInt;

{-# NEED CSize #-}
type {-# 1 #-} CSize = CInt;

{-# NEED {CInt CInt} #-}
newtype {-#  #-} CInt
  = CInt Prelude.Int;

{-# NEED CClock #-}
type {-# 2 #-} CClock = CUInt;

{-# NEED CTime #-}
type {-# 3 #-} CTime = CUInt;

{-# NEED {CUInt CUInt} #-}
newtype {-#  #-} CUInt
  = CUInt FFIBuiltin.Word32;
interface ! FFIBuiltin
{-# NEED Word32 #-}
data Word32;
interface ! FFI
{-# NEED CFile #-}
data CFile;

{-# NEED CFpos #-}
data CFpos;

{-# NEED CJmpBuf #-}
data CJmpBuf;
interface ! FFIBuiltin
{-# NEED Int64 #-}
data Int64;

{-# NEED Int32 #-}
data Int32;

{-# NEED Int16 #-}
data Int16;

{-# NEED Int8 #-}
data Int8;
}
