interface Foreign.C where {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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.Functor NHC.Internal.IO;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 (NHC.FFI.ForeignPtr a);

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Foreign.C.Error.Errno;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 (NHC.FFI.ForeignPtr a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 [a];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.FFI.StablePtr a);
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface IO
{-# NEED SeekMode #-}
data SeekMode;

{-# NEED IOMode #-}
data IOMode;

{-# NEED BufferMode #-}
data BufferMode;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED HandlePosn #-}
data HandlePosn;
interface Data.HashTable
{-# NEED HashData #-}
data HashData;

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

{-# NEED KeyPr #-}
data KeyPr;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface NHC.FFI
{-# NEED FunPtr #-}
data FunPtr a;
interface Array
{-# NEED Array #-}
data (Ix.Ix a) => Array a b;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface NHC.FFI
{-# NEED ForeignPtr #-}
data ForeignPtr a;
interface Data.Typeable
{-# NEED TypeRep #-}
data TypeRep;

{-# NEED TyCon #-}
data TyCon;

{-# NEED Typeable #-}
class Typeable a;
interface NHC.FFI
{-# NEED StablePtr #-}
data StablePtr a;
interface ! NHC.FFI
{-# NEED CFile #-}
data CFile;

{-# NEED CFpos #-}
data CFpos;

{-# NEED CJmpBuf #-}
data CJmpBuf;
interface ! Foreign.C.Error
{-# NEED eOK #-}
eOK{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED e2BIG #-}
e2BIG{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eACCES #-}
eACCES{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eADDRINUSE #-}
eADDRINUSE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eADDRNOTAVAIL #-}
eADDRNOTAVAIL{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eADV #-}
eADV{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eAFNOSUPPORT #-}
eAFNOSUPPORT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eAGAIN #-}
eAGAIN{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eALREADY #-}
eALREADY{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eBADF #-}
eBADF{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eBADMSG #-}
eBADMSG{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eBADRPC #-}
eBADRPC{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eBUSY #-}
eBUSY{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eCHILD #-}
eCHILD{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eCOMM #-}
eCOMM{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eCONNABORTED #-}
eCONNABORTED{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eCONNREFUSED #-}
eCONNREFUSED{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eCONNRESET #-}
eCONNRESET{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eDEADLK #-}
eDEADLK{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eDESTADDRREQ #-}
eDESTADDRREQ{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eDIRTY #-}
eDIRTY{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eDOM #-}
eDOM{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eDQUOT #-}
eDQUOT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eEXIST #-}
eEXIST{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eFAULT #-}
eFAULT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eFBIG #-}
eFBIG{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eFTYPE #-}
eFTYPE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eHOSTDOWN #-}
eHOSTDOWN{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eHOSTUNREACH #-}
eHOSTUNREACH{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eIDRM #-}
eIDRM{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eILSEQ #-}
eILSEQ{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eINPROGRESS #-}
eINPROGRESS{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eINTR #-}
eINTR{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eINVAL #-}
eINVAL{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eIO #-}
eIO{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eISCONN #-}
eISCONN{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eISDIR #-}
eISDIR{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eLOOP #-}
eLOOP{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eMFILE #-}
eMFILE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eMLINK #-}
eMLINK{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eMSGSIZE #-}
eMSGSIZE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eMULTIHOP #-}
eMULTIHOP{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNAMETOOLONG #-}
eNAMETOOLONG{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNETDOWN #-}
eNETDOWN{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNETRESET #-}
eNETRESET{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNETUNREACH #-}
eNETUNREACH{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNFILE #-}
eNFILE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOBUFS #-}
eNOBUFS{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNODATA #-}
eNODATA{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNODEV #-}
eNODEV{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOENT #-}
eNOENT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOEXEC #-}
eNOEXEC{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOLCK #-}
eNOLCK{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOLINK #-}
eNOLINK{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOMEM #-}
eNOMEM{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOMSG #-}
eNOMSG{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNONET #-}
eNONET{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOPROTOOPT #-}
eNOPROTOOPT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOSPC #-}
eNOSPC{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOSR #-}
eNOSR{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOSTR #-}
eNOSTR{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOSYS #-}
eNOSYS{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOTBLK #-}
eNOTBLK{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOTCONN #-}
eNOTCONN{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOTDIR #-}
eNOTDIR{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOTEMPTY #-}
eNOTEMPTY{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOTSOCK #-}
eNOTSOCK{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNOTTY #-}
eNOTTY{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eNXIO #-}
eNXIO{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eOPNOTSUPP #-}
eOPNOTSUPP{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePERM #-}
ePERM{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePFNOSUPPORT #-}
ePFNOSUPPORT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePIPE #-}
ePIPE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePROCLIM #-}
ePROCLIM{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePROCUNAVAIL #-}
ePROCUNAVAIL{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePROGMISMATCH #-}
ePROGMISMATCH{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePROGUNAVAIL #-}
ePROGUNAVAIL{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePROTO #-}
ePROTO{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePROTONOSUPPORT #-}
ePROTONOSUPPORT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED ePROTOTYPE #-}
ePROTOTYPE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eRANGE #-}
eRANGE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eREMCHG #-}
eREMCHG{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eREMOTE #-}
eREMOTE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eROFS #-}
eROFS{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eRPCMISMATCH #-}
eRPCMISMATCH{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eRREMOTE #-}
eRREMOTE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eSHUTDOWN #-}
eSHUTDOWN{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eSOCKTNOSUPPORT #-}
eSOCKTNOSUPPORT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eSPIPE #-}
eSPIPE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eSRCH #-}
eSRCH{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eSRMNT #-}
eSRMNT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eSTALE #-}
eSTALE{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eTIME #-}
eTIME{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eTIMEDOUT #-}
eTIMEDOUT{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eTOOMANYREFS #-}
eTOOMANYREFS{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eTXTBSY #-}
eTXTBSY{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eUSERS #-}
eUSERS{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eWOULDBLOCK #-}
eWOULDBLOCK{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED eXDEV #-}
eXDEV{-# 0 #-}::Foreign.C.Error.Errno;

{-# NEED isValidErrno #-}
isValidErrno{-# 1 #-}::(Foreign.C.Error.Errno -> Prelude.Bool);

{-# NEED getErrno #-}
getErrno{-# 0 #-}::(NHC.Internal.IO Foreign.C.Error.Errno);

{-# NEED resetErrno #-}
resetErrno{-# 0 #-}::(NHC.Internal.IO ());

{-# NEED throwErrno #-}
throwErrno{-# 1 #-}::(Prelude.String -> (NHC.Internal.IO a));

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

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

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

{-# NEED throwErrnoIfRetryMayBlock #-}
throwErrnoIfRetryMayBlock{-# 4 #-}::((a -> Prelude.Bool) -> (Prelude.String -> ((NHC.Internal.IO a) -> ((NHC.Internal.IO b) -> (NHC.Internal.IO a)))));

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

{-# NEED throwErrnoIfRetryMayBlock_ #-}
throwErrnoIfRetryMayBlock_{-# 4 #-}::((a -> Prelude.Bool) -> (Prelude.String -> ((NHC.Internal.IO a) -> ((NHC.Internal.IO b) -> (NHC.Internal.IO ())))));

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

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

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

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

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

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

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

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

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

{-# NEED errnoToIOError #-}
errnoToIOError{-# 4 #-}::(Prelude.String -> (Foreign.C.Error.Errno -> ((Prelude.Maybe IO.Handle) -> ((Prelude.Maybe Prelude.String) -> Prelude.IOError))));
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface ! Foreign.C.Error
{-# NEED {Errno Errno} #-}
newtype {-#  #-} Errno
  = Errno NHC.FFI.CInt;
interface ! Foreign.C.String
{-# NEED peekCString #-}
peekCString{-# 0 #-}::(Foreign.C.String.CString -> (NHC.Internal.IO Prelude.String));

{-# NEED peekCStringLen #-}
peekCStringLen{-# 0 #-}::(Foreign.C.String.CStringLen -> (NHC.Internal.IO Prelude.String));

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

{-# NEED newCStringLen #-}
newCStringLen{-# 0 #-}::(Prelude.String -> (NHC.Internal.IO Foreign.C.String.CStringLen));

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

{-# NEED withCStringLen #-}
withCStringLen{-# 0 #-}::(Prelude.String -> ((Foreign.C.String.CStringLen -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)));

{-# NEED charIsRepresentable #-}
charIsRepresentable{-# 1 #-}::(Prelude.Char -> (NHC.Internal.IO Prelude.Bool));

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

{-# NEED castCharToCChar #-}
castCharToCChar{-# 1 #-}::(Prelude.Char -> NHC.FFI.CChar);

{-# NEED peekCAString #-}
peekCAString{-# 1 #-}::(Foreign.C.String.CString -> (NHC.Internal.IO Prelude.String));

{-# NEED peekCAStringLen #-}
peekCAStringLen{-# 1 #-}::(Foreign.C.String.CStringLen -> (NHC.Internal.IO Prelude.String));

{-# NEED newCAString #-}
newCAString{-# 0 #-}::(Prelude.String -> (NHC.Internal.IO Foreign.C.String.CString));

{-# NEED newCAStringLen #-}
newCAStringLen{-# 1 #-}::(Prelude.String -> (NHC.Internal.IO Foreign.C.String.CStringLen));

{-# NEED withCAString #-}
withCAString{-# 0 #-}::(Prelude.String -> ((Foreign.C.String.CString -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)));

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

{-# NEED withCAStringLen #-}
withCAStringLen{-# 2 #-}::(Prelude.String -> ((Foreign.C.String.CStringLen -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)));

{-# NEED CStringLen #-}
type {-# 2 #-} CStringLen = ((NHC.FFI.Ptr NHC.FFI.CChar),Prelude.Int);
interface ! NHC.FFI
{-# NEED {CChar CChar} #-}
newtype {-#  #-} CChar
  = CChar NHC.FFI.Int8;
interface ! Foreign.C.String
{-# NEED peekCWString #-}
peekCWString{-# 1 #-}::(Foreign.C.String.CWString -> (NHC.Internal.IO Prelude.String));

{-# NEED peekCWStringLen #-}
peekCWStringLen{-# 1 #-}::(Foreign.C.String.CWStringLen -> (NHC.Internal.IO Prelude.String));

{-# NEED newCWString #-}
newCWString{-# 0 #-}::(Prelude.String -> (NHC.Internal.IO Foreign.C.String.CWString));

{-# NEED newCWStringLen #-}
newCWStringLen{-# 1 #-}::(Prelude.String -> (NHC.Internal.IO Foreign.C.String.CWStringLen));

{-# NEED withCWString #-}
withCWString{-# 0 #-}::(Prelude.String -> ((Foreign.C.String.CWString -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)));

{-# NEED CWString #-}
type {-# 3 #-} CWString = (NHC.FFI.Ptr NHC.FFI.CWchar);

{-# NEED withCWStringLen #-}
withCWStringLen{-# 2 #-}::(Prelude.String -> ((Foreign.C.String.CWStringLen -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Foreign.C.String
{-# NEED CWStringLen #-}
type {-# 4 #-} CWStringLen = ((NHC.FFI.Ptr NHC.FFI.CWchar),Prelude.Int);
interface ! NHC.FFI
{-# NEED {CWchar CWchar} #-}
newtype {-#  #-} CWchar
  = CWchar NHC.FFI.CInt;
interface NHC.FFI
{-# NEED Ptr #-}
data Ptr a;
interface ! NHC.FFI
{-# NEED {CPtrdiff CPtrdiff} #-}
newtype {-#  #-} CPtrdiff
  = CPtrdiff NHC.FFI.CInt;

{-# NEED {CSigAtomic CSigAtomic} #-}
newtype {-#  #-} CSigAtomic
  = CSigAtomic NHC.FFI.CInt;

{-# NEED {CSize CSize} #-}
newtype {-#  #-} CSize
  = CSize NHC.FFI.CInt;

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

{-# NEED {CULLong CULLong} #-}
newtype {-#  #-} CULLong
  = CULLong NHC.FFI.Word64;
interface NHC.FFI
{-# NEED Word64 #-}
data Word64;
interface ! NHC.FFI
{-# NEED {CLLong CLLong} #-}
newtype {-#  #-} CLLong
  = CLLong NHC.FFI.Int64;
interface NHC.FFI
{-# NEED Int64 #-}
data Int64;
interface ! NHC.FFI
{-# NEED {CULong CULong} #-}
newtype {-#  #-} CULong
  = CULong NHC.FFI.Word32;

{-# NEED {CLong CLong} #-}
newtype {-#  #-} CLong
  = CLong NHC.FFI.Int32;
interface NHC.FFI
{-# NEED Int32 #-}
data Int32;
interface ! NHC.FFI
{-# NEED {CUShort CUShort} #-}
newtype {-#  #-} CUShort
  = CUShort NHC.FFI.Word16;
interface NHC.FFI
{-# NEED Word16 #-}
data Word16;
interface ! NHC.FFI
{-# NEED {CShort CShort} #-}
newtype {-#  #-} CShort
  = CShort NHC.FFI.Int16;
interface NHC.FFI
{-# NEED Int16 #-}
data Int16;
interface ! NHC.FFI
{-# NEED {CUChar CUChar} #-}
newtype {-#  #-} CUChar
  = CUChar NHC.FFI.Word8;
interface NHC.FFI
{-# NEED Word8 #-}
data Word8;
interface ! NHC.FFI
{-# NEED {CSChar CSChar} #-}
newtype {-#  #-} CSChar
  = CSChar NHC.FFI.Int8;
interface NHC.FFI
{-# NEED Int8 #-}
data Int8;
interface ! NHC.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 {CClock CClock} #-}
newtype {-#  #-} CClock
  = CClock NHC.FFI.CUInt;

{-# NEED {CTime CTime} #-}
newtype {-#  #-} CTime
  = CTime NHC.FFI.CUInt;

{-# NEED {CUInt CUInt} #-}
newtype {-#  #-} CUInt
  = CUInt NHC.FFI.Word32;
interface NHC.FFI
{-# NEED Word32 #-}
data Word32;
}