interface Text.XML.HaXml where {
infixr  3 Text.XML.HaXml.Combinators.?>;
infixr  3 Text.XML.HaXml.Combinators.:>;
infixr  5 `Text.XML.HaXml.Combinators.o`;
infixr  5 `Text.XML.HaXml.Combinators.union`;
infixr  5 `Text.XML.HaXml.Combinators.andThen`;
infixl  5 Text.XML.HaXml.Combinators.|>|;
infixl  6 `Text.XML.HaXml.Combinators.with`;
infixl  6 `Text.XML.HaXml.Combinators.without`;
infixl  5 Text.XML.HaXml.Combinators./>;
infixl  5 Text.XML.HaXml.Combinators.</;
infixr  4 `Text.XML.HaXml.Combinators.when`;
infixr  4 `Text.XML.HaXml.Combinators.guards`;
infixr  5 `Text.XML.HaXml.Combinators.oo`;

{-# NEED #-}
instance (Text.XML.HaXml.XmlContent.XmlContent a) => Text.XML.HaXml.XmlContent.XmlContent (Text.XML.HaXml.XmlContent.List1 a);

{-# NEED #-}
instance Text.XML.HaXml.XmlContent.XmlContent Text.XML.HaXml.XmlContent.ANYContent;

{-# NEED #-}
instance (Text.XML.HaXml.TypeMapping.HTypeable a) => Text.XML.HaXml.TypeMapping.HTypeable (Text.XML.HaXml.XmlContent.List1 a);

{-# NEED #-}
instance Text.XML.HaXml.TypeMapping.HTypeable Text.XML.HaXml.XmlContent.ANYContent;

{-# NEED #-}
instance Text.ParserCombinators.Poly.Base.PolyParse (Text.ParserCombinators.Poly.NoLeak.Plain.Parser a);

{-# NEED #-}
instance Text.ParserCombinators.Poly.Base.PolyParse (Text.ParserCombinators.Poly.NoLeak.State.Parser a b);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Bits.Bits 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.StablePtr a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.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 (Ix.Ix a) => Data.Traversable.Traversable (Array.Array a);

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

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

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

{-# NEED #-}
instance (Ix.Ix a) => Data.Foldable.Foldable (Array.Array a);

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Text.XML.HaXml.Verbatim.Verbatim a,Text.XML.HaXml.Verbatim.Verbatim b) => Text.XML.HaXml.Verbatim.Verbatim (Prelude.Either a b);

{-# NEED #-}
instance Text.XML.HaXml.Verbatim.Verbatim (Text.XML.HaXml.Types.Element a);

{-# NEED #-}
instance Text.XML.HaXml.Verbatim.Verbatim (Text.XML.HaXml.Types.Content a);

{-# NEED #-}
instance Text.XML.HaXml.Verbatim.Verbatim Prelude.Char;

{-# NEED #-}
instance (Text.XML.HaXml.Verbatim.Verbatim a) => Text.XML.HaXml.Verbatim.Verbatim [a];

{-# NEED #-}
instance Text.XML.HaXml.Verbatim.Verbatim Text.XML.HaXml.Types.Reference;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 Prelude.Bounded Data.Char.GeneralCategory;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.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 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.Num NHC.FFI.CFloat;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Num NHC.FFI.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.CFloat;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Real NHC.FFI.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.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.Enum DErrNo.ErrNo;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Monoid.Monoid Data.ByteString.Base.ByteString;

{-# NEED #-}
instance Data.Monoid.Monoid Data.ByteString.Base.LazyByteString;

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Num a) => Data.Monoid.Monoid (Data.Monoid.Product 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 [a];

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

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

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

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

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

{-# NEED #-}
instance Prelude.Read Data.ByteString.Base.ByteString;

{-# NEED #-}
instance Prelude.Read Data.ByteString.Base.LazyByteString;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Read NHC.FFI.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.Ord a,Prelude.Read a,Prelude.Read b) => Prelude.Read (Data.Map.Map a b);

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

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

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

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

{-# NEED #-}
instance Prelude.Ord Data.ByteString.Base.ByteString;

{-# NEED #-}
instance Prelude.Ord Data.ByteString.Base.LazyByteString;

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Ord (NHC.FFI.ForeignPtr 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.Ord NHC.FFI.CFloat;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Ord NHC.FFI.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 b) => Prelude.Ord (Data.Map.Map a b);

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

{-# NEED #-}
instance Prelude.Monad (Text.ParserCombinators.Poly.Parser a);

{-# NEED #-}
instance Prelude.Monad (Text.ParserCombinators.Poly.NoLeak.Plain.Parser a);

{-# NEED #-}
instance Prelude.Monad (Text.ParserCombinators.Poly.NoLeak.State.Parser a b);

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

{-# NEED #-}
instance Prelude.Functor (Text.ParserCombinators.Poly.Parser a);

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

{-# NEED #-}
instance Prelude.Functor (Text.ParserCombinators.Poly.NoLeak.Plain.Result a);

{-# NEED #-}
instance Prelude.Functor (Text.ParserCombinators.Poly.NoLeak.Plain.Parser a);

{-# NEED #-}
instance Prelude.Functor (Text.ParserCombinators.Poly.NoLeak.State.Parser a b);

{-# NEED #-}
instance Prelude.Functor (Text.ParserCombinators.Poly.NoLeak.State.Result a b);

{-# NEED #-}
instance Prelude.Functor Text.XML.HaXml.Types.Element;

{-# NEED #-}
instance Prelude.Functor Text.XML.HaXml.Types.Content;

{-# NEED #-}
instance Prelude.Functor Text.XML.HaXml.Types.Document;

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Data.ByteString.Base.ByteString;

{-# NEED #-}
instance Prelude.Eq Data.ByteString.Base.LazyByteString;

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Text.XML.HaXml.XmlContent.List1 a);

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.XmlContent.ANYContent;

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Text.XML.HaXml.XmlContent.Defaultable a);

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.TypeMapping.HType;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.TypeMapping.Constr;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq (NHC.FFI.ForeignPtr 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 NHC.FFI.CFloat;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Posn.Posn;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Lex.Section;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Lex.Special;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Lex.TokenT;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Lex.Where;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.Misc;

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Text.XML.HaXml.Types.Element a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Text.XML.HaXml.Types.Content a);

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.EncodingDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.XMLDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.Mixed;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.Modifier;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.CP;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.ContentSpec;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.ElementDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.TokenizedType;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.EnumeratedType;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.AttType;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.FIXED;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.DefaultDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.AttDef;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.AttListDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.NDataDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.EntityDef;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.GEDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.PEDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.EntityDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.PublicID;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.NotationDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.MarkupDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.DocTypeDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.Prolog;

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Text.XML.HaXml.Types.Document a);

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.TextDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.Ignore;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.IgnoreSectContents;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.ExtSubsetDecl;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.ConditionalSect;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.ExtPE;

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Text.XML.HaXml.Types.ExtParsedEnt a);

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.ElemTag;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.ExtSubset;

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

{-# 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 a,Prelude.Eq b) => Prelude.Eq (Data.Map.Map a b);

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

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.SystemLiteral;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.PubidLiteral;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.EV;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.EntityValue;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.AttValue;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.ExternalID;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.PEDef;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.Reference;

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

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

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

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

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

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

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

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

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

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

{-# 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 (Prelude.Maybe a);

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

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

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

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

{-# 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 a,Data.Typeable.Typeable b) => Data.Typeable.Typeable (Data.Map.Map a b);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Integral NHC.FFI.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 Prelude.Show System.ExitCode;

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

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

{-# NEED #-}
instance Prelude.Show Data.ByteString.Base.ByteString;

{-# NEED #-}
instance Prelude.Show Data.ByteString.Base.LazyByteString;

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Text.XML.HaXml.XmlContent.List1 a);

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.XmlContent.ANYContent;

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Text.XML.HaXml.XmlContent.Defaultable a);

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.TypeMapping.HType;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.TypeMapping.Constr;

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show (NHC.FFI.ForeignPtr 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 NHC.FFI.CFloat;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Posn.Posn;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Lex.Section;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Lex.Special;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Lex.TokenT;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.Modifier;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.CP;

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

{-# 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 a,Prelude.Show b) => Prelude.Show (Data.Map.Map a b);

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

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

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.SystemLiteral;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.PubidLiteral;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.EV;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.EntityValue;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.AttValue;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.ExternalID;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.PEDef;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.Reference;

{-# NEED #-}
instance Prelude.Show Text.PrettyPrint.HughesPJ.Doc;
interface Text.XML.HaXml.XmlContent
{-# NEED #-}
class XmlContent a;
interface Text.XML.HaXml.TypeMapping
{-# NEED #-}
class HTypeable a;
interface Data.Monoid
{-# NEED Monoid #-}
class Monoid a;
interface Text.ParserCombinators.Poly
{-# NEED Parser #-}
newtype {-#  #-} Parser a b;
interface Text.ParserCombinators.Poly.NoLeak.Plain
{-# NEED Result #-}
data Result a b;

{-# NEED Parser #-}
newtype {-#  #-} Parser a b;
interface Text.ParserCombinators.Poly.NoLeak.State
{-# NEED Parser #-}
newtype {-#  #-} Parser a b c;

{-# NEED Result #-}
data Result a b c;
interface Data.Typeable
{-# NEED KeyPr #-}
data KeyPr;

{-# NEED Key #-}
newtype {-#  #-} Key;
interface Data.HashTable
{-# NEED Inserts #-}
data Inserts;
interface Text.XML.HaXml.Lex
{-# NEED Where #-}
data Where;
interface NHC.FFI
{-# NEED StablePtr #-}
data StablePtr a;
interface Data.Typeable
{-# NEED Typeable #-}
class Typeable a;
interface System
{-# NEED ExitCode #-}
data ExitCode;
interface Data.Monoid
{-# NEED First #-}
newtype {-#  #-} First a;

{-# NEED Last #-}
newtype {-#  #-} Last a;
interface Data.ByteString.Base
{-# NEED ByteString #-}
data ByteString;

{-# NEED LazyByteString #-}
newtype {-#  #-} LazyByteString;
interface IO
{-# NEED BufferMode #-}
data BufferMode;
interface Data.ByteString.Fusion
{-# NEED MaybeS #-}
data MaybeS a;

{-# NEED PairS #-}
data PairS a b;
interface Data.Typeable
{-# NEED TyCon #-}
data TyCon;

{-# NEED TypeRep #-}
data TypeRep;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface Text.XML.HaXml.XmlContent
{-# NEED List1 #-}
data List1 a;

{-# NEED ANYContent #-}
data ANYContent;

{-# NEED Defaultable #-}
data Defaultable a;
interface Text.XML.HaXml.TypeMapping
{-# NEED HType #-}
data HType;

{-# NEED Constr #-}
data Constr;
interface Data.HashTable
{-# NEED HashData #-}
data HashData;
interface IO
{-# NEED HandlePosn #-}
data HandlePosn;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface IO
{-# NEED IOMode #-}
data IOMode;

{-# NEED SeekMode #-}
data SeekMode;
interface Data.Monoid
{-# NEED Dual #-}
newtype {-#  #-} Dual a;

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

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

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

{-# NEED Product #-}
newtype {-#  #-} Product a;
interface NHC.FFI
{-# NEED ForeignPtr #-}
data ForeignPtr a;
interface Array
{-# NEED Array #-}
data (Ix.Ix a) => Array a b;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface NHC.FFI
{-# NEED FunPtr #-}
data FunPtr a;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED CPtrdiff #-}
newtype {-#  #-} CPtrdiff;
interface Text.XML.HaXml.Lex
{-# NEED Section #-}
data Section;

{-# NEED Special #-}
data Special;

{-# NEED TokenT #-}
data TokenT;
interface NHC.FFI
{-# NEED CInt #-}
newtype {-#  #-} CInt;

{-# 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.Map
{-# NEED Map #-}
data Map a b;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface ! Text.XML.HaXml
{-# NEED version #-}
version{-# 0 #-}::Prelude.String;
interface ! Text.XML.HaXml.Pretty
{-# NEED element #-}
element{-# 1 #-}::((Text.XML.HaXml.Types.Element a) -> Text.PrettyPrint.HughesPJ.Doc);
interface ! Text.XML.HaXml.Combinators
{-# NEED keep #-}
keep{-# 0 #-}::(a -> [a]);

{-# NEED none #-}
none{-# 0 #-}::(a -> [b]);

{-# NEED children #-}
children{-# 1 #-}::(Text.XML.HaXml.Combinators.CFilter a);

{-# NEED position #-}
position{-# 2 #-}::(Prelude.Int -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED elm #-}
elm{-# 1 #-}::(Text.XML.HaXml.Combinators.CFilter a);

{-# NEED txt #-}
txt{-# 1 #-}::(Text.XML.HaXml.Combinators.CFilter a);

{-# NEED tag #-}
tag{-# 2 #-}::(Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED tagWith #-}
tagWith{-# 2 #-}::((Prelude.String -> Prelude.Bool) -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED attr #-}
attr{-# 2 #-}::(Text.XML.HaXml.Types.Name -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED attrval #-}
attrval{-# 2 #-}::(Text.XML.HaXml.Types.Attribute -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED find #-}
find{-# 3 #-}::(Prelude.String -> ((Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a)) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED iffind #-}
iffind{-# 4 #-}::(Prelude.String -> ((Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a)) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a))));

{-# NEED ifTxt #-}
ifTxt{-# 3 #-}::((Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a)) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED (?>) #-}
(?>){-# 2 #-}::((a -> [b]) -> ((Text.XML.HaXml.Combinators.ThenElse (a -> [b])) -> (a -> [b])));

{-# NEED {ThenElse (:>)} #-}
data ThenElse a
  = (:>) a a;

{-# NEED o #-}
o{-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED union #-}
union{-# 0 #-}::((a -> [b]) -> ((a -> [b]) -> (a -> [b])));

{-# NEED cat #-}
cat{-# 1 #-}::([(a -> [b])] -> (a -> [b]));

{-# NEED andThen #-}
andThen{-# 2 #-}::((a -> b) -> ((b -> (a -> c)) -> (a -> c)));

{-# NEED (|>|) #-}
(|>|){-# 2 #-}::((a -> [b]) -> ((a -> [b]) -> (a -> [b])));

{-# NEED with #-}
with{-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED without #-}
without{-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED (/>) #-}
(/>){-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED (</) #-}
(</){-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED et #-}
et{-# 2 #-}::((Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a)) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED path #-}
path{-# 1 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED deep #-}
deep{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED deepest #-}
deepest{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED multi #-}
multi{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED when #-}
when{-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED guards #-}
guards{-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED chip #-}
chip{-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED inplace #-}
inplace{-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED foldXml #-}
foldXml{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED mkElem #-}
mkElem{-# 2 #-}::(Prelude.String -> ([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED mkElemAttr #-}
mkElemAttr{-# 3 #-}::(Prelude.String -> ([(Prelude.String,(Text.XML.HaXml.Combinators.CFilter a))] -> ([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a))));

{-# NEED literal #-}
literal{-# 1 #-}::(Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED cdata #-}
cdata{-# 1 #-}::(Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED replaceTag #-}
replaceTag{-# 2 #-}::(Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED replaceAttrs #-}
replaceAttrs{-# 2 #-}::([(Prelude.String,Prelude.String)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED oo #-}
oo{-# 2 #-}::((a -> (Text.XML.HaXml.Combinators.CFilter b)) -> ((Text.XML.HaXml.Combinators.LabelFilter b a) -> (Text.XML.HaXml.Combinators.CFilter b)));

{-# NEED x #-}
x{-# 2 #-}::(((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.LabelFilter a b)) -> (((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.LabelFilter a c)) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.LabelFilter a (b,c)))));

{-# NEED numbered #-}
numbered{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.LabelFilter a Prelude.Int));

{-# NEED interspersed #-}
interspersed{-# 3 #-}::(Prelude.String -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Prelude.String -> (Text.XML.HaXml.Combinators.LabelFilter a Prelude.String))));

{-# NEED tagged #-}
tagged{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.LabelFilter a Prelude.String));

{-# NEED attributed #-}
attributed{-# 2 #-}::(Prelude.String -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.LabelFilter a Prelude.String)));

{-# NEED textlabelled #-}
textlabelled{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.LabelFilter a (Prelude.Maybe Prelude.String)));

{-# NEED extracted #-}
extracted{-# 2 #-}::(((Text.XML.HaXml.Types.Content a) -> b) -> ((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.LabelFilter a b)));

{-# NEED LabelFilter #-}
type {-# 2 #-} LabelFilter a b = ((Text.XML.HaXml.Types.Content a) -> [(b,(Text.XML.HaXml.Types.Content a))]);
interface ! Text.XML.HaXml.Wrappers
{-# NEED fix2Args #-}
fix2Args{-# 0 #-}::(NHC.Internal.IO (Prelude.String,Prelude.String));

{-# NEED processXmlWith #-}
processXmlWith{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter Text.XML.HaXml.Posn.Posn) -> (NHC.Internal.IO ()));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Text.XML.HaXml.Types
{-# NEED emptyST #-}
emptyST{-# 0 #-}::(Text.XML.HaXml.Types.SymTab a);

{-# NEED addST #-}
addST{-# 2 #-}::(Prelude.String -> (a -> ((Text.XML.HaXml.Types.SymTab a) -> (Text.XML.HaXml.Types.SymTab a))));

{-# NEED lookupST #-}
lookupST{-# 0 #-}::(Prelude.String -> ((Text.XML.HaXml.Types.SymTab a) -> (Prelude.Maybe a)));

{-# NEED info #-}
info{-# 1 #-}::((Text.XML.HaXml.Types.Content a) -> a);

{-# NEED PEReference #-}
type {-# 17 #-} PEReference = Name;

{-# NEED Names #-}
type {-# 18 #-} Names = [Name];

{-# NEED NmTokens #-}
type {-# 19 #-} NmTokens = [NmToken];

{-# NEED CDSect #-}
type {-# 21 #-} CDSect = CharData;
interface ! Text.XML.HaXml.Verbatim
{-# NEED verbAttr #-}
verbAttr{-# 1 #-}::(Text.XML.HaXml.Types.Attribute -> Prelude.String);
interface ! Text.XML.HaXml.Html.Generate
{-# NEED html #-}
html{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hhead #-}
hhead{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED htitle #-}
htitle{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hbody #-}
hbody{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED h1 #-}
h1{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED h2 #-}
h2{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED h3 #-}
h3{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED h4 #-}
h4{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hpara #-}
hpara{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hpre #-}
hpre{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hcentre #-}
hcentre{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hem #-}
hem{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED htt #-}
htt{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hbold #-}
hbold{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED htable #-}
htable{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hrow #-}
hrow{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hcol #-}
hcol{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hdiv #-}
hdiv{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED hspan #-}
hspan{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED margin #-}
margin{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED anchor #-}
anchor{-# 0 #-}::([(Prelude.String,(Text.XML.HaXml.Combinators.CFilter a))] -> ([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED makehref #-}
makehref{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED anchorname #-}
anchorname{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a)));

{-# NEED hbr #-}
hbr{-# 0 #-}::(Text.XML.HaXml.Combinators.CFilter a);

{-# NEED hhr #-}
hhr{-# 0 #-}::(Text.XML.HaXml.Combinators.CFilter a);

{-# NEED showattr #-}
showattr{-# 1 #-}::(Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED (!) #-}
(!){-# 0 #-}::(Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED (?) #-}
(?){-# 0 #-}::(Prelude.String -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED parens #-}
parens{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> (Text.XML.HaXml.Combinators.CFilter a));

{-# NEED bullet #-}
bullet{-# 0 #-}::([(Text.XML.HaXml.Combinators.CFilter a)] -> (Text.XML.HaXml.Combinators.CFilter a));
interface ! Text.XML.HaXml.Combinators
{-# NEED CFilter #-}
type {-# 1 #-} CFilter a = ((Text.XML.HaXml.Types.Content a) -> [(Text.XML.HaXml.Types.Content a)]);
interface ! Text.XML.HaXml.Html.Generate
{-# NEED htmlprint #-}
htmlprint{-# 0 #-}::([(Text.XML.HaXml.Types.Content a)] -> Text.PrettyPrint.HughesPJ.Doc);
interface ! Text.XML.HaXml.Verbatim
{-# NEED {Verbatim verbatim} #-}
class Verbatim a where {
  verbatim{-# 1 #-}::(a -> Prelude.String);
};
interface ! Text.XML.HaXml.Validate
{-# NEED validate #-}
validate{-# 2 #-}::(Text.XML.HaXml.Types.DocTypeDecl -> ((Text.XML.HaXml.Types.Element a) -> [Prelude.String]));
interface ! Text.XML.HaXml.Html.Parse
{-# NEED htmlParse #-}
htmlParse{-# 1 #-}::(Prelude.String -> (Prelude.String -> (Text.XML.HaXml.Types.Document Text.XML.HaXml.Posn.Posn)));
interface ! Text.XML.HaXml.Parse
{-# NEED xmlParse #-}
xmlParse{-# 1 #-}::(Prelude.String -> (Prelude.String -> (Text.XML.HaXml.Types.Document Text.XML.HaXml.Posn.Posn)));
interface Text.XML.HaXml.Posn
{-# NEED Posn #-}
data Posn;
interface ! Text.XML.HaXml.Parse
{-# NEED dtdParse #-}
dtdParse{-# 1 #-}::(Prelude.String -> (Prelude.String -> (Prelude.Maybe Text.XML.HaXml.Types.DocTypeDecl)));
interface ! Text.XML.HaXml.Escape
{-# NEED xmlEscape #-}
xmlEscape{-# 2 #-}::(Text.XML.HaXml.Escape.XmlEscaper -> ((Text.XML.HaXml.Types.Element a) -> (Text.XML.HaXml.Types.Element a)));

{-# NEED xmlEscapeContent #-}
xmlEscapeContent{-# 2 #-}::(Text.XML.HaXml.Escape.XmlEscaper -> ([(Text.XML.HaXml.Types.Content a)] -> [(Text.XML.HaXml.Types.Content a)]));

{-# NEED xmlUnEscape #-}
xmlUnEscape{-# 2 #-}::(Text.XML.HaXml.Escape.XmlEscaper -> ((Text.XML.HaXml.Types.Element a) -> (Text.XML.HaXml.Types.Element a)));

{-# NEED xmlUnEscapeContent #-}
xmlUnEscapeContent{-# 2 #-}::(Text.XML.HaXml.Escape.XmlEscaper -> ([(Text.XML.HaXml.Types.Content a)] -> [(Text.XML.HaXml.Types.Content a)]));

{-# NEED stdXmlEscaper #-}
stdXmlEscaper{-# 0 #-}::Text.XML.HaXml.Escape.XmlEscaper;

{-# NEED mkXmlEscaper #-}
mkXmlEscaper{-# 2 #-}::([(Prelude.Char,Prelude.String)] -> ((Prelude.Char -> Prelude.Bool) -> Text.XML.HaXml.Escape.XmlEscaper));

{-# NEED XmlEscaper #-}
data XmlEscaper;
interface ! Text.XML.HaXml.Types
{-# NEED {Document Document} #-}
data Document a
  = Document Text.XML.HaXml.Types.Prolog (Text.XML.HaXml.Types.SymTab Text.XML.HaXml.Types.EntityDef) (Text.XML.HaXml.Types.Element a) [Text.XML.HaXml.Types.Misc];

{-# NEED SymTab #-}
type {-# 2 #-} SymTab a = [(Prelude.String,a)];

{-# NEED {Prolog Prolog} #-}
data Prolog
  = Prolog (Prelude.Maybe Text.XML.HaXml.Types.XMLDecl) [Text.XML.HaXml.Types.Misc] (Prelude.Maybe Text.XML.HaXml.Types.DocTypeDecl) [Text.XML.HaXml.Types.Misc];

{-# NEED {DocTypeDecl DTD} #-}
data DocTypeDecl
  = DTD Text.XML.HaXml.Types.Name (Prelude.Maybe Text.XML.HaXml.Types.ExternalID) [Text.XML.HaXml.Types.MarkupDecl];

{-# NEED {XMLDecl XMLDecl} #-}
data XMLDecl
  = XMLDecl Text.XML.HaXml.Types.VersionInfo (Prelude.Maybe Text.XML.HaXml.Types.EncodingDecl) (Prelude.Maybe Text.XML.HaXml.Types.SDDecl);

{-# NEED SDDecl #-}
type {-# 5 #-} SDDecl = Prelude.Bool;

{-# NEED {ExtPE ExtPE} #-}
data ExtPE
  = ExtPE (Prelude.Maybe Text.XML.HaXml.Types.TextDecl) [Text.XML.HaXml.Types.ExtSubsetDecl];

{-# NEED {ExtParsedEnt ExtParsedEnt} #-}
data ExtParsedEnt a
  = ExtParsedEnt (Prelude.Maybe Text.XML.HaXml.Types.TextDecl) (Text.XML.HaXml.Types.Content a);

{-# NEED {Content CElem CString CRef CMisc} {Element Elem} #-}
data Content a
  = CElem (Text.XML.HaXml.Types.Element a) a
  | CString Prelude.Bool Text.XML.HaXml.Types.CharData a
  | CRef Text.XML.HaXml.Types.Reference a
  | CMisc Text.XML.HaXml.Types.Misc a;
data Element a
  = Elem Text.XML.HaXml.Types.Name [Text.XML.HaXml.Types.Attribute] [(Text.XML.HaXml.Types.Content a)];

{-# NEED CharData #-}
type {-# 20 #-} CharData = Prelude.String;

{-# NEED {ElemTag ElemTag} #-}
data ElemTag
  = ElemTag Text.XML.HaXml.Types.Name [Text.XML.HaXml.Types.Attribute];

{-# NEED Attribute #-}
type {-# 9 #-} Attribute = (Name,AttValue);

{-# NEED {ExtSubset ExtSubset} #-}
data ExtSubset
  = ExtSubset (Prelude.Maybe Text.XML.HaXml.Types.TextDecl) [Text.XML.HaXml.Types.ExtSubsetDecl];

{-# NEED {ConditionalSect IncludeSect IgnoreSect} {ExtSubsetDecl ExtMarkupDecl ExtConditionalSect} IncludeSect #-}
data ConditionalSect
  = IncludeSect Text.XML.HaXml.Types.IncludeSect
  | IgnoreSect Text.XML.HaXml.Types.IgnoreSect;
data ExtSubsetDecl
  = ExtMarkupDecl Text.XML.HaXml.Types.MarkupDecl
  | ExtConditionalSect Text.XML.HaXml.Types.ConditionalSect;
type {-# 13 #-} IncludeSect = [ExtSubsetDecl];

{-# NEED IgnoreSect #-}
type {-# 14 #-} IgnoreSect = [IgnoreSectContents];

{-# NEED {IgnoreSectContents IgnoreSectContents} #-}
data IgnoreSectContents
  = IgnoreSectContents Text.XML.HaXml.Types.Ignore [(Text.XML.HaXml.Types.IgnoreSectContents,Text.XML.HaXml.Types.Ignore)];

{-# NEED {Ignore Ignore} #-}
data Ignore
  = Ignore ;

{-# NEED {MarkupDecl Element AttList Entity Notation MarkupMisc} #-}
data MarkupDecl
  = Element Text.XML.HaXml.Types.ElementDecl
  | AttList Text.XML.HaXml.Types.AttListDecl
  | Entity Text.XML.HaXml.Types.EntityDecl
  | Notation Text.XML.HaXml.Types.NotationDecl
  | MarkupMisc Text.XML.HaXml.Types.Misc;

{-# NEED {Misc Comment PI} #-}
data Misc
  = Comment Text.XML.HaXml.Types.Comment
  | PI Text.XML.HaXml.Types.ProcessingInstruction;

{-# NEED ProcessingInstruction #-}
type {-# 4 #-} ProcessingInstruction = (PITarget,Prelude.String);

{-# NEED PITarget #-}
type {-# 3 #-} PITarget = Prelude.String;

{-# NEED Comment #-}
type {-# 7 #-} Comment = Prelude.String;

{-# NEED {NotationDecl NOTATION} #-}
data NotationDecl
  = NOTATION Text.XML.HaXml.Types.Name (Prelude.Either Text.XML.HaXml.Types.ExternalID Text.XML.HaXml.Types.PublicID);

{-# NEED {PublicID PUBLICID} #-}
newtype {-#  #-} PublicID
  = PUBLICID Text.XML.HaXml.Types.PubidLiteral;

{-# NEED {EntityDecl EntityGEDecl EntityPEDecl} #-}
data EntityDecl
  = EntityGEDecl Text.XML.HaXml.Types.GEDecl
  | EntityPEDecl Text.XML.HaXml.Types.PEDecl;

{-# NEED {PEDecl PEDecl} #-}
data PEDecl
  = PEDecl Text.XML.HaXml.Types.Name Text.XML.HaXml.Types.PEDef;

{-# NEED {GEDecl GEDecl} #-}
data GEDecl
  = GEDecl Text.XML.HaXml.Types.Name Text.XML.HaXml.Types.EntityDef;

{-# NEED {EntityDef DefEntityValue DefExternalID} #-}
data EntityDef
  = DefEntityValue Text.XML.HaXml.Types.EntityValue
  | DefExternalID Text.XML.HaXml.Types.ExternalID (Prelude.Maybe Text.XML.HaXml.Types.NDataDecl);

{-# NEED {NDataDecl NDATA} #-}
newtype {-#  #-} NDataDecl
  = NDATA Text.XML.HaXml.Types.Name;

{-# NEED {AttListDecl AttListDecl} #-}
data AttListDecl
  = AttListDecl Text.XML.HaXml.Types.Name [Text.XML.HaXml.Types.AttDef];

{-# NEED {AttDef AttDef} #-}
data AttDef
  = AttDef Text.XML.HaXml.Types.Name Text.XML.HaXml.Types.AttType Text.XML.HaXml.Types.DefaultDecl;

{-# NEED {DefaultDecl REQUIRED IMPLIED DefaultTo} #-}
data DefaultDecl
  = REQUIRED 
  | IMPLIED 
  | DefaultTo Text.XML.HaXml.Types.AttValue (Prelude.Maybe Text.XML.HaXml.Types.FIXED);

{-# NEED {FIXED FIXED} #-}
data FIXED
  = FIXED ;

{-# NEED {AttType StringType TokenizedType EnumeratedType} #-}
data AttType
  = StringType 
  | TokenizedType Text.XML.HaXml.Types.TokenizedType
  | EnumeratedType Text.XML.HaXml.Types.EnumeratedType;

{-# NEED {EnumeratedType NotationType Enumeration} #-}
data EnumeratedType
  = NotationType Text.XML.HaXml.Types.NotationType
  | Enumeration Text.XML.HaXml.Types.Enumeration;

{-# NEED Enumeration #-}
type {-# 12 #-} Enumeration = [NmToken];

{-# NEED NmToken #-}
type {-# 11 #-} NmToken = Prelude.String;

{-# NEED NotationType #-}
type {-# 10 #-} NotationType = [Name];

{-# NEED {TokenizedType ID IDREF IDREFS ENTITY ENTITIES NMTOKEN NMTOKENS} #-}
data TokenizedType
  = ID 
  | IDREF 
  | IDREFS 
  | ENTITY 
  | ENTITIES 
  | NMTOKEN 
  | NMTOKENS ;

{-# NEED {ElementDecl ElementDecl} #-}
data ElementDecl
  = ElementDecl Text.XML.HaXml.Types.Name Text.XML.HaXml.Types.ContentSpec;

{-# NEED {ContentSpec EMPTY ANY Mixed ContentSpec} #-}
data ContentSpec
  = EMPTY 
  | ANY 
  | Mixed Text.XML.HaXml.Types.Mixed
  | ContentSpec Text.XML.HaXml.Types.CP;

{-# NEED {CP TagName Choice Seq} #-}
data CP
  = TagName Text.XML.HaXml.Types.Name Text.XML.HaXml.Types.Modifier
  | Choice [Text.XML.HaXml.Types.CP] Text.XML.HaXml.Types.Modifier
  | Seq [Text.XML.HaXml.Types.CP] Text.XML.HaXml.Types.Modifier;

{-# NEED {Modifier None Query Star Plus} #-}
data Modifier
  = None 
  | Query 
  | Star 
  | Plus ;

{-# NEED {Mixed PCDATA PCDATAplus} #-}
data Mixed
  = PCDATA 
  | PCDATAplus [Text.XML.HaXml.Types.Name];

{-# NEED {TextDecl TextDecl} #-}
data TextDecl
  = TextDecl (Prelude.Maybe Text.XML.HaXml.Types.VersionInfo) Text.XML.HaXml.Types.EncodingDecl;

{-# NEED {EncodingDecl EncodingDecl} #-}
newtype {-#  #-} EncodingDecl
  = EncodingDecl Prelude.String;

{-# NEED VersionInfo #-}
type {-# 6 #-} VersionInfo = Prelude.String;

{-# NEED {AttValue AttValue} #-}
data AttValue
  = AttValue [(Prelude.Either Prelude.String Text.XML.HaXml.Types.Reference)];

{-# NEED {PEDef PEDefEntityValue PEDefExternalID} #-}
data PEDef
  = PEDefEntityValue Text.XML.HaXml.Types.EntityValue
  | PEDefExternalID Text.XML.HaXml.Types.ExternalID;

{-# NEED {ExternalID SYSTEM PUBLIC} #-}
data ExternalID
  = SYSTEM Text.XML.HaXml.Types.SystemLiteral
  | PUBLIC Text.XML.HaXml.Types.PubidLiteral Text.XML.HaXml.Types.SystemLiteral;

{-# NEED {PubidLiteral PubidLiteral} #-}
newtype {-#  #-} PubidLiteral
  = PubidLiteral Prelude.String;

{-# NEED {SystemLiteral SystemLiteral} #-}
newtype {-#  #-} SystemLiteral
  = SystemLiteral Prelude.String;

{-# NEED {EntityValue EntityValue} #-}
data EntityValue
  = EntityValue [Text.XML.HaXml.Types.EV];

{-# NEED {EV EVString EVRef} #-}
data EV
  = EVString Prelude.String
  | EVRef Text.XML.HaXml.Types.Reference;

{-# NEED {Reference RefEntity RefChar} #-}
data Reference
  = RefEntity Text.XML.HaXml.Types.EntityRef
  | RefChar Text.XML.HaXml.Types.CharRef;

{-# NEED CharRef #-}
type {-# 16 #-} CharRef = Prelude.Int;

{-# NEED EntityRef #-}
type {-# 15 #-} EntityRef = Name;

{-# NEED Name #-}
type {-# 8 #-} Name = Prelude.String;
interface ! Text.PrettyPrint.HughesPJ
{-# NEED render #-}
render{-# 1 #-}::(Text.PrettyPrint.HughesPJ.Doc -> Prelude.String);
interface Text.PrettyPrint.HughesPJ
{-# NEED Doc #-}
data Doc;
}