interface Hat.PreludeBuiltinTypes where {

{-# 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.Functor NHC.Internal.IO;

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Hat.Hat.RefExp;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface ! Hat.PreludeBuiltinTypes
{-# NEED aundefined #-}
aundefined{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED hundefined #-}
hundefined{-# 1 #-}::(Hat.Hat.RefExp -> a);

{-# NEED gundefined #-}
gundefined{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

{-# NEED aerror #-}
aerror{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED herror #-}
herror{-# 2 #-}::((Hat.Hat.R String) -> (Hat.Hat.RefExp -> a));

{-# NEED gerror #-}
gerror{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun String a))));
interface Hat.Hat
{-# NEED RefSrcPos #-}
newtype {-#  #-} RefSrcPos;
interface ! Hat.PreludeBuiltinTypes
{-# NEED aIOError #-}
aIOError{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED fromIOError #-}
fromIOError{-# 2 #-}::(Hat.Hat.RefExp -> (Prelude.IOError -> (Hat.Hat.R Prelude.IOError)));

{-# NEED toIOError #-}
toIOError{-# 2 #-}::(Hat.Hat.RefExp -> ((Hat.Hat.R Prelude.IOError) -> Prelude.IOError));

{-# NEED fromString #-}
fromString{-# 0 #-}::(Hat.Hat.RefExp -> (Prelude.String -> (Hat.Hat.R String)));

{-# NEED toString #-}
toString{-# 0 #-}::(Hat.Hat.RefExp -> ((Hat.Hat.R String) -> Prelude.String));

{-# NEED fromList #-}
fromList{-# 2 #-}::((Hat.Hat.RefExp -> (a -> (Hat.Hat.R b))) -> (Hat.Hat.RefExp -> ([a] -> (Hat.Hat.R (Hat.Hat.List b)))));

{-# NEED toList #-}
toList{-# 3 #-}::((Hat.Hat.RefExp -> ((Hat.Hat.R a) -> b)) -> (Hat.Hat.RefExp -> ((Hat.Hat.R (Hat.Hat.List a)) -> [b])));

{-# NEED fromBool #-}
fromBool{-# 2 #-}::(Hat.Hat.RefExp -> (Prelude.Bool -> (Hat.Hat.R Prelude.Bool)));

{-# NEED toBool #-}
toBool{-# 2 #-}::(Hat.Hat.RefExp -> ((Hat.Hat.R Prelude.Bool) -> Prelude.Bool));

{-# NEED fromFun #-}
fromFun{-# 4 #-}::((Hat.Hat.RefExp -> ((Hat.Hat.R a) -> b)) -> ((Hat.Hat.RefExp -> (c -> (Hat.Hat.R d))) -> (Hat.Hat.RefExp -> ((b -> c) -> (Hat.Hat.R (Hat.Hat.Fun a d))))));

{-# NEED toFun #-}
toFun{-# 4 #-}::((Hat.Hat.RefExp -> (a -> (Hat.Hat.R b))) -> ((Hat.Hat.RefExp -> ((Hat.Hat.R c) -> d)) -> (Hat.Hat.RefExp -> ((Hat.Hat.R (Hat.Hat.Fun b c)) -> (a -> d)))));

{-# NEED String #-}
type {-# 1 #-} String = (Hat.Hat.List Prelude.Char);
interface Hat.Hat
{-# NEED List #-}
data List a;
interface ! Hat.PreludeBuiltinTypes
{-# NEED aFalse #-}
aFalse{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED aTrue #-}
aTrue{-# 0 #-}::Hat.Hat.RefAtom;
interface Hat.Hat
{-# NEED RefAtom #-}
newtype {-#  #-} RefAtom;
interface ! Prelude
{-# NEED IOError #-}
data IOError;
interface ! Hat.Hat
{-# NEED {Fun Fun} #-}
newtype {-#  #-} Fun a b
  = Fun (Hat.Hat.RefExp -> ((Hat.Hat.R a) -> (Hat.Hat.R b)));
interface Hat.Hat
{-# NEED R #-}
data R a;

{-# NEED RefExp #-}
newtype {-#  #-} RefExp;
interface ! Prelude
{-# NEED {Bool False True} #-}
data Bool
  = False 
  | True ;
}
