interface Foreign where {
infixl  8 `Data.Bits.shift`;
infixl  8 `Data.Bits.rotate`;
infixl  8 `Data.Bits.shiftL`;
infixl  8 `Data.Bits.shiftR`;
infixl  8 `Data.Bits.rotateL`;
infixl  8 `Data.Bits.rotateR`;
infixl  7 Data.Bits..&.;
infixl  5 Data.Bits..|.;
infixl  6 `Data.Bits.xor`;

{-# NEED #-}
instance Data.Typeable.Typeable2 Array.Array;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.FFI.ForeignPtr;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable1 (Array.Array a);

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.FFI.StablePtr;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.FFI.FunPtr;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.FFI.Ptr;

{-# NEED #-}
instance Data.Typeable.Typeable1 Ratio.Ratio;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.Internal.IO;

{-# NEED #-}
instance (Data.Typeable.Typeable a,Data.Typeable.Typeable b) => Data.Typeable.Typeable (Prelude.Either a b);

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (Prelude.Maybe a);

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable [a];

{-# NEED #-}
instance Data.Typeable.Typeable Data.Typeable.TyCon;

{-# NEED #-}
instance Data.Typeable.Typeable Data.Typeable.TypeRep;

{-# NEED #-}
instance Data.Typeable.Typeable IO.Handle;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.FFI.ForeignPtr a);

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Ordering;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Integer;

{-# NEED #-}
instance (Data.Typeable.Typeable a,Data.Typeable.Typeable b) => Data.Typeable.Typeable (Array.Array a b);

{-# NEED #-}
instance Data.Typeable.Typeable ();

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.FFI.StablePtr a);

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Int;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Double;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Bool;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Float;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Char;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.FFI.FunPtr a);

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.FFI.Ptr a);

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

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Word64;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Word16;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Word8;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Word32;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Int8;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Int16;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Int32;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Int64;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (Ratio.Ratio a);

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.Internal.IO a);

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

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

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

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

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

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

{-# NEED #-}
instance Data.Bits.Bits Prelude.Integer;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CChar;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CSChar;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CUChar;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CShort;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CUShort;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CLong;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CULong;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CLLong;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CULLong;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CUInt;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CSize;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CWchar;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CPtrdiff;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.CInt;

{-# NEED #-}
instance Data.Bits.Bits Prelude.Int;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Word64;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Word16;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Word8;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Word32;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Int8;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Int16;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Int32;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Int64;

{-# 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 (a,b,c);

{-# 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 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 o) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);

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

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

{-# NEED #-}
instance Ix.Ix Data.Char.GeneralCategory;

{-# NEED #-}
instance Ix.Ix IO.IOMode;

{-# NEED #-}
instance Ix.Ix IO.SeekMode;

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

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

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

{-# NEED #-}
instance Ix.Ix NHC.FFI.Word64;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Word16;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Word8;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Word32;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Int8;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Int16;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Int32;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Bounded Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Bounded IO.IOMode;

{-# NEED #-}
instance Prelude.Bounded IO.SeekMode;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.CChar;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.CPtrdiff;

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

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Int64;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CTime;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CClock;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CFloat;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CDouble;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CLDouble;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CChar;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CSChar;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CUChar;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CShort;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CUShort;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CLong;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CULong;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CLLong;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CULLong;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CUInt;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CSize;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CSigAtomic;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CWchar;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CPtrdiff;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CInt;

{-# NEED #-}
instance NHC.FFI.Storable (NHC.FFI.StablePtr a);

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

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

{-# NEED #-}
instance NHC.FFI.Storable Prelude.Bool;

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

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

{-# NEED #-}
instance NHC.FFI.Storable (NHC.FFI.FunPtr a);

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

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Word64;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Word16;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Word8;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Word32;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Int8;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Int16;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Int32;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Int64;

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Read IO.BufferMode;

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

{-# NEED #-}
instance Prelude.Read Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Read IO.IOMode;

{-# NEED #-}
instance Prelude.Read IO.SeekMode;

{-# NEED #-}
instance Prelude.Read NHC.FFI.CTime;

{-# NEED #-}
instance Prelude.Read NHC.FFI.CClock;

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Read NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Read NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Read NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Read NHC.FFI.CPtrdiff;

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

{-# NEED #-}
instance Prelude.Read NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Int64;

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

{-# NEED #-}
instance Prelude.Num NHC.FFI.CTime;

{-# NEED #-}
instance Prelude.Num NHC.FFI.CClock;

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

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

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

{-# NEED #-}
instance Prelude.Num NHC.FFI.CChar;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Num NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Num NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Num NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Num NHC.FFI.CPtrdiff;

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

{-# NEED #-}
instance Prelude.Num NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Int64;

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

{-# NEED #-}
instance Prelude.Real NHC.FFI.CTime;

{-# NEED #-}
instance Prelude.Real NHC.FFI.CClock;

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

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

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

{-# NEED #-}
instance Prelude.Real NHC.FFI.CChar;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Real NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Real NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Real NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Real NHC.FFI.CPtrdiff;

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

{-# NEED #-}
instance Prelude.Real NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Int64;

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

{-# NEED #-}
instance Prelude.Eq Data.Typeable.KeyPr;

{-# NEED #-}
instance Prelude.Eq Data.Typeable.Key;

{-# NEED #-}
instance Prelude.Eq Data.HashTable.Inserts;

{-# NEED #-}
instance Prelude.Eq Data.Typeable.TyCon;

{-# NEED #-}
instance Prelude.Eq Data.Typeable.TypeRep;

{-# NEED #-}
instance Prelude.Eq Data.HashTable.HashData;

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

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

{-# NEED #-}
instance Prelude.Eq (NHC.FFI.ForeignPtr a);

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

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

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

{-# NEED #-}
instance Prelude.Eq Data.Char.GeneralCategory;

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

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

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CTime;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CClock;

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CPtrdiff;

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

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

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

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Int64;

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

{-# NEED #-}
instance Prelude.Ord (NHC.FFI.ForeignPtr a);

{-# NEED #-}
instance Prelude.Ord IO.BufferMode;

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

{-# NEED #-}
instance Prelude.Ord Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Ord IO.IOMode;

{-# NEED #-}
instance Prelude.Ord IO.SeekMode;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CTime;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CClock;

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CPtrdiff;

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

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

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

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Int64;

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

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

{-# NEED #-}
instance Prelude.Enum Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Enum IO.IOMode;

{-# NEED #-}
instance Prelude.Enum IO.SeekMode;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CTime;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CClock;

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CPtrdiff;

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

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

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Int64;

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

{-# NEED #-}
instance Prelude.Integral NHC.FFI.CChar;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Integral NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.CPtrdiff;

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

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Int64;

{-# NEED #-}
instance (Ix.Ix a) => Prelude.Functor (Array.Array a);

{-# NEED #-}
instance Prelude.Functor NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Monad NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Show Data.Typeable.TyCon;

{-# NEED #-}
instance Prelude.Show Data.Typeable.TypeRep;

{-# NEED #-}
instance Prelude.Show Data.HashTable.HashData;

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

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

{-# NEED #-}
instance Prelude.Show (NHC.FFI.ForeignPtr a);

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

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

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

{-# NEED #-}
instance Prelude.Show Data.Char.GeneralCategory;

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

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

{-# NEED #-}
instance Prelude.Show NHC.FFI.CTime;

{-# NEED #-}
instance Prelude.Show NHC.FFI.CClock;

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show NHC.FFI.CSize;

{-# NEED #-}
instance Prelude.Show NHC.FFI.CSigAtomic;

{-# NEED #-}
instance Prelude.Show NHC.FFI.CWchar;

{-# NEED #-}
instance Prelude.Show NHC.FFI.CPtrdiff;

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

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

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

{-# NEED #-}
instance Prelude.Show NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Int64;

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);
interface Data.Typeable
{-# NEED Typeable #-}
class Typeable a;

{-# NEED KeyPr #-}
data KeyPr;

{-# NEED Key #-}
newtype {-#  #-} Key;
interface Data.HashTable
{-# NEED Inserts #-}
data Inserts;
interface Data.Typeable
{-# NEED TyCon #-}
data TyCon;

{-# NEED TypeRep #-}
data TypeRep;
interface Data.HashTable
{-# NEED HashData #-}
data HashData;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;

{-# NEED HandlePosn #-}
data HandlePosn;

{-# NEED BufferMode #-}
data BufferMode;
interface Array
{-# NEED Array #-}
data (Ix.Ix a) => Array a b;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface IO
{-# NEED IOMode #-}
data IOMode;

{-# NEED SeekMode #-}
data SeekMode;
interface NHC.FFI
{-# NEED CTime #-}
newtype {-#  #-} CTime;

{-# NEED CClock #-}
newtype {-#  #-} CClock;

{-# NEED CFloat #-}
newtype {-#  #-} CFloat;

{-# NEED CDouble #-}
newtype {-#  #-} CDouble;

{-# NEED CLDouble #-}
newtype {-#  #-} CLDouble;

{-# NEED CChar #-}
newtype {-#  #-} CChar;

{-# NEED CSChar #-}
newtype {-#  #-} CSChar;

{-# NEED CUChar #-}
newtype {-#  #-} CUChar;

{-# NEED CShort #-}
newtype {-#  #-} CShort;

{-# NEED CUShort #-}
newtype {-#  #-} CUShort;

{-# NEED CLong #-}
newtype {-#  #-} CLong;

{-# NEED CULong #-}
newtype {-#  #-} CULong;

{-# NEED CLLong #-}
newtype {-#  #-} CLLong;

{-# NEED CULLong #-}
newtype {-#  #-} CULLong;

{-# NEED CUInt #-}
newtype {-#  #-} CUInt;

{-# NEED CSize #-}
newtype {-#  #-} CSize;

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

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

{-# NEED CPtrdiff #-}
newtype {-#  #-} CPtrdiff;

{-# NEED CInt #-}
newtype {-#  #-} CInt;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! NHC.FFI
{-# NEED newForeignPtr #-}
newForeignPtr{-# 0 #-}::((NHC.FFI.FinalizerPtr a) -> ((NHC.FFI.Ptr a) -> (NHC.Internal.IO (NHC.FFI.ForeignPtr a))));

{-# NEED newForeignPtr_ #-}
newForeignPtr_{-# 1 #-}::((NHC.FFI.Ptr a) -> (NHC.Internal.IO (NHC.FFI.ForeignPtr a)));

{-# NEED addForeignPtrFinalizer #-}
addForeignPtrFinalizer{-# 2 #-}::((NHC.FFI.FinalizerPtr a) -> ((NHC.FFI.ForeignPtr a) -> (NHC.Internal.IO ())));

{-# NEED FinalizerPtr #-}
type {-# 1 #-} FinalizerPtr a = (NHC.FFI.FunPtr ((NHC.FFI.Ptr a) -> (NHC.Internal.IO ())));

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

{-# NEED unsafeForeignPtrToPtr #-}
unsafeForeignPtrToPtr{-# 1 #-}::((NHC.FFI.ForeignPtr a) -> (NHC.FFI.Ptr a));

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

{-# NEED castForeignPtr #-}
castForeignPtr{-# 1 #-}::((NHC.FFI.ForeignPtr a) -> (NHC.FFI.ForeignPtr b));
interface ! Foreign.ForeignPtr
{-# NEED mallocForeignPtr #-}
mallocForeignPtr{-# 0 #-}::(NHC.FFI.Storable a) => (NHC.Internal.IO (NHC.FFI.ForeignPtr a));

{-# NEED mallocForeignPtrBytes #-}
mallocForeignPtrBytes{-# 1 #-}::(Prelude.Int -> (NHC.Internal.IO (NHC.FFI.ForeignPtr a)));

{-# NEED mallocForeignPtrArray #-}
mallocForeignPtrArray{-# 0 #-}::(NHC.FFI.Storable a) => (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.ForeignPtr a)));

{-# NEED mallocForeignPtrArray0 #-}
mallocForeignPtrArray0{-# 1 #-}::(NHC.FFI.Storable a) => (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.ForeignPtr a)));
interface ! NHC.FFI
{-# NEED newStablePtr #-}
newStablePtr{-# 0 #-}::(a -> (NHC.Internal.IO (NHC.FFI.StablePtr a)));

{-# NEED deRefStablePtr #-}
deRefStablePtr{-# 0 #-}::((NHC.FFI.StablePtr a) -> (NHC.Internal.IO a));

{-# NEED freeStablePtr #-}
freeStablePtr{-# 0 #-}::((NHC.FFI.StablePtr a) -> (NHC.Internal.IO ()));

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

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

{-# NEED nullFunPtr #-}
nullFunPtr{-# 0 #-}::(NHC.FFI.FunPtr a);

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

{-# NEED freeHaskellFunPtr #-}
freeHaskellFunPtr{-# 1 #-}::((NHC.FFI.FunPtr a) -> (NHC.Internal.IO ()));

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

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

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

{-# NEED nullPtr #-}
nullPtr{-# 0 #-}::(NHC.FFI.Ptr a);

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

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

{-# NEED minusPtr #-}
minusPtr{-# 2 #-}::((NHC.FFI.Ptr a) -> ((NHC.FFI.Ptr b) -> Prelude.Int));
interface ! Foreign.Marshal.Alloc
{-# NEED finalizerFree #-}
finalizerFree{-# 0 #-}::(NHC.FFI.FunPtr ((NHC.FFI.Ptr a) -> (NHC.Internal.IO ())));

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

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

{-# NEED realloc #-}
realloc{-# 0 #-}::(NHC.FFI.Storable b) => ((NHC.FFI.Ptr a) -> (NHC.Internal.IO (NHC.FFI.Ptr b)));

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

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

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

{-# NEED malloc #-}
malloc{-# 0 #-}::(NHC.FFI.Storable a) => (NHC.Internal.IO (NHC.FFI.Ptr a));
interface ! Foreign.Marshal.Pool
{-# NEED pooledNewArray0 #-}
pooledNewArray0{-# 3 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> (a -> ([a] -> (NHC.Internal.IO (NHC.FFI.Ptr a)))));

{-# NEED pooledNewArray #-}
pooledNewArray{-# 2 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> ([a] -> (NHC.Internal.IO (NHC.FFI.Ptr a))));

{-# NEED pooledNew #-}
pooledNew{-# 2 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> (a -> (NHC.Internal.IO (NHC.FFI.Ptr a))));

{-# NEED pooledReallocArray0 #-}
pooledReallocArray0{-# 3 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> ((NHC.FFI.Ptr a) -> (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.Ptr a)))));

{-# NEED pooledReallocArray #-}
pooledReallocArray{-# 0 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> ((NHC.FFI.Ptr a) -> (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.Ptr a)))));

{-# NEED pooledMallocArray0 #-}
pooledMallocArray0{-# 2 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.Ptr a))));

{-# NEED pooledMallocArray #-}
pooledMallocArray{-# 0 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.Ptr a))));

{-# NEED pooledReallocBytes #-}
pooledReallocBytes{-# 3 #-}::(Foreign.Marshal.Pool.Pool -> ((NHC.FFI.Ptr a) -> (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.Ptr a)))));

{-# NEED pooledRealloc #-}
pooledRealloc{-# 0 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> ((NHC.FFI.Ptr a) -> (NHC.Internal.IO (NHC.FFI.Ptr a))));

{-# NEED pooledMallocBytes #-}
pooledMallocBytes{-# 2 #-}::(Foreign.Marshal.Pool.Pool -> (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.Ptr a))));

{-# NEED pooledMalloc #-}
pooledMalloc{-# 0 #-}::(NHC.FFI.Storable a) => (Foreign.Marshal.Pool.Pool -> (NHC.Internal.IO (NHC.FFI.Ptr a)));

{-# NEED withPool #-}
withPool{-# 0 #-}::((Foreign.Marshal.Pool.Pool -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a));

{-# NEED freePool #-}
freePool{-# 1 #-}::(Foreign.Marshal.Pool.Pool -> (NHC.Internal.IO ()));

{-# NEED newPool #-}
newPool{-# 0 #-}::(NHC.Internal.IO Foreign.Marshal.Pool.Pool);

{-# NEED {Pool} #-}
newtype {-#  #-} Pool
  = Unexported.Constr_143 (NHC.IOExtras.IORef [(NHC.FFI.Ptr ())]);
interface NHC.IOExtras
{-# NEED IORef #-}
newtype {-#  #-} IORef a;
interface ! Foreign.Marshal.Error
{-# NEED void #-}
void{-# 1 #-}::((NHC.Internal.IO a) -> (NHC.Internal.IO ()));

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

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

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

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

{-# NEED throwIf #-}
throwIf{-# 3 #-}::((a -> Prelude.Bool) -> ((a -> Prelude.String) -> ((NHC.Internal.IO a) -> (NHC.Internal.IO a))));
interface ! Foreign.Marshal.Utils
{-# NEED moveBytes #-}
moveBytes{-# 3 #-}::((NHC.FFI.Ptr a) -> ((NHC.FFI.Ptr a) -> (Prelude.Int -> (NHC.Internal.IO ()))));

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

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

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

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

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

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

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

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

{-# NEED new #-}
new{-# 1 #-}::(NHC.FFI.Storable a) => (a -> (NHC.Internal.IO (NHC.FFI.Ptr a)));
interface ! Foreign.Marshal.Array
{-# NEED advancePtr #-}
advancePtr{-# 0 #-}::(NHC.FFI.Storable a) => ((NHC.FFI.Ptr a) -> (Prelude.Int -> (NHC.FFI.Ptr a)));

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

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

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

{-# NEED withArrayLen0 #-}
withArrayLen0{-# 3 #-}::(NHC.FFI.Storable a) => (a -> ([a] -> ((Prelude.Int -> ((NHC.FFI.Ptr a) -> (NHC.Internal.IO b))) -> (NHC.Internal.IO b))));

{-# NEED withArray0 #-}
withArray0{-# 2 #-}::(NHC.FFI.Storable a) => (a -> ([a] -> (((NHC.FFI.Ptr a) -> (NHC.Internal.IO b)) -> (NHC.Internal.IO b))));

{-# NEED withArrayLen #-}
withArrayLen{-# 2 #-}::(NHC.FFI.Storable a) => ([a] -> ((Prelude.Int -> ((NHC.FFI.Ptr a) -> (NHC.Internal.IO b))) -> (NHC.Internal.IO b)));

{-# NEED withArray #-}
withArray{-# 1 #-}::(NHC.FFI.Storable a) => ([a] -> (((NHC.FFI.Ptr a) -> (NHC.Internal.IO b)) -> (NHC.Internal.IO b)));

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

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

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

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

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

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

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

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

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

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

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

{-# NEED mallocArray #-}
mallocArray{-# 0 #-}::(NHC.FFI.Storable a) => (Prelude.Int -> (NHC.Internal.IO (NHC.FFI.Ptr a)));
interface ! NHC.FFI
{-# NEED ForeignPtr #-}
data ForeignPtr a;

{-# NEED StablePtr #-}
data StablePtr a;

{-# NEED FunPtr #-}
data FunPtr a;
interface ! NHC.Internal
{-# NEED unsafePerformIO #-}
unsafePerformIO{-# 1 #-}::((NHC.Internal.IO a) -> a);
interface ! NHC.FFI
{-# NEED Word64 #-}
data Word64;

{-# NEED Word16 #-}
data Word16;

{-# NEED Word8 #-}
data Word8;
interface ! Data.Word
{-# NEED Word #-}
type {-# 1 #-} Word = NHC.FFI.Word32;
interface ! NHC.FFI
{-# NEED Word32 #-}
data Word32;

{-# NEED Int8 #-}
data Int8;

{-# NEED Int16 #-}
data Int16;

{-# NEED Int32 #-}
data Int32;
interface ! Data.Bits
{-# NEED {Bits shift rotate bit setBit clearBit complementBit testBit shiftL shiftR rotateL rotateR (.&.) (.|.) xor complement bitSize isSigned} #-}
class (Prelude.Num a) => Bits a where {
  shift{-# 2 #-}::(a -> (Prelude.Int -> a));
  rotate{-# 2 #-}::(a -> (Prelude.Int -> a));
  bit{-# 1 #-}::(Prelude.Int -> a);
  setBit{-# 2 #-}::(a -> (Prelude.Int -> a));
  clearBit{-# 2 #-}::(a -> (Prelude.Int -> a));
  complementBit{-# 2 #-}::(a -> (Prelude.Int -> a));
  testBit{-# 2 #-}::(a -> (Prelude.Int -> Prelude.Bool));
  shiftL{-# 2 #-}::(a -> (Prelude.Int -> a));
  shiftR{-# 2 #-}::(a -> (Prelude.Int -> a));
  rotateL{-# 2 #-}::(a -> (Prelude.Int -> a));
  rotateR{-# 2 #-}::(a -> (Prelude.Int -> a));
  (.&.){-# 2 #-}::(a -> (a -> a));
  (.|.){-# 2 #-}::(a -> (a -> a));
  xor{-# 2 #-}::(a -> (a -> a));
  complement{-# 1 #-}::(a -> a);
  bitSize{-# 1 #-}::(a -> Prelude.Int);
  isSigned{-# 1 #-}::(a -> Prelude.Bool);
};
interface ! NHC.FFI
{-# NEED {Storable peekElemOff pokeElemOff peekByteOff pokeByteOff peek poke destruct sizeOf alignment} #-}
class Storable a where {
  peekElemOff{-# 2 #-}::((NHC.FFI.Ptr a) -> (Prelude.Int -> (NHC.Internal.IO a)));
  pokeElemOff{-# 3 #-}::((NHC.FFI.Ptr a) -> (Prelude.Int -> (a -> (NHC.Internal.IO ()))));
  peekByteOff{-# 2 #-}::((NHC.FFI.Ptr b) -> (Prelude.Int -> (NHC.Internal.IO a)));
  pokeByteOff{-# 3 #-}::((NHC.FFI.Ptr b) -> (Prelude.Int -> (a -> (NHC.Internal.IO ()))));
  peek{-# 1 #-}::((NHC.FFI.Ptr a) -> (NHC.Internal.IO a));
  poke{-# 2 #-}::((NHC.FFI.Ptr a) -> (a -> (NHC.Internal.IO ())));
  destruct{-# 1 #-}::((NHC.FFI.Ptr a) -> (NHC.Internal.IO ()));
  sizeOf{-# 1 #-}::(a -> Prelude.Int);
  alignment{-# 1 #-}::(a -> Prelude.Int);
};
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Prelude
{-# NEED Int #-}
data Int;
interface ! NHC.FFI
{-# NEED Ptr #-}
data Ptr a;

{-# NEED Int64 #-}
data Int64;
}