interface Text.XHtml where {
infixr  2 Text.XHtml.Internals.+++;
infixr  7 Text.XHtml.Internals.<<;
infixr  3 Text.XHtml.Table.</>;
infixr  4 Text.XHtml.Table.<->;
infixl  8 Text.XHtml.Internals.!;

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

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

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

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

{-# NEED #-}
instance Data.Monoid.Monoid Text.XHtml.Internals.Html;

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

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

{-# NEED #-}
instance Text.XHtml.Table.HTMLTABLE Text.XHtml.Table.HtmlTable;

{-# NEED #-}
instance Text.XHtml.Table.HTMLTABLE Text.XHtml.Internals.Html;

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show Text.XHtml.Extras.HotLink;

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Text.XHtml.BlockTable.BlockTable a);

{-# NEED #-}
instance Prelude.Show Text.XHtml.Table.HtmlTable;

{-# NEED #-}
instance Prelude.Show Text.XHtml.Internals.Html;

{-# NEED #-}
instance Prelude.Show Text.XHtml.Internals.HtmlAttr;

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

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

{-# NEED #-}
instance Text.XHtml.Internals.HTML Prelude.Char;

{-# NEED #-}
instance Text.XHtml.Internals.HTML Text.XHtml.Debug.HtmlTree;

{-# NEED #-}
instance Text.XHtml.Internals.HTML Text.XHtml.Extras.HotLink;

{-# NEED #-}
instance Text.XHtml.Internals.HTML Text.XHtml.Table.HtmlTable;

{-# NEED #-}
instance Text.XHtml.Internals.HTML Text.XHtml.Internals.Html;

{-# NEED #-}
instance (Text.XHtml.Internals.HTML a) => Text.XHtml.Internals.HTML [a];

{-# NEED #-}
instance Text.XHtml.Internals.ADDATTRS Text.XHtml.Internals.Html;

{-# NEED #-}
instance (Text.XHtml.Internals.ADDATTRS b) => Text.XHtml.Internals.ADDATTRS (a -> b);
interface Data.Monoid
{-# NEED Monoid #-}
class Monoid a;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Text.XHtml.Extras
{-# NEED gui #-}
gui{-# 1 #-}::(Prelude.String -> (Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html));

{-# NEED menu #-}
menu{-# 2 #-}::(Prelude.String -> ([Text.XHtml.Internals.Html] -> Text.XHtml.Internals.Html));

{-# NEED clickmap #-}
clickmap{-# 1 #-}::(Prelude.String -> Text.XHtml.Internals.Html);

{-# NEED afile #-}
afile{-# 1 #-}::(Prelude.String -> Text.XHtml.Internals.Html);

{-# NEED textfield #-}
textfield{-# 1 #-}::(Prelude.String -> Text.XHtml.Internals.Html);

{-# NEED password #-}
password{-# 1 #-}::(Prelude.String -> Text.XHtml.Internals.Html);

{-# NEED submit #-}
submit{-# 2 #-}::(Prelude.String -> (Prelude.String -> Text.XHtml.Internals.Html));

{-# NEED reset #-}
reset{-# 2 #-}::(Prelude.String -> (Prelude.String -> Text.XHtml.Internals.Html));

{-# NEED radio #-}
radio{-# 2 #-}::(Prelude.String -> (Prelude.String -> Text.XHtml.Internals.Html));

{-# NEED hidden #-}
hidden{-# 2 #-}::(Prelude.String -> (Prelude.String -> Text.XHtml.Internals.Html));

{-# NEED checkbox #-}
checkbox{-# 2 #-}::(Prelude.String -> (Prelude.String -> Text.XHtml.Internals.Html));

{-# NEED widget #-}
widget{-# 3 #-}::(Prelude.String -> (Prelude.String -> ([Text.XHtml.Internals.HtmlAttr] -> Text.XHtml.Internals.Html)));

{-# NEED defList #-}
defList{-# 1 #-}::(Text.XHtml.Internals.HTML a,Text.XHtml.Internals.HTML b) => ([(a,b)] -> Text.XHtml.Internals.Html);

{-# NEED unordList #-}
unordList{-# 1 #-}::(Text.XHtml.Internals.HTML a) => ([a] -> Text.XHtml.Internals.Html);

{-# NEED ordList #-}
ordList{-# 1 #-}::(Text.XHtml.Internals.HTML a) => ([a] -> Text.XHtml.Internals.Html);

{-# NEED hotlink #-}
hotlink{-# 2 #-}::(Text.XHtml.Extras.URL -> (Text.XHtml.Internals.Html -> Text.XHtml.Extras.HotLink));

{-# NEED p #-}
p{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED bullet #-}
bullet{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED spaceHtml #-}
spaceHtml{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED copyright #-}
copyright{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED primHtmlChar #-}
primHtmlChar{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.Html);

{-# NEED linesToHtml #-}
linesToHtml{-# 1 #-}::([Prelude.String] -> Text.XHtml.Internals.Html);

{-# NEED lineToHtml #-}
lineToHtml{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.Html);

{-# NEED stringToHtml #-}
stringToHtml{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.Html);
interface ! Text.XHtml.Transitional.Attributes
{-# NEED white #-}
white{-# 0 #-}::Prelude.String;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED vspace #-}
vspace{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED vlink #-}
vlink{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED version #-}
version{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED text #-}
text{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED target #-}
target{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED start #-}
start{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED nowrap #-}
nowrap{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED noshade #-}
noshade{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED link #-}
link{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED hspace #-}
hspace{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED face #-}
face{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED compact #-}
compact{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED color #-}
color{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED code #-}
code{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED clear #-}
clear{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED bgcolor #-}
bgcolor{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED background #-}
background{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED alink #-}
alink{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);
interface ! Text.XHtml.Strict.Attributes
{-# NEED width #-}
width{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED value #-}
value{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED valign #-}
valign{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED usemap #-}
usemap{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED title #-}
title{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED thetype #-}
thetype{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED thestyle #-}
thestyle{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED thefor #-}
thefor{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED theclass #-}
theclass{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED src #-}
src{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED size #-}
size{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED shape #-}
shape{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED selected #-}
selected{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED rules #-}
rules{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED rowspan #-}
rowspan{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED rows #-}
rows{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED rev #-}
rev{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED rel #-}
rel{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED nohref #-}
nohref{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED name #-}
name{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED multiple #-}
multiple{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED method #-}
method{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED maxlength #-}
maxlength{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED lang #-}
lang{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED ismap #-}
ismap{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED identifier #-}
identifier{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED httpequiv #-}
httpequiv{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED href #-}
href{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED height #-}
height{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED enctype #-}
enctype{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED disabled #-}
disabled{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED coords #-}
coords{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED content #-}
content{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED colspan #-}
colspan{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED cols #-}
cols{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED codebase #-}
codebase{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED checked #-}
checked{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED cellspacing #-}
cellspacing{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED cellpadding #-}
cellpadding{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED bordercolor #-}
bordercolor{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED border #-}
border{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED base #-}
base{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED archive #-}
archive{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED altcode #-}
altcode{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED alt #-}
alt{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED align #-}
align{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED action #-}
action{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);
interface ! Text.XHtml.Frameset.Attributes
{-# NEED scrolling #-}
scrolling{-# 0 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED noresize #-}
noresize{-# 0 #-}::Text.XHtml.Internals.HtmlAttr;

{-# NEED marginwidth #-}
marginwidth{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED marginheight #-}
marginheight{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);

{-# NEED frameborder #-}
frameborder{-# 0 #-}::(Prelude.Int -> Text.XHtml.Internals.HtmlAttr);
interface ! Text.XHtml.Internals
{-# NEED prettyHtmlFragment #-}
prettyHtmlFragment{-# 0 #-}::(Text.XHtml.Internals.HTML a) => (a -> Prelude.String);

{-# NEED renderHtmlFragment #-}
renderHtmlFragment{-# 1 #-}::(Text.XHtml.Internals.HTML a) => (a -> Prelude.String);

{-# NEED showHtmlFragment #-}
showHtmlFragment{-# 1 #-}::(Text.XHtml.Internals.HTML a) => (a -> Prelude.String);

{-# NEED primHtml #-}
primHtml{-# 1 #-}::(Prelude.String -> Text.XHtml.Internals.Html);

{-# NEED strAttr #-}
strAttr{-# 2 #-}::(Prelude.String -> (Prelude.String -> Text.XHtml.Internals.HtmlAttr));

{-# NEED intAttr #-}
intAttr{-# 2 #-}::(Prelude.String -> (Prelude.Int -> Text.XHtml.Internals.HtmlAttr));

{-# NEED emptyAttr #-}
emptyAttr{-# 1 #-}::(Prelude.String -> Text.XHtml.Internals.HtmlAttr);

{-# NEED itag #-}
itag{-# 1 #-}::(Prelude.String -> Text.XHtml.Internals.Html);

{-# NEED tag #-}
tag{-# 2 #-}::(Prelude.String -> (Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html));

{-# NEED isNoHtml #-}
isNoHtml{-# 1 #-}::(Text.XHtml.Internals.Html -> Prelude.Bool);

{-# NEED noHtml #-}
noHtml{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED (+++) #-}
(+++){-# 2 #-}::(Text.XHtml.Internals.HTML a,Text.XHtml.Internals.HTML b) => (a -> (b -> Text.XHtml.Internals.Html));

{-# NEED concatHtml #-}
concatHtml{-# 1 #-}::(Text.XHtml.Internals.HTML a) => ([a] -> Text.XHtml.Internals.Html);

{-# NEED (<<) #-}
(<<){-# 2 #-}::(Text.XHtml.Internals.HTML b) => ((Text.XHtml.Internals.Html -> a) -> (b -> a));
interface ! Text.XHtml.Transitional.Elements
{-# NEED underline #-}
underline{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED strike #-}
strike{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED themenu #-}
themenu{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED isindex #-}
isindex{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED iframe #-}
iframe{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED font #-}
font{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED dir #-}
dir{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED center #-}
center{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED basefont #-}
basefont{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED applet #-}
applet{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);
interface ! Text.XHtml.Strict.Elements
{-# NEED variable #-}
variable{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED ulist #-}
ulist{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED tt #-}
tt{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED tr #-}
tr{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED thetitle #-}
thetitle{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED thespan #-}
thespan{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED themap #-}
themap{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED thelink #-}
thelink{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED thehtml #-}
thehtml{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED thediv #-}
thediv{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED thecode #-}
thecode{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED thebase #-}
thebase{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED thead #-}
thead{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED th #-}
th{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED tfoot #-}
tfoot{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED textarea #-}
textarea{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED td #-}
td{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED tbody #-}
tbody{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED table #-}
table{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED sup #-}
sup{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED sub #-}
sub{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED style #-}
style{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED strong #-}
strong{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED small #-}
small{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED select #-}
select{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED script #-}
script{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED sample #-}
sample{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED quote #-}
quote{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED pre #-}
pre{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED param #-}
param{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED paragraph #-}
paragraph{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED option #-}
option{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED optgroup #-}
optgroup{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED olist #-}
olist{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED object #-}
object{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED noscript #-}
noscript{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED meta #-}
meta{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED li #-}
li{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED legend #-}
legend{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED label #-}
label{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED keyboard #-}
keyboard{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED italics #-}
italics{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED ins #-}
ins{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED input #-}
input{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED image #-}
image{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED hr #-}
hr{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED header #-}
header{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED h6 #-}
h6{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED h5 #-}
h5{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED h4 #-}
h4{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED h3 #-}
h3{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED h2 #-}
h2{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED h1 #-}
h1{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED form #-}
form{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED fieldset #-}
fieldset{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED emphasize #-}
emphasize{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED dterm #-}
dterm{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED dlist #-}
dlist{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED del #-}
del{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED define #-}
define{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED ddef #-}
ddef{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED colgroup #-}
colgroup{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED col #-}
col{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED cite #-}
cite{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED caption #-}
caption{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED br #-}
br{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED button #-}
button{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED bold #-}
bold{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED body #-}
body{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED blockquote #-}
blockquote{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED big #-}
big{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED bdo #-}
bdo{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED area #-}
area{-# 0 #-}::Text.XHtml.Internals.Html;

{-# NEED anchor #-}
anchor{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED address #-}
address{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED acronym #-}
acronym{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED abbr #-}
abbr{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);
interface ! Text.XHtml.Frameset.Elements
{-# NEED noframes #-}
noframes{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED frameset #-}
frameset{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);

{-# NEED frame #-}
frame{-# 0 #-}::(Text.XHtml.Internals.Html -> Text.XHtml.Internals.Html);
interface ! Text.XHtml.Transitional
{-# NEED showHtml #-}
showHtml{-# 0 #-}::(Text.XHtml.Internals.HTML a) => (a -> Prelude.String);

{-# NEED renderHtml #-}
renderHtml{-# 0 #-}::(Text.XHtml.Internals.HTML a) => (a -> Prelude.String);

{-# NEED prettyHtml #-}
prettyHtml{-# 0 #-}::(Text.XHtml.Internals.HTML a) => (a -> Prelude.String);
interface ! Text.XHtml.Debug
{-# NEED treeHtml #-}
treeHtml{-# 2 #-}::([Prelude.String] -> (Text.XHtml.Debug.HtmlTree -> Text.XHtml.Internals.Html));

{-# NEED treeColors #-}
treeColors{-# 0 #-}::[Prelude.String];

{-# NEED debugHtml #-}
debugHtml{-# 1 #-}::(Text.XHtml.Internals.HTML a) => (a -> Text.XHtml.Internals.Html);

{-# NEED {HtmlTree HtmlLeaf HtmlNode} #-}
data HtmlTree
  = HtmlLeaf Text.XHtml.Internals.Html
  | HtmlNode Text.XHtml.Internals.Html [Text.XHtml.Debug.HtmlTree] Text.XHtml.Internals.Html;
interface ! Text.XHtml.Extras
{-# NEED {HotLink HotLink hotLinkURL hotLinkContents hotLinkAttributes} #-}
data HotLink
  = HotLink {Text.XHtml.Extras.hotLinkURL :: Text.XHtml.Extras.URL} {Text.XHtml.Extras.hotLinkContents :: Text.XHtml.Internals.Html} {Text.XHtml.Extras.hotLinkAttributes :: [Text.XHtml.Internals.HtmlAttr]};

{-# NEED URL #-}
type {-# 2 #-} URL = Prelude.String;
interface ! Text.XHtml.Table
{-# NEED above #-}
above{-# 2 #-}::(Text.XHtml.Table.HTMLTABLE a,Text.XHtml.Table.HTMLTABLE b) => (a -> (b -> Text.XHtml.Table.HtmlTable));

{-# NEED (</>) #-}
(</>){-# 0 #-}::(Text.XHtml.Table.HTMLTABLE a,Text.XHtml.Table.HTMLTABLE b) => (a -> (b -> Text.XHtml.Table.HtmlTable));

{-# NEED beside #-}
beside{-# 2 #-}::(Text.XHtml.Table.HTMLTABLE a,Text.XHtml.Table.HTMLTABLE b) => (a -> (b -> Text.XHtml.Table.HtmlTable));

{-# NEED (<->) #-}
(<->){-# 0 #-}::(Text.XHtml.Table.HTMLTABLE a,Text.XHtml.Table.HTMLTABLE b) => (a -> (b -> Text.XHtml.Table.HtmlTable));

{-# NEED aboves #-}
aboves{-# 1 #-}::(Text.XHtml.Table.HTMLTABLE a) => ([a] -> Text.XHtml.Table.HtmlTable);

{-# NEED besides #-}
besides{-# 1 #-}::(Text.XHtml.Table.HTMLTABLE a) => ([a] -> Text.XHtml.Table.HtmlTable);

{-# NEED {HTMLTABLE cell} #-}
class HTMLTABLE a where {
  cell{-# 1 #-}::(a -> Text.XHtml.Table.HtmlTable);
};

{-# NEED {HtmlTable} #-}
newtype {-#  #-} HtmlTable
  = Unexported.Constr_24 (Text.XHtml.BlockTable.BlockTable (Prelude.Int -> (Prelude.Int -> Text.XHtml.Internals.Html)));
interface Text.XHtml.BlockTable
{-# NEED BlockTable #-}
data BlockTable a;
interface ! Text.XHtml.Table
{-# NEED simpleTable #-}
simpleTable{-# 3 #-}::([Text.XHtml.Internals.HtmlAttr] -> ([Text.XHtml.Internals.HtmlAttr] -> ([[Text.XHtml.Internals.Html]] -> Text.XHtml.Internals.Html)));
interface ! Text.XHtml.Internals
{-# NEED {HTML toHtmlFromList toHtml} #-}
class HTML a where {
  toHtmlFromList{-# 1 #-}::([a] -> Text.XHtml.Internals.Html);
  toHtml{-# 1 #-}::(a -> Text.XHtml.Internals.Html);
};

{-# NEED {Html Html getHtmlElements} #-}
newtype {-#  #-} Html
  = Html {Text.XHtml.Internals.getHtmlElements :: [Text.XHtml.Internals.HtmlElement]};

{-# NEED HtmlElement #-}
data HtmlElement;

{-# NEED {ADDATTRS (!)} #-}
class ADDATTRS a where {
  (!){-# 2 #-}::(a -> ([Text.XHtml.Internals.HtmlAttr] -> a));
};

{-# NEED HtmlAttr #-}
data HtmlAttr;
}