interface Distribution.ParseUtils where {

{-# NEED #-}
instance Distribution.Package.Package Distribution.Package.PackageIdentifier;

{-# NEED #-}
instance Control.Monad.Fix.MonadFix NHC.Internal.IO;

{-# NEED #-}
instance Data.Traversable.Traversable (Data.Map.Map a);

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.Elem;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.Node;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.Digit;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.FingerTree;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.Seq;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.ViewR;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.ViewL;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Tree.Tree;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Set.Set;

{-# NEED #-}
instance Data.Foldable.Foldable (Data.Map.Map a);

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.Elem;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.Node;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.Digit;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.FingerTree;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.Seq;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.ViewR;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.ViewL;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Tree.Tree;

{-# NEED #-}
instance Data.Typeable.Typeable2 NHC.IOExtras.IOArray;

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

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

{-# NEED #-}
instance (Control.Arrow.ArrowZero a,Control.Arrow.ArrowPlus a) => Control.Applicative.Alternative (Control.Applicative.WrappedArrow a b);

{-# NEED #-}
instance (Control.Monad.MonadPlus a) => Control.Applicative.Alternative (Control.Applicative.WrappedMonad a);

{-# NEED #-}
instance Control.Applicative.Applicative Data.Traversable.Id;

{-# NEED #-}
instance Control.Applicative.Applicative Control.Applicative.ZipList;

{-# NEED #-}
instance (Control.Arrow.Arrow a) => Control.Applicative.Applicative (Control.Applicative.WrappedArrow a b);

{-# NEED #-}
instance (Prelude.Monad a) => Control.Applicative.Applicative (Control.Applicative.WrappedMonad a);

{-# NEED #-}
instance (Data.Monoid.Monoid a) => Control.Applicative.Applicative (Control.Applicative.Const a);

{-# NEED #-}
instance Control.Applicative.Applicative Data.Tree.Tree;

{-# NEED #-}
instance Control.Applicative.Applicative NHC.Internal.IO;

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

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

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

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

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

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

{-# 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.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.Bits.Bits NHC.FFI.CChar;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Typeable.Typeable1 Data.Sequence.Seq;

{-# NEED #-}
instance Data.Typeable.Typeable1 Data.Sequence.ViewR;

{-# NEED #-}
instance Data.Typeable.Typeable1 Data.Sequence.ViewL;

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

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

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

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.IOExtras.IORef;

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

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

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

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

{-# 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 Control.Exception.Base.Exception Prelude.IOError;

{-# NEED #-}
instance Control.Exception.Base.Exception Control.Exception.Base.SomeException;

{-# NEED #-}
instance Control.Exception.Base.Exception System.ExitCode;

{-# NEED #-}
instance Distribution.Text.Text Distribution.Compiler.CompilerFlavor;

{-# NEED #-}
instance Distribution.Text.Text Distribution.Compiler.CompilerId;

{-# NEED #-}
instance Distribution.Text.Text Distribution.Version.VersionWildcard;

{-# NEED #-}
instance Distribution.Text.Text Language.Haskell.Extension.Extension;

{-# NEED #-}
instance Distribution.Text.Text Distribution.License.License;

{-# NEED #-}
instance Distribution.Text.Text Distribution.ModuleName.ModuleName;

{-# NEED #-}
instance Distribution.Text.Text Distribution.Version.VersionRange;

{-# NEED #-}
instance Distribution.Text.Text Distribution.Package.PackageName;

{-# NEED #-}
instance Distribution.Text.Text Distribution.Package.PackageIdentifier;

{-# NEED #-}
instance Distribution.Text.Text Distribution.Package.Dependency;

{-# NEED #-}
instance Distribution.Text.Text Data.Version.Version;

{-# NEED #-}
instance Distribution.Text.Text Prelude.Bool;

{-# NEED #-}
instance Control.Category.Category ( (->) a);

{-# NEED #-}
instance Control.Category.Category (Prelude.Monad a);

{-# NEED #-}
instance Data.Monoid.Monoid (Data.Monoid.Endo a);

{-# NEED #-}
instance (Prelude.Ord a) => Data.Monoid.Monoid (Data.Set.Set a);

{-# NEED #-}
instance (Prelude.Ord a) => Data.Monoid.Monoid (Data.Map.Map a b);

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

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

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

{-# NEED #-}
instance (Prelude.Num a) => Data.Monoid.Monoid (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Num a) => Data.Monoid.Monoid (Data.Monoid.Sum a);

{-# NEED #-}
instance Data.Monoid.Monoid Data.Monoid.Any;

{-# NEED #-}
instance Data.Monoid.Monoid Data.Monoid.All;

{-# NEED #-}
instance (Data.Monoid.Monoid a) => Data.Monoid.Monoid (Data.Monoid.Dual a);

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

{-# NEED #-}
instance Data.Monoid.Monoid (Data.Sequence.Seq a);

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

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

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

{-# NEED #-}
instance Data.Monoid.Monoid [a];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Bounded a) => Prelude.Bounded (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Bounded a) => Prelude.Bounded (Data.Monoid.Sum a);

{-# NEED #-}
instance Prelude.Bounded Data.Monoid.Any;

{-# NEED #-}
instance Prelude.Bounded Data.Monoid.All;

{-# NEED #-}
instance (Prelude.Bounded a) => Prelude.Bounded (Data.Monoid.Dual a);

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Sequence.Sized (Data.Sequence.Elem a);

{-# NEED #-}
instance Data.Sequence.Sized (Data.Sequence.Node a);

{-# NEED #-}
instance (Data.Sequence.Sized a) => Data.Sequence.Sized (Data.Sequence.Digit a);

{-# NEED #-}
instance (Data.Sequence.Sized a) => Data.Sequence.Sized (Data.Sequence.FingerTree a);

{-# NEED #-}
instance Control.Arrow.ArrowApply ( (->) a);

{-# NEED #-}
instance Control.Arrow.ArrowApply (Prelude.Monad a);

{-# NEED #-}
instance Control.Arrow.Arrow ( (->) a);

{-# NEED #-}
instance Control.Arrow.Arrow (Prelude.Monad a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Control.Monad.MonadPlus (Text.ParserCombinators.ReadP.ReadPN a);

{-# NEED #-}
instance Control.Monad.MonadPlus Text.ParserCombinators.ReadP.P;

{-# NEED #-}
instance Control.Monad.MonadPlus Data.Sequence.Seq;

{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.Maybe;

{-# NEED #-}
instance Control.Monad.MonadPlus (Distribution.Compat.ReadP.P a);

{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.[];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Read Distribution.Compiler.CompilerId;

{-# NEED #-}
instance (Prelude.Read a,Prelude.Ord a) => Prelude.Read (Data.Set.Set a);

{-# NEED #-}
instance (Prelude.Ord a,Prelude.Read a,Prelude.Read b) => Prelude.Read (Data.Map.Map a b);

{-# NEED #-}
instance Prelude.Read Language.Haskell.Extension.Extension;

{-# NEED #-}
instance Prelude.Read Distribution.License.License;

{-# NEED #-}
instance Prelude.Read System.ExitCode;

{-# NEED #-}
instance Prelude.Read Distribution.ModuleName.ModuleName;

{-# NEED #-}
instance Prelude.Read Distribution.Version.VersionRange;

{-# NEED #-}
instance Prelude.Read Distribution.Package.PackageName;

{-# NEED #-}
instance Prelude.Read Distribution.Package.PackageIdentifier;

{-# NEED #-}
instance Prelude.Read Distribution.Package.Dependency;

{-# NEED #-}
instance Prelude.Read Data.Version.Version;

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Monoid.Sum a);

{-# NEED #-}
instance Prelude.Read Data.Monoid.Any;

{-# NEED #-}
instance Prelude.Read Data.Monoid.All;

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Monoid.Dual a);

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Sequence.Seq a);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Sequence.ViewR a);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Sequence.ViewL a);

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

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Tree.Tree a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Ord Distribution.Compiler.CompilerId;

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Set.Set a);

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

{-# NEED #-}
instance Prelude.Ord System.ExitCode;

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

{-# NEED #-}
instance Prelude.Ord Distribution.Package.PackageName;

{-# NEED #-}
instance Prelude.Ord Distribution.Package.PackageIdentifier;

{-# NEED #-}
instance Prelude.Ord Data.Version.Version;

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

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Monoid.Sum a);

{-# NEED #-}
instance Prelude.Ord Data.Monoid.Any;

{-# NEED #-}
instance Prelude.Ord Data.Monoid.All;

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Monoid.Dual a);

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Sequence.Seq a);

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Sequence.ViewR a);

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Sequence.ViewL a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Distribution.Compiler.CompilerId;

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Set.Set a);

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

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Extension.Extension;

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

{-# NEED #-}
instance Prelude.Eq System.ExitCode;

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

{-# NEED #-}
instance Prelude.Eq Distribution.Version.VersionRange;

{-# NEED #-}
instance Prelude.Eq Distribution.Package.PackageName;

{-# NEED #-}
instance Prelude.Eq Distribution.Package.PackageIdentifier;

{-# NEED #-}
instance Prelude.Eq Distribution.Package.Dependency;

{-# NEED #-}
instance Prelude.Eq Data.Version.Version;

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

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

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

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

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Monoid.Sum a);

{-# NEED #-}
instance Prelude.Eq Data.Monoid.Any;

{-# NEED #-}
instance Prelude.Eq Data.Monoid.All;

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Monoid.Dual a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Sequence.Seq a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Sequence.ViewR a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Sequence.ViewL a);

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

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

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

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Tree.Tree a);

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

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

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

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

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

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

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

{-# 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.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.Integral NHC.FFI.CChar;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Typeable.Typeable Control.Exception.Base.SomeException;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (Data.Sequence.ViewL 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.FunPtr a);

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable [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 (Prelude.Either a b);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show Distribution.Compiler.CompilerId;

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Set.Set a);

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

{-# NEED #-}
instance Prelude.Show Language.Haskell.Extension.Extension;

{-# NEED #-}
instance Prelude.Show Distribution.License.License;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.ArithException;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.ArrayException;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.AsyncException;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.AssertionFailed;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.PatternMatchFail;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.NoMethodError;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.Deadlock;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.BlockedOnDeadMVar;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.BlockedIndefinitely;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.ErrorCall;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.RecConError;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.RecSelError;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.RecUpdError;

{-# NEED #-}
instance Prelude.Show Control.Exception.Base.SomeException;

{-# NEED #-}
instance Prelude.Show System.ExitCode;

{-# NEED #-}
instance Prelude.Show Distribution.ModuleName.ModuleName;

{-# NEED #-}
instance Prelude.Show Distribution.Version.VersionRange;

{-# NEED #-}
instance Prelude.Show Distribution.Package.PackageName;

{-# NEED #-}
instance Prelude.Show Distribution.Package.PackageIdentifier;

{-# NEED #-}
instance Prelude.Show Distribution.Package.Dependency;

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Monoid.Sum a);

{-# NEED #-}
instance Prelude.Show Data.Monoid.Any;

{-# NEED #-}
instance Prelude.Show Data.Monoid.All;

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Monoid.Dual a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Sequence.Seq a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Sequence.ViewR a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Sequence.ViewL a);

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

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

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Tree.Tree a);

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

{-# NEED #-}
instance Prelude.Show Text.PrettyPrint.HughesPJ.Doc;

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

{-# NEED #-}
instance Prelude.Functor (Data.Map.Map a);

{-# NEED #-}
instance Prelude.Functor (Text.ParserCombinators.ReadP.ReadPN a);

{-# NEED #-}
instance Prelude.Functor Data.Sequence.Elem;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.Node;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.Digit;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.FingerTree;

{-# NEED #-}
instance Prelude.Functor Data.Traversable.Id;

{-# NEED #-}
instance Prelude.Functor Control.Applicative.ZipList;

{-# NEED #-}
instance (Control.Arrow.Arrow a) => Prelude.Functor (Control.Applicative.WrappedArrow a b);

{-# NEED #-}
instance (Prelude.Monad a) => Prelude.Functor (Control.Applicative.WrappedMonad a);

{-# NEED #-}
instance Prelude.Functor (Control.Applicative.Const a);

{-# NEED #-}
instance Prelude.Functor Data.Sequence.Seq;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.ViewR;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.ViewL;

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

{-# NEED #-}
instance Prelude.Functor Data.Tree.Tree;

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

{-# NEED #-}
instance Prelude.Functor Distribution.ReadE.ReadE;

{-# NEED #-}
instance Prelude.Functor (Distribution.Compat.ReadP.Parser a b);

{-# NEED #-}
instance Prelude.Monad ParseResult;

{-# NEED #-}
instance Prelude.Monad (Text.ParserCombinators.ReadP.ReadPN a);

{-# NEED #-}
instance Prelude.Monad Text.ParserCombinators.ReadP.P;

{-# NEED #-}
instance (Control.Arrow.ArrowApply a) => Prelude.Monad (Control.Arrow.ArrowMonad a);

{-# NEED #-}
instance Prelude.Monad Data.Sequence.Seq;

{-# NEED #-}
instance Prelude.Monad Data.Tree.Tree;

{-# NEED #-}
instance Prelude.Monad (Distribution.Compat.ReadP.P a);

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

{-# NEED #-}
instance Prelude.Monad (Distribution.Compat.ReadP.Parser a b);
interface Control.Arrow
{-# NEED ArrowPlus #-}
class (Control.Arrow.ArrowZero a) => ArrowPlus a;

{-# NEED ArrowZero #-}
class (Control.Arrow.Arrow a) => ArrowZero a;
interface Control.Monad
{-# NEED MonadPlus #-}
class (Prelude.Monad a) => MonadPlus a;
interface Distribution.Version
{-# NEED VersionWildcard #-}
newtype {-#  #-} VersionWildcard;
interface Data.Monoid
{-# NEED Endo #-}
newtype {-#  #-} Endo a;

{-# NEED Monoid #-}
class Monoid a;
interface Data.Sequence
{-# NEED Sized #-}
class Sized a;
interface Data.Typeable
{-# NEED KeyPr #-}
data KeyPr;

{-# NEED Key #-}
newtype {-#  #-} Key;
interface Data.HashTable
{-# NEED Inserts #-}
data Inserts;
interface NHC.IOExtras
{-# NEED IOArray #-}
data (Ix.Ix a) => IOArray a b;

{-# NEED IORef #-}
newtype {-#  #-} IORef a;
interface NHC.FFI
{-# NEED StablePtr #-}
data StablePtr a;
interface Data.Typeable
{-# NEED Typeable #-}
class Typeable a;
interface NHC.DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface Time
{-# NEED ClockTime #-}
data ClockTime;
interface Directory
{-# NEED Permissions #-}
data Permissions;
interface Distribution.Verbosity
{-# NEED Verbosity #-}
data Verbosity;
interface NHC.FFI
{-# NEED CClock #-}
newtype {-#  #-} CClock;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED CDev #-}
newtype {-#  #-} CDev;
interface NHC.FFI
{-# NEED CLDouble #-}
newtype {-#  #-} CLDouble;

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

{-# NEED CFloat #-}
newtype {-#  #-} CFloat;
interface Distribution.Compiler
{-# NEED CompilerId #-}
data CompilerId;
interface Data.Set
{-# NEED Set #-}
data Set a;
interface Control.Exception.Base
{-# NEED ArithException #-}
data ArithException;

{-# NEED ArrayException #-}
data ArrayException;

{-# NEED AsyncException #-}
data AsyncException;

{-# NEED AssertionFailed #-}
data AssertionFailed;

{-# NEED PatternMatchFail #-}
data PatternMatchFail;

{-# NEED NoMethodError #-}
data NoMethodError;

{-# NEED Deadlock #-}
data Deadlock;

{-# NEED BlockedOnDeadMVar #-}
data BlockedOnDeadMVar;

{-# NEED BlockedIndefinitely #-}
data BlockedIndefinitely;

{-# NEED ErrorCall #-}
data ErrorCall;

{-# NEED RecConError #-}
data RecConError;

{-# NEED RecSelError #-}
data RecSelError;

{-# NEED RecUpdError #-}
data RecUpdError;

{-# NEED SomeException #-}
data SomeException;
interface System
{-# NEED ExitCode #-}
data ExitCode;
interface Distribution.Package
{-# NEED PackageIdentifier #-}
data PackageIdentifier;
interface IO
{-# NEED HandlePosn #-}
data HandlePosn;
interface Data.HashTable
{-# NEED HashData #-}
data HashData;
interface NHC.FFI
{-# NEED ForeignPtr #-}
data ForeignPtr a;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface Data.Monoid
{-# NEED Product #-}
newtype {-#  #-} Product a;

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

{-# NEED Any #-}
newtype {-#  #-} Any;

{-# NEED All #-}
newtype {-#  #-} All;

{-# NEED Dual #-}
newtype {-#  #-} Dual a;
interface IO
{-# NEED BufferMode #-}
data BufferMode;

{-# NEED SeekMode #-}
data SeekMode;

{-# NEED IOMode #-}
data IOMode;
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface NHC.FFI
{-# NEED CInt #-}
newtype {-#  #-} CInt;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface NHC.FFI
{-# NEED Int64 #-}
data Int64;

{-# NEED Int32 #-}
data Int32;

{-# NEED Int16 #-}
data Int16;

{-# NEED Int8 #-}
data Int8;

{-# NEED Word8 #-}
data Word8;

{-# NEED Word16 #-}
data Word16;

{-# NEED Word32 #-}
data Word32;

{-# NEED Word64 #-}
data Word64;
interface Data.Typeable
{-# NEED TypeRep #-}
data TypeRep;

{-# NEED TyCon #-}
data TyCon;
interface NHC.FFI
{-# NEED FunPtr #-}
data FunPtr a;

{-# NEED Ptr #-}
data Ptr a;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface Data.Map
{-# NEED Map #-}
data Map a b;
interface Data.Sequence
{-# NEED Elem #-}
newtype {-#  #-} Elem a;

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

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

{-# NEED FingerTree #-}
data FingerTree a;
interface Data.Traversable
{-# NEED Id #-}
newtype {-#  #-} Id a;
interface Control.Applicative
{-# NEED ZipList #-}
newtype {-#  #-} ZipList a;

{-# NEED WrappedArrow #-}
newtype {-#  #-} WrappedArrow a b c;

{-# NEED WrappedMonad #-}
newtype {-#  #-} WrappedMonad a b;

{-# NEED Const #-}
newtype {-#  #-} Const a b;
interface Data.Sequence
{-# NEED ViewR #-}
data ViewR a;

{-# NEED ViewL #-}
data ViewL a;
interface Array
{-# NEED Array #-}
data (Ix.Ix a) => Array a b;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface Text.ParserCombinators.ReadP
{-# NEED ReadPN #-}
newtype {-#  #-} ReadPN a b;

{-# NEED P #-}
data P a;
interface Control.Arrow
{-# NEED ArrowMonad #-}
newtype {-#  #-} (Control.Arrow.ArrowApply a) => ArrowMonad a b;

{-# NEED ArrowApply #-}
class (Control.Arrow.Arrow a) => ArrowApply a;

{-# NEED Arrow #-}
class (Control.Category.Category a) => Arrow a;
interface Control.Category
{-# NEED Category #-}
class Category a;
interface Data.Sequence
{-# NEED Seq #-}
newtype {-#  #-} Seq a;
interface Data.Tree
{-# NEED Tree Forest #-}
data Tree a;
type {-# 1 #-} Forest a = [(Data.Tree.Tree a)];
interface Distribution.Compat.ReadP
{-# NEED P #-}
data P a b;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Distribution.ParseUtils
{-# NEED showFreeText #-}
showFreeText{-# 1 #-}::(Prelude.String -> Text.PrettyPrint.HughesPJ.Doc);

{-# NEED showTestedWith #-}
showTestedWith{-# 1 #-}::((Distribution.Compiler.CompilerFlavor,Distribution.Version.VersionRange) -> Text.PrettyPrint.HughesPJ.Doc);

{-# NEED showToken #-}
showToken{-# 1 #-}::(Prelude.String -> Text.PrettyPrint.HughesPJ.Doc);

{-# NEED showFilePath #-}
showFilePath{-# 0 #-}::(Prelude.FilePath -> Text.PrettyPrint.HughesPJ.Doc);

{-# NEED parseFreeText #-}
parseFreeText{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Prelude.String);

{-# NEED parseQuoted #-}
parseQuoted{-# 1 #-}::((Distribution.Compat.ReadP.ReadP a b) -> (Distribution.Compat.ReadP.ReadP a b));

{-# NEED parseOptCommaList #-}
parseOptCommaList{-# 0 #-}::((Distribution.Compat.ReadP.ReadP a b) -> (Distribution.Compat.ReadP.ReadP a [b]));

{-# NEED parseCommaList #-}
parseCommaList{-# 0 #-}::((Distribution.Compat.ReadP.ReadP a b) -> (Distribution.Compat.ReadP.ReadP a [b]));

{-# NEED parseSepList #-}
parseSepList{-# 2 #-}::((Distribution.Compat.ReadP.ReadP a b) -> ((Distribution.Compat.ReadP.ReadP a c) -> (Distribution.Compat.ReadP.ReadP a [c])));

{-# NEED parseTokenQ #-}
parseTokenQ{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Prelude.String);

{-# NEED parseExtensionQ #-}
parseExtensionQ{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Language.Haskell.Extension.Extension);
interface Language.Haskell.Extension
{-# NEED Extension #-}
data Extension;
interface ! Distribution.ParseUtils
{-# NEED parseLicenseQ #-}
parseLicenseQ{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Distribution.License.License);
interface Distribution.License
{-# NEED License #-}
data License;
interface ! Distribution.ParseUtils
{-# NEED parseTestedWithQ #-}
parseTestedWithQ{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a (Distribution.Compiler.CompilerFlavor,Distribution.Version.VersionRange));

{-# NEED parseOptVersion #-}
parseOptVersion{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Data.Version.Version);

{-# NEED parseVersionRangeQ #-}
parseVersionRangeQ{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Distribution.Version.VersionRange);

{-# NEED parsePackageNameQ #-}
parsePackageNameQ{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Distribution.Package.PackageName);

{-# NEED parsePkgconfigDependency #-}
parsePkgconfigDependency{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Distribution.Package.Dependency);

{-# NEED parseBuildTool #-}
parseBuildTool{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Distribution.Package.Dependency);
interface Distribution.Package
{-# NEED Dependency #-}
data Dependency;
interface Distribution.Version
{-# NEED VersionRange #-}
data VersionRange;
interface Data.Version
{-# NEED Version #-}
data Version;
interface Distribution.Package
{-# NEED PackageName #-}
newtype {-#  #-} PackageName;
interface ! Distribution.ParseUtils
{-# NEED parseFilePathQ #-}
parseFilePathQ{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Prelude.FilePath);

{-# NEED parseModuleNameQ #-}
parseModuleNameQ{-# 0 #-}::(Distribution.Compat.ReadP.ReadP a Distribution.ModuleName.ModuleName);
interface Distribution.ModuleName
{-# NEED ModuleName #-}
newtype {-#  #-} ModuleName;
interface ! Distribution.ParseUtils
{-# NEED readFields #-}
readFields{-# 1 #-}::(Prelude.String -> (ParseResult [Field]));

{-# NEED fName #-}
fName{-# 1 #-}::(Field -> Prelude.String);

{-# NEED lineNo #-}
lineNo{-# 1 #-}::(Field -> LineNo);

{-# NEED {Field F Section IfBlock} #-}
data Field
  = F LineNo Prelude.String Prelude.String
  | Section LineNo Prelude.String Prelude.String [Field]
  | IfBlock LineNo Prelude.String [Field] [Field];

{-# NEED ignoreUnrec #-}
ignoreUnrec{-# 2 #-}::(UnrecFieldParser a);

{-# NEED warnUnrec #-}
warnUnrec{-# 2 #-}::(UnrecFieldParser a);

{-# NEED UnrecFieldParser #-}
type {-# 2 #-} UnrecFieldParser a = ((Prelude.String,Prelude.String) -> (a -> (Prelude.Maybe a)));

{-# NEED parseFields #-}
parseFields{-# 2 #-}::([(FieldDescr a)] -> (a -> (Prelude.String -> (ParseResult a))));

{-# NEED showSingleNamedField #-}
showSingleNamedField{-# 2 #-}::([(FieldDescr a)] -> (Prelude.String -> (Prelude.Maybe (a -> Prelude.String))));

{-# NEED showFields #-}
showFields{-# 1 #-}::([(FieldDescr a)] -> (a -> Prelude.String));

{-# NEED ppField #-}
ppField{-# 2 #-}::(Prelude.String -> (Text.PrettyPrint.HughesPJ.Doc -> Text.PrettyPrint.HughesPJ.Doc));

{-# NEED ppFields #-}
ppFields{-# 2 #-}::([(FieldDescr a)] -> (a -> Text.PrettyPrint.HughesPJ.Doc));

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

{-# NEED optsField #-}
optsField{-# 4 #-}::(Prelude.String -> (Distribution.Compiler.CompilerFlavor -> ((a -> [(Distribution.Compiler.CompilerFlavor,[Prelude.String])]) -> (([(Distribution.Compiler.CompilerFlavor,[Prelude.String])] -> (a -> a)) -> (FieldDescr a)))));
interface Distribution.Compiler
{-# NEED CompilerFlavor #-}
data CompilerFlavor;
interface ! Distribution.ParseUtils
{-# NEED listField #-}
listField{-# 5 #-}::(Prelude.String -> ((a -> Text.PrettyPrint.HughesPJ.Doc) -> ((Distribution.Compat.ReadP.ReadP [a] a) -> ((b -> [a]) -> (([a] -> (b -> b)) -> (FieldDescr b))))));

{-# NEED spaceListField #-}
spaceListField{-# 5 #-}::(Prelude.String -> ((a -> Text.PrettyPrint.HughesPJ.Doc) -> ((Distribution.Compat.ReadP.ReadP [a] a) -> ((b -> [a]) -> (([a] -> (b -> b)) -> (FieldDescr b))))));

{-# NEED commaListField #-}
commaListField{-# 5 #-}::(Prelude.String -> ((a -> Text.PrettyPrint.HughesPJ.Doc) -> ((Distribution.Compat.ReadP.ReadP [a] a) -> ((b -> [a]) -> (([a] -> (b -> b)) -> (FieldDescr b))))));

{-# NEED simpleField #-}
simpleField{-# 5 #-}::(Prelude.String -> ((a -> Text.PrettyPrint.HughesPJ.Doc) -> ((Distribution.Compat.ReadP.ReadP a a) -> ((b -> a) -> ((a -> (b -> b)) -> (FieldDescr b))))));

{-# NEED liftField #-}
liftField{-# 3 #-}::((a -> b) -> ((b -> (a -> a)) -> ((FieldDescr b) -> (FieldDescr a))));

{-# NEED field #-}
field{-# 3 #-}::(Prelude.String -> ((a -> Text.PrettyPrint.HughesPJ.Doc) -> ((Distribution.Compat.ReadP.ReadP a a) -> (FieldDescr a))));

{-# NEED {FieldDescr FieldDescr fieldName fieldGet fieldSet} #-}
data FieldDescr a
  = FieldDescr {fieldName :: Prelude.String} {fieldGet :: (a -> Text.PrettyPrint.HughesPJ.Doc)} {fieldSet :: (LineNo -> (Prelude.String -> (a -> (ParseResult a))))};
interface Text.PrettyPrint.HughesPJ
{-# NEED Doc #-}
data Doc;
interface ! Distribution.ParseUtils
{-# NEED warning #-}
warning{-# 1 #-}::(Prelude.String -> (ParseResult ()));

{-# NEED syntaxError #-}
syntaxError{-# 2 #-}::(LineNo -> (Prelude.String -> (ParseResult a)));

{-# NEED locatedErrorMsg #-}
locatedErrorMsg{-# 1 #-}::(PError -> ((Prelude.Maybe LineNo),Prelude.String));

{-# NEED runE #-}
runE{-# 4 #-}::(LineNo -> (Prelude.String -> ((Distribution.ReadE.ReadE a) -> (Prelude.String -> (ParseResult a)))));
interface Distribution.ReadE
{-# NEED ReadE #-}
newtype {-#  #-} ReadE a;

{-# NEED ErrorMsg #-}
type {-# 2 #-} ErrorMsg = Prelude.String;
interface ! Distribution.ParseUtils
{-# NEED runP #-}
runP{-# 4 #-}::(LineNo -> (Prelude.String -> ((Distribution.Compat.ReadP.ReadP a a) -> (Prelude.String -> (ParseResult a)))));
interface Distribution.Compat.ReadP
{-# NEED ReadP #-}
type {-# 1 #-} ReadP a b = (Distribution.Compat.ReadP.Parser a Prelude.Char b);

{-# NEED Parser #-}
newtype {-#  #-} Parser a b c;
interface ! Distribution.ParseUtils
{-# NEED parseFail #-}
parseFail{-# 0 #-}::(PError -> (ParseResult a));

{-# NEED catchParseError #-}
catchParseError{-# 2 #-}::((ParseResult a) -> ((PError -> (ParseResult a)) -> (ParseResult a)));

{-# NEED {ParseResult ParseFailed ParseOk} #-}
data ParseResult a
  = ParseFailed PError
  | ParseOk [PWarning] a;

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

{-# NEED {PWarning PWarning UTFWarning} #-}
data PWarning
  = PWarning Prelude.String
  | UTFWarning LineNo Prelude.String;

{-# NEED {PError AmbigousParse NoParse TabsError FromString} #-}
data PError
  = AmbigousParse Prelude.String LineNo
  | NoParse Prelude.String LineNo
  | TabsError LineNo
  | FromString Prelude.String (Prelude.Maybe LineNo);

{-# NEED LineNo #-}
type {-# 1 #-} LineNo = Prelude.Int;
}
