interface FFI where {

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

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

{-# 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 CLDouble;

{-# NEED #-}
instance Storable CDouble;

{-# NEED #-}
instance Storable CFloat;

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

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

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

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

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

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

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

{-# 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 CChar;

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Floating 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 (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 Ix.Ix Prelude.Bool;

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

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

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

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

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d) => Ix.Ix (a,b,c,d);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c) => Ix.Ix (a,b,c);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b) => Ix.Ix (a,b);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e) => Ix.Ix (a,b,c,d,e);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f) => Ix.Ix (a,b,c,d,e,f);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g) => Ix.Ix (a,b,c,d,e,f,g);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h) => Ix.Ix (a,b,c,d,e,f,g,h);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i) => Ix.Ix (a,b,c,d,e,f,g,h,i);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j) => Ix.Ix (a,b,c,d,e,f,g,h,i,j);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l,Ix.Ix m) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l,Ix.Ix m,Ix.Ix n) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m,n);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l,Ix.Ix m,Ix.Ix n,Ix.Ix o) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);

{-# 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 Ix.Ix FFIBuiltin.Word8;

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

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

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

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

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

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

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

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

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

{-# 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.Real FFIBuiltin.Word8;

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

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

{-# 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.Integral a) => Prelude.Num (Ratio.Ratio a);

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

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

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

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

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

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

{-# 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.Num FFIBuiltin.Word8;

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

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

{-# 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.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;

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

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

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

{-# 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.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.Bounded FFIBuiltin.Word8;

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

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

{-# 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.Read a,Prelude.Integral a) => Prelude.Read (Ratio.Ratio a);

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

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

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

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

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

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

{-# 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.Read FFIBuiltin.Word8;

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

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

{-# 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 CChar;

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

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

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

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

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

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

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

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

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

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

{-# 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.Enum FFIBuiltin.Word8;

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

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

{-# 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 CChar;

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

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

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

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

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

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

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

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

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

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

{-# 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.Ord FFIBuiltin.Word8;

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

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

{-# 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 CChar;

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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.Eq FFIBuiltin.Word8;

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

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

{-# 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 CChar;

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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.Show FFIBuiltin.Word8;

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

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

{-# 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 CChar;

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

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

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

{-# NEED #-}
instance Prelude.NmCoerce (FFIBuiltin.StablePtr a);

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.ForeignObj;

{-# NEED #-}
instance Prelude.NmCoerce PackedString.PackedString;
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 FFIBuiltin
{-# NEED StablePtr #-}
data StablePtr a;
interface ! FFI
{-# NEED mallocArray #-}
mallocArray{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO (Ptr a))))))));

{-# NEED mallocArray0 #-}
mallocArray0{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO (Ptr a))))))));

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

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

{-# NEED reallocArray #-}
reallocArray{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO (Ptr a)))))))))));

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

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

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

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

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

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

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

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

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

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

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

{-# NEED copyArray #-}
copyArray{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO ())))))))))))));

{-# NEED moveArray #-}
moveArray{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO ())))))))))))));

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

{-# NEED advancePtr #-}
advancePtr{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Ptr a))))))))));

{-# NEED new #-}
new{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.IO (Ptr a))))))));

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

{-# NEED fromBool #-}
fromBool{-# 2 #-}::(Prelude.Num a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Bool) -> (Prelude.R a))))));

{-# NEED toBool #-}
toBool{-# 2 #-}::(Prelude.Num a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R Prelude.Bool))))));

{-# NEED maybeNew #-}
maybeNew{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.IO (Ptr a)))))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Maybe a)) -> (Prelude.R (Prelude.IO (Ptr a)))))))))));

{-# NEED maybeWith #-}
maybeWith{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr b)) -> (Prelude.R (Prelude.IO c))))) -> (Prelude.R (Prelude.IO c)))))))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Maybe a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr b)) -> (Prelude.R (Prelude.IO c))))) -> (Prelude.R (Prelude.IO c)))))))))))));

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

{-# NEED withMany #-}
withMany{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R b) -> (Prelude.R c)))) -> (Prelude.R c))))))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R [a]) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R [b]) -> (Prelude.R c)))) -> (Prelude.R c))))))))))));

{-# NEED copyBytes #-}
copyBytes{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO ())))))))))))));

{-# NEED moveBytes #-}
moveBytes{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO ())))))))))))));

{-# NEED peekCString #-}
peekCString{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R CString) -> (Prelude.R (Prelude.IO Prelude.String)))))));

{-# NEED peekCStringLen #-}
peekCStringLen{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R CStringLen) -> (Prelude.R (Prelude.IO Prelude.String)))))));

{-# NEED newCString #-}
newCString{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO CString)))))));

{-# NEED newCStringLen #-}
newCStringLen{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.IO CStringLen)))))));

{-# NEED withCString #-}
withCString{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R CString) -> (Prelude.R (Prelude.IO a))))) -> (Prelude.R (Prelude.IO a))))))))));

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

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

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

{-# NEED castCCharToChar #-}
castCCharToChar{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R CChar) -> (Prelude.R Prelude.Char))))));

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

{-# NEED castFunPtr #-}
castFunPtr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (FunPtr a)) -> (Prelude.R (FunPtr b)))))));

{-# NEED castFunPtrToPtr #-}
castFunPtrToPtr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (FunPtr a)) -> (Prelude.R (Ptr b)))))));

{-# NEED castPtrToFunPtr #-}
castPtrToFunPtr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (FunPtr b)))))));

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

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

{-# NEED touchForeignPtr #-}
touchForeignPtr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (ForeignPtr a)) -> (Prelude.R (Prelude.IO ())))))));

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

{-# NEED foreignPtrToPtr #-}
foreignPtrToPtr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (ForeignPtr a)) -> (Prelude.R (Ptr a)))))));

{-# NEED castForeignPtr #-}
castForeignPtr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (ForeignPtr a)) -> (Prelude.R (ForeignPtr b)))))));

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

{-# NEED nullPtr #-}
nullPtr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Ptr a))));

{-# NEED castPtr #-}
castPtr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Ptr b)))))));

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

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

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

{-# NEED throwIf #-}
throwIf{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R Prelude.Bool)))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R Prelude.String)))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO a)) -> (Prelude.R (Prelude.IO a)))))))))))));

{-# NEED throwIf_ #-}
throwIf_{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R Prelude.Bool)))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R Prelude.String)))) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO a)) -> (Prelude.R (Prelude.IO ())))))))))))));

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

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

{-# NEED throwIfNull #-}
throwIfNull{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.String) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO (Ptr a))) -> (Prelude.R (Prelude.IO (Ptr a)))))))))));

{-# NEED void #-}
void{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO a)) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED getErrNo #-}
getErrNo{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO Prelude.Int))));

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

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

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

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

{-# NEED newForeignObj #-}
newForeignObj{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R FFIBuiltin.Addr) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.IO ())) -> (Prelude.R (Prelude.IO FFIBuiltin.ForeignObj))))))))));

{-# NEED foreignObjToAddr #-}
foreignObjToAddr{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R FFIBuiltin.ForeignObj) -> (Prelude.R FFIBuiltin.Addr))))));

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

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

{-# NEED fromCString #-}
fromCString{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R PackedString.PackedString) -> (Prelude.R [Prelude.Char]))))));
interface ! FFI
{-# NEED malloc #-}
malloc{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO (Ptr a)))));

{-# NEED mallocBytes #-}
mallocBytes{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.IO (Ptr a))))))));

{-# NEED alloca #-}
alloca{-# 2 #-}::(Storable a) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.IO b))))) -> (Prelude.R (Prelude.IO b)))))));

{-# NEED allocaBytes #-}
allocaBytes{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.IO b))))) -> (Prelude.R (Prelude.IO b))))))))));

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

{-# NEED free #-}
free{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Ptr a)) -> (Prelude.R (Prelude.IO ())))))));

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

{-# NEED {CPtrdiff CPtrdiff} #-}
newtype {-#  #-} CPtrdiff
  = CPtrdiff (Prelude.R CInt);

{-# NEED {CWchar CWchar} #-}
newtype {-#  #-} CWchar
  = CWchar (Prelude.R CInt);

{-# NEED {CSigAtomic CSigAtomic} #-}
newtype {-#  #-} CSigAtomic
  = CSigAtomic (Prelude.R CInt);

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

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

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

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

{-# NEED {CUInt CUInt} #-}
newtype {-#  #-} CUInt
  = CUInt (Prelude.R FFIBuiltin.Word32);

{-# NEED CFile #-}
data CFile;

{-# NEED CFpos #-}
data CFpos;

{-# NEED CJmpBuf #-}
data CJmpBuf;

{-# NEED {CLDouble CLDouble} #-}
newtype {-#  #-} CLDouble
  = CLDouble (Prelude.R Prelude.Double);

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

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

{-# NEED {CULLong CULLong} #-}
newtype {-#  #-} CULLong
  = CULLong (Prelude.R FFIBuiltin.Word64);
interface ! FFIBuiltin
{-# NEED Word64 #-}
data Word64;
interface ! FFI
{-# NEED {CLLong CLLong} #-}
newtype {-#  #-} CLLong
  = CLLong (Prelude.R FFIBuiltin.Int64);
interface ! FFIBuiltin
{-# NEED Int64 #-}
data Int64;
interface ! FFI
{-# NEED {CULong CULong} #-}
newtype {-#  #-} CULong
  = CULong (Prelude.R FFIBuiltin.Word32);
interface ! FFIBuiltin
{-# NEED Word32 #-}
data Word32;
interface ! FFI
{-# NEED {CLong CLong} #-}
newtype {-#  #-} CLong
  = CLong (Prelude.R FFIBuiltin.Int32);
interface ! FFIBuiltin
{-# NEED Int32 #-}
data Int32;
interface ! FFI
{-# NEED {CUShort CUShort} #-}
newtype {-#  #-} CUShort
  = CUShort (Prelude.R FFIBuiltin.Word16);
interface ! FFIBuiltin
{-# NEED Word16 #-}
data Word16;
interface ! FFI
{-# NEED {CShort CShort} #-}
newtype {-#  #-} CShort
  = CShort (Prelude.R FFIBuiltin.Int16);
interface ! FFIBuiltin
{-# NEED Int16 #-}
data Int16;
interface ! FFI
{-# NEED {CUChar CUChar} #-}
newtype {-#  #-} CUChar
  = CUChar (Prelude.R FFIBuiltin.Word8);
interface ! FFIBuiltin
{-# NEED Word8 #-}
data Word8;
interface ! FFI
{-# NEED {CSChar CSChar} #-}
newtype {-#  #-} CSChar
  = CSChar (Prelude.R FFIBuiltin.Int8);
interface ! FFIBuiltin
{-# NEED Int8 #-}
data Int8;
interface ! FFI
{-# NEED {CChar CChar} #-}
newtype {-#  #-} CChar
  = CChar (Prelude.R Prelude.Char);

{-# NEED {Ptr Ptr} #-}
newtype {-#  #-} Ptr a
  = Ptr (Prelude.R FFIBuiltin.Addr);
interface ! FFIBuiltin
{-# NEED Addr #-}
data Addr;

{-# NEED ForeignObj #-}
data ForeignObj;
interface ! PackedString
{-# NEED PackedString #-}
data PackedString;
}
