interface Text.XML.HaXml.Wrappers where {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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.Read IO.IOMode;

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

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

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

{-# NEED #-}
instance Prelude.Ord Text.XML.HaXml.Types.QName;

{-# 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.Ord IO.IOMode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show Text.PrettyPrint.HughesPJ.Doc;
interface Data.Typeable
{-# NEED Typeable #-}
class Typeable a;
interface Text.ParserCombinators.Poly.Plain
{-# NEED Result #-}
data Result a b;
interface Text.ParserCombinators.Poly.State
{-# NEED Result #-}
data Result a b c;
interface Text.ParserCombinators.Poly.Plain
{-# NEED Parser #-}
newtype {-#  #-} Parser a b;
interface Text.ParserCombinators.Poly.State
{-# NEED Parser #-}
newtype {-#  #-} Parser a b c;
interface Text.XML.HaXml.Types
{-# NEED XMLDecl #-}
data XMLDecl;

{-# NEED DocTypeDecl #-}
data DocTypeDecl;

{-# NEED MarkupDecl #-}
data MarkupDecl;

{-# NEED ExtSubset #-}
data ExtSubset;

{-# NEED ExtSubsetDecl #-}
data ExtSubsetDecl;

{-# NEED ElemTag #-}
data ElemTag;

{-# NEED ElementDecl #-}
data ElementDecl;

{-# NEED ContentSpec #-}
data ContentSpec;

{-# NEED Mixed #-}
data Mixed;

{-# NEED AttListDecl #-}
data AttListDecl;

{-# NEED AttDef #-}
data AttDef;

{-# NEED AttType #-}
data AttType;

{-# NEED TokenizedType #-}
data TokenizedType;

{-# NEED EnumeratedType #-}
data EnumeratedType;

{-# NEED DefaultDecl #-}
data DefaultDecl;

{-# NEED FIXED #-}
data FIXED;

{-# NEED ConditionalSect #-}
data ConditionalSect;

{-# NEED Ignore #-}
data Ignore;

{-# NEED IgnoreSectContents #-}
data IgnoreSectContents;

{-# NEED EntityDecl #-}
data EntityDecl;

{-# NEED GEDecl #-}
data GEDecl;

{-# NEED PEDecl #-}
data PEDecl;

{-# NEED NDataDecl #-}
newtype {-#  #-} NDataDecl;

{-# NEED TextDecl #-}
data TextDecl;

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

{-# NEED ExtPE #-}
data ExtPE;

{-# NEED NotationDecl #-}
data NotationDecl;

{-# NEED PublicID #-}
newtype {-#  #-} PublicID;

{-# NEED EncodingDecl #-}
newtype {-#  #-} EncodingDecl;
interface Text.XML.HaXml.Lex
{-# NEED Where #-}
data Where;
interface System
{-# NEED ExitCode #-}
data ExitCode;
interface Text.XML.HaXml.Types
{-# NEED CP #-}
data CP;

{-# NEED Modifier #-}
data Modifier;

{-# NEED PEDef #-}
data PEDef;

{-# NEED ExternalID #-}
data ExternalID;

{-# NEED Namespace #-}
data Namespace;

{-# NEED AttValue #-}
data AttValue;

{-# NEED EntityValue #-}
data EntityValue;

{-# NEED EV #-}
data EV;

{-# NEED PubidLiteral #-}
newtype {-#  #-} PubidLiteral;

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

{-# NEED Special #-}
data Special;

{-# NEED TokenT #-}
data TokenT;
interface Text.XML.HaXml.Types
{-# NEED QName #-}
data QName;
interface Data.Map
{-# NEED Map #-}
data Map a b;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface IO
{-# NEED IOMode #-}
data IOMode;

{-# NEED SeekMode #-}
data SeekMode;

{-# NEED BufferMode #-}
data BufferMode;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED HandlePosn #-}
data HandlePosn;
interface Text.PrettyPrint.HughesPJ
{-# NEED Doc #-}
data Doc;
interface ! Text.XML.HaXml.Wrappers
{-# NEED onContent #-}
onContent{-# 2 #-}::((Text.XML.HaXml.Combinators.CFilter a) -> ((Text.XML.HaXml.Types.Document a) -> (Text.XML.HaXml.Types.Document a)));
interface Text.XML.HaXml.Types
{-# NEED Document #-}
data Document a;

{-# NEED EntityDef #-}
data EntityDef;

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

{-# NEED Prolog #-}
data Prolog;
interface ! Text.XML.HaXml.Wrappers
{-# NEED processXmlWith #-}
processXmlWith{-# 1 #-}::((Text.XML.HaXml.Combinators.CFilter Text.XML.HaXml.Posn.Posn) -> (NHC.Internal.IO ()));
interface Text.XML.HaXml.Posn
{-# NEED Posn #-}
data Posn;
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.Types
{-# NEED Content #-}
data Content a;

{-# NEED Misc #-}
data Misc;

{-# NEED Reference #-}
data Reference;

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

{-# NEED Element #-}
data Element a;
interface ! Text.XML.HaXml.Wrappers
{-# NEED fix2Args #-}
fix2Args{-# 0 #-}::(NHC.Internal.IO (Prelude.String,Prelude.String));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;
interface NHC.DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface NHC.Internal
{-# NEED World #-}
data World;
}
