interface Distribution.Simple.Utils where {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CIno;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CMode;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.COff;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CPid;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CGid;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CUid;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Data.Bits.Bits NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CDev;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CCc;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CIno;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CMode;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.COff;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CPid;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CSsize;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CGid;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CNlink;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CUid;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.CRLim;

{-# NEED #-}
instance NHC.FFI.Storable NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.FFI.ForeignPtr 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 NHC.FFI.Int64;

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CDev;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CCc;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CIno;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CMode;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.COff;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CPid;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CGid;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CUid;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Bounded NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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.Num NHC.FFI.Int64;

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CDev;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CCc;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Num NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CDev;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CCc;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Real NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Read Directory.Permissions;

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CDev;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CCc;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Read NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Ord Distribution.Verbosity.Verbosity;

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

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

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

{-# NEED #-}
instance Prelude.Ord Time.ClockTime;

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

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

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

{-# NEED #-}
instance Prelude.Ord Directory.Permissions;

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CDev;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CCc;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Ord NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CDev;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CCc;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Enum NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Integral NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Distribution.Verbosity.Verbosity;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Time.ClockTime;

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Directory.Permissions;

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CDev;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CCc;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Eq NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show Data.Dynamic.Dynamic;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show Time.ClockTime;

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show Directory.Permissions;

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CDev;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CCc;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CSpeed;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CIno;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CMode;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.COff;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CPid;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CSsize;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CGid;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CNlink;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CUid;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CTcflag;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.CRLim;

{-# NEED #-}
instance Prelude.Show NHC.PosixTypes.Fd;

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show IO.Handle;
interface NHC.FFI
{-# NEED StablePtr #-}
data StablePtr 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.Dynamic
{-# NEED Dynamic #-}
data Dynamic;
interface Data.Typeable
{-# NEED TypeRep #-}
data TypeRep;

{-# NEED TyCon #-}
data TyCon;
interface Data.HashTable
{-# NEED HashData #-}
data HashData;
interface IO
{-# NEED HandlePosn #-}
data HandlePosn;
interface NHC.DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface NHC.FFI
{-# NEED Ptr #-}
data Ptr a;

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

{-# NEED FunPtr #-}
data FunPtr a;
interface Time
{-# NEED ClockTime #-}
data ClockTime;
interface IO
{-# NEED IOMode #-}
data IOMode;
interface Array
{-# NEED Array #-}
data (Ix.Ix a) => Array a b;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface IO
{-# NEED SeekMode #-}
data SeekMode;

{-# NEED BufferMode #-}
data BufferMode;
interface Directory
{-# NEED Permissions #-}
data Permissions;
interface NHC.FFI
{-# NEED Int64 #-}
data Int64;

{-# NEED Word16 #-}
data Word16;

{-# NEED Word8 #-}
data Word8;

{-# NEED Word64 #-}
data Word64;

{-# NEED Int8 #-}
data Int8;

{-# NEED Int16 #-}
data Int16;

{-# NEED Word32 #-}
data Word32;

{-# NEED Int32 #-}
data Int32;
interface NHC.PosixTypes
{-# NEED CDev #-}
newtype {-#  #-} CDev;

{-# NEED CCc #-}
newtype {-#  #-} CCc;

{-# NEED CSpeed #-}
newtype {-#  #-} CSpeed;

{-# NEED CIno #-}
newtype {-#  #-} CIno;

{-# NEED CMode #-}
newtype {-#  #-} CMode;

{-# NEED COff #-}
newtype {-#  #-} COff;

{-# NEED CPid #-}
newtype {-#  #-} CPid;

{-# NEED CSsize #-}
newtype {-#  #-} CSsize;

{-# NEED CGid #-}
newtype {-#  #-} CGid;

{-# NEED CNlink #-}
newtype {-#  #-} CNlink;

{-# NEED CUid #-}
newtype {-#  #-} CUid;

{-# NEED CTcflag #-}
newtype {-#  #-} CTcflag;

{-# NEED CRLim #-}
newtype {-#  #-} CRLim;

{-# NEED Fd #-}
newtype {-#  #-} Fd;
interface NHC.FFI
{-# NEED CChar #-}
newtype {-#  #-} CChar;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED CTime #-}
newtype {-#  #-} CTime;

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

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

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

{-# NEED CLDouble #-}
newtype {-#  #-} CLDouble;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface ! Distribution.Simple.Utils
{-# NEED dllExtension #-}
dllExtension{-# 0 #-}::Prelude.String;

{-# NEED objExtension #-}
objExtension{-# 0 #-}::Prelude.String;

{-# NEED exeExtension #-}
exeExtension{-# 0 #-}::Prelude.String;

{-# NEED findHookedPackageDesc #-}
findHookedPackageDesc{-# 1 #-}::(Prelude.FilePath -> (NHC.Internal.IO (Prelude.Maybe Prelude.FilePath)));

{-# NEED defaultHookedPackageDesc #-}
defaultHookedPackageDesc{-# 0 #-}::(NHC.Internal.IO (Prelude.Maybe Prelude.FilePath));

{-# NEED findPackageDesc #-}
findPackageDesc{-# 2 #-}::(Distribution.Verbosity.Verbosity -> (Prelude.FilePath -> (NHC.Internal.IO Prelude.FilePath)));

{-# NEED defaultPackageDesc #-}
defaultPackageDesc{-# 1 #-}::(Distribution.Verbosity.Verbosity -> (NHC.Internal.IO Prelude.FilePath));

{-# NEED matchesDescFile #-}
matchesDescFile{-# 1 #-}::(Prelude.FilePath -> Prelude.Bool);

{-# NEED mkProfLibName #-}
mkProfLibName{-# 2 #-}::(Prelude.FilePath -> (Prelude.String -> Prelude.String));

{-# NEED mkLibName #-}
mkLibName{-# 2 #-}::(Prelude.FilePath -> (Prelude.String -> Prelude.String));

{-# NEED currentDir #-}
currentDir{-# 0 #-}::Prelude.FilePath;

{-# NEED copyDirectoryRecursiveVerbose #-}
copyDirectoryRecursiveVerbose{-# 3 #-}::(Distribution.Verbosity.Verbosity -> (Prelude.FilePath -> (Prelude.FilePath -> (NHC.Internal.IO ()))));

{-# NEED copyFileVerbose #-}
copyFileVerbose{-# 3 #-}::(Distribution.Verbosity.Verbosity -> (Prelude.FilePath -> (Prelude.FilePath -> (NHC.Internal.IO ()))));

{-# NEED createDirectoryIfMissingVerbose #-}
createDirectoryIfMissingVerbose{-# 3 #-}::(Distribution.Verbosity.Verbosity -> (Prelude.Bool -> (Prelude.FilePath -> (NHC.Internal.IO ()))));

{-# NEED smartCopySources #-}
smartCopySources{-# 7 #-}::(Distribution.Verbosity.Verbosity -> ([Prelude.FilePath] -> (Prelude.FilePath -> ([Prelude.String] -> ([Prelude.String] -> (Prelude.Bool -> (Prelude.Bool -> (NHC.Internal.IO ()))))))));

{-# NEED dotToSep #-}
dotToSep{-# 0 #-}::(Prelude.String -> Prelude.String);

{-# NEED findFile #-}
findFile{-# 2 #-}::([Prelude.FilePath] -> (Prelude.FilePath -> (NHC.Internal.IO Prelude.FilePath)));

{-# NEED moduleToFilePath2 #-}
moduleToFilePath2{-# 3 #-}::([Prelude.FilePath] -> (Prelude.String -> ([Prelude.String] -> (NHC.Internal.IO [(Prelude.FilePath,Prelude.FilePath)]))));

{-# NEED moduleToFilePath #-}
moduleToFilePath{-# 3 #-}::([Prelude.FilePath] -> (Prelude.String -> ([Prelude.String] -> (NHC.Internal.IO [Prelude.FilePath]))));

{-# NEED xargs #-}
xargs{-# 5 #-}::(Prelude.Int -> ((a -> ([Prelude.String] -> (NHC.Internal.IO ()))) -> (a -> ([Prelude.String] -> ([Prelude.String] -> (NHC.Internal.IO ()))))));

{-# NEED rawSystemStdout #-}
rawSystemStdout{-# 3 #-}::(Distribution.Verbosity.Verbosity -> (Prelude.FilePath -> ([Prelude.String] -> (NHC.Internal.IO Prelude.String))));

{-# NEED rawSystemPathExit #-}
rawSystemPathExit{-# 3 #-}::(Distribution.Verbosity.Verbosity -> (Prelude.String -> ([Prelude.String] -> (NHC.Internal.IO ()))));

{-# NEED rawSystemExit #-}
rawSystemExit{-# 3 #-}::(Distribution.Verbosity.Verbosity -> (Prelude.FilePath -> ([Prelude.String] -> (NHC.Internal.IO ()))));

{-# NEED maybeExit #-}
maybeExit{-# 1 #-}::((NHC.Internal.IO System.ExitCode) -> (NHC.Internal.IO ()));
interface System
{-# NEED ExitCode #-}
data ExitCode;
interface ! Distribution.Simple.Utils
{-# NEED warn #-}
warn{-# 2 #-}::(Distribution.Verbosity.Verbosity -> (Prelude.String -> (NHC.Internal.IO ())));
interface Distribution.Verbosity
{-# NEED Verbosity #-}
data Verbosity;
interface ! Distribution.Simple.Utils
{-# NEED die #-}
die{-# 1 #-}::(Prelude.String -> (NHC.Internal.IO a));

{-# NEED dieWithLocation #-}
dieWithLocation{-# 3 #-}::(Prelude.FilePath -> ((Prelude.Maybe Prelude.Int) -> (Prelude.String -> (NHC.Internal.IO a))));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
}