interface Hat.Char where {

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

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

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

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

{-# NEED #-}
instance Hat.Hat.WrapVal (Hat.PreludeBasic.Either a b);

{-# NEED #-}
instance Hat.Hat.WrapVal (Hat.PreludeBasic.Maybe a);

{-# NEED #-}
instance (Hat.PreludeBasic.Integral a) => Hat.Hat.WrapVal (Hat.PreludeBasic.Ratio a);

{-# NEED #-}
instance Hat.Hat.WrapVal Hat.PreludeBasic.Ordering;

{-# NEED #-}
instance Hat.PreludeBasic.RealFloat Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.RealFloat Prelude.Double;

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

{-# NEED #-}
instance Hat.PreludeBasic.RealFrac Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.RealFrac Prelude.Double;

{-# NEED #-}
instance Hat.PreludeBasic.Floating Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Floating Prelude.Double;

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

{-# NEED #-}
instance Hat.PreludeBasic.Fractional Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Fractional Prelude.Double;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Integral Prelude.Integer;

{-# NEED #-}
instance Hat.PreludeBasic.Integral Prelude.Int;

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

{-# NEED #-}
instance Hat.PreludeBasic.Real Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Real Prelude.Double;

{-# NEED #-}
instance Hat.PreludeBasic.Real Prelude.Integer;

{-# NEED #-}
instance Hat.PreludeBasic.Real Prelude.Int;

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

{-# NEED #-}
instance Hat.PreludeBasic.Num Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Num Prelude.Double;

{-# NEED #-}
instance Hat.PreludeBasic.Num Prelude.Integer;

{-# NEED #-}
instance Hat.PreludeBasic.Num Prelude.Int;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Hat.Hat.RefExp;

{-# NEED #-}
instance Hat.PreludeBasic.Monad Hat.Hat.IO;

{-# NEED #-}
instance Hat.PreludeBasic.Monad Hat.PreludeBasic.Maybe;

{-# NEED #-}
instance Hat.PreludeBasic.Monad Hat.Hat.List;

{-# NEED #-}
instance Hat.PreludeBasic.Functor Hat.Hat.IO;

{-# NEED #-}
instance Hat.PreludeBasic.Functor Hat.PreludeBasic.Maybe;

{-# NEED #-}
instance Hat.PreludeBasic.Functor Hat.Hat.List;

{-# NEED #-}
instance Hat.PreludeBasic.Enum Hat.Hat.Tuple0;

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

{-# NEED #-}
instance Hat.PreludeBasic.Enum Hat.PreludeBasic.Ordering;

{-# NEED #-}
instance Hat.PreludeBasic.Enum Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Enum Prelude.Double;

{-# NEED #-}
instance Hat.PreludeBasic.Enum Prelude.Integer;

{-# NEED #-}
instance Hat.PreludeBasic.Enum Prelude.Bool;

{-# NEED #-}
instance Hat.PreludeBasic.Enum Prelude.Int;

{-# NEED #-}
instance Hat.PreludeBasic.Enum Prelude.Char;

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Show Prelude.IOError;

{-# NEED #-}
instance (Hat.PreludeBasic.Show a,Hat.PreludeBasic.Show b) => Hat.PreludeBasic.Show (Hat.PreludeBasic.Either a b);

{-# NEED #-}
instance (Hat.PreludeBasic.Show a,Hat.PreludeBasic.Show b,Hat.PreludeBasic.Show c) => Hat.PreludeBasic.Show (Hat.Hat.Tuple3 a b c);

{-# NEED #-}
instance (Hat.PreludeBasic.Show a) => Hat.PreludeBasic.Show (Hat.PreludeBasic.Maybe a);

{-# NEED #-}
instance Hat.PreludeBasic.Show Hat.Hat.Tuple0;

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

{-# NEED #-}
instance Hat.PreludeBasic.Show Hat.PreludeBasic.Ordering;

{-# NEED #-}
instance Hat.PreludeBasic.Show Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Show Prelude.Double;

{-# NEED #-}
instance Hat.PreludeBasic.Show Prelude.Integer;

{-# NEED #-}
instance Hat.PreludeBasic.Show Prelude.Bool;

{-# NEED #-}
instance (Hat.PreludeBasic.Show a,Hat.PreludeBasic.Show b) => Hat.PreludeBasic.Show (Hat.Hat.Tuple2 a b);

{-# NEED #-}
instance (Hat.PreludeBasic.Show a) => Hat.PreludeBasic.Show (Hat.Hat.List a);

{-# NEED #-}
instance Hat.PreludeBasic.Show Prelude.Int;

{-# NEED #-}
instance Hat.PreludeBasic.Show Prelude.Char;

{-# NEED #-}
instance (Hat.PreludeBasic.Read a,Hat.PreludeBasic.Read b) => Hat.PreludeBasic.Read (Hat.PreludeBasic.Either a b);

{-# NEED #-}
instance (Hat.PreludeBasic.Read a,Hat.PreludeBasic.Read b,Hat.PreludeBasic.Read c) => Hat.PreludeBasic.Read (Hat.Hat.Tuple3 a b c);

{-# NEED #-}
instance (Hat.PreludeBasic.Read a) => Hat.PreludeBasic.Read (Hat.PreludeBasic.Maybe a);

{-# NEED #-}
instance Hat.PreludeBasic.Read Hat.Hat.Tuple0;

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

{-# NEED #-}
instance Hat.PreludeBasic.Read Hat.PreludeBasic.Ordering;

{-# NEED #-}
instance Hat.PreludeBasic.Read Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Read Prelude.Double;

{-# NEED #-}
instance Hat.PreludeBasic.Read Prelude.Integer;

{-# NEED #-}
instance Hat.PreludeBasic.Read Prelude.Bool;

{-# NEED #-}
instance (Hat.PreludeBasic.Read a,Hat.PreludeBasic.Read b) => Hat.PreludeBasic.Read (Hat.Hat.Tuple2 a b);

{-# NEED #-}
instance (Hat.PreludeBasic.Read a) => Hat.PreludeBasic.Read (Hat.Hat.List a);

{-# NEED #-}
instance Hat.PreludeBasic.Read Prelude.Int;

{-# NEED #-}
instance Hat.PreludeBasic.Read Prelude.Char;

{-# NEED #-}
instance (Hat.PreludeBasic.Bounded a,Hat.PreludeBasic.Bounded b,Hat.PreludeBasic.Bounded c) => Hat.PreludeBasic.Bounded (Hat.Hat.Tuple3 a b c);

{-# NEED #-}
instance Hat.PreludeBasic.Bounded Hat.Hat.Tuple0;

{-# NEED #-}
instance Hat.PreludeBasic.Bounded Hat.PreludeBasic.Ordering;

{-# NEED #-}
instance Hat.PreludeBasic.Bounded Prelude.Bool;

{-# NEED #-}
instance (Hat.PreludeBasic.Bounded a,Hat.PreludeBasic.Bounded b) => Hat.PreludeBasic.Bounded (Hat.Hat.Tuple2 a b);

{-# NEED #-}
instance Hat.PreludeBasic.Bounded Prelude.Int;

{-# NEED #-}
instance Hat.PreludeBasic.Bounded Prelude.Char;

{-# NEED #-}
instance (Hat.PreludeBasic.Ord a,Hat.PreludeBasic.Ord b) => Hat.PreludeBasic.Ord (Hat.PreludeBasic.Either a b);

{-# NEED #-}
instance (Hat.PreludeBasic.Ord a,Hat.PreludeBasic.Ord b,Hat.PreludeBasic.Ord c) => Hat.PreludeBasic.Ord (Hat.Hat.Tuple3 a b c);

{-# NEED #-}
instance (Hat.PreludeBasic.Ord a) => Hat.PreludeBasic.Ord (Hat.PreludeBasic.Maybe a);

{-# NEED #-}
instance Hat.PreludeBasic.Ord Hat.Hat.Tuple0;

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

{-# NEED #-}
instance Hat.PreludeBasic.Ord Hat.PreludeBasic.Ordering;

{-# NEED #-}
instance Hat.PreludeBasic.Ord Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Ord Prelude.Double;

{-# NEED #-}
instance Hat.PreludeBasic.Ord Prelude.Integer;

{-# NEED #-}
instance Hat.PreludeBasic.Ord Prelude.Bool;

{-# NEED #-}
instance (Hat.PreludeBasic.Ord a,Hat.PreludeBasic.Ord b) => Hat.PreludeBasic.Ord (Hat.Hat.Tuple2 a b);

{-# NEED #-}
instance (Hat.PreludeBasic.Ord a) => Hat.PreludeBasic.Ord (Hat.Hat.List a);

{-# NEED #-}
instance Hat.PreludeBasic.Ord Prelude.Int;

{-# NEED #-}
instance Hat.PreludeBasic.Ord Prelude.Char;

{-# NEED #-}
instance (Hat.PreludeBasic.Eq a,Hat.PreludeBasic.Eq b) => Hat.PreludeBasic.Eq (Hat.PreludeBasic.Either a b);

{-# NEED #-}
instance (Hat.PreludeBasic.Eq a,Hat.PreludeBasic.Eq b,Hat.PreludeBasic.Eq c) => Hat.PreludeBasic.Eq (Hat.Hat.Tuple3 a b c);

{-# NEED #-}
instance (Hat.PreludeBasic.Eq a) => Hat.PreludeBasic.Eq (Hat.PreludeBasic.Maybe a);

{-# NEED #-}
instance Hat.PreludeBasic.Eq Hat.Hat.Tuple0;

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

{-# NEED #-}
instance Hat.PreludeBasic.Eq Hat.PreludeBasic.Ordering;

{-# NEED #-}
instance Hat.PreludeBasic.Eq Prelude.Float;

{-# NEED #-}
instance Hat.PreludeBasic.Eq Prelude.Double;

{-# NEED #-}
instance Hat.PreludeBasic.Eq Prelude.Integer;

{-# NEED #-}
instance Hat.PreludeBasic.Eq Prelude.Bool;

{-# NEED #-}
instance (Hat.PreludeBasic.Eq a,Hat.PreludeBasic.Eq b) => Hat.PreludeBasic.Eq (Hat.Hat.Tuple2 a b);

{-# NEED #-}
instance (Hat.PreludeBasic.Eq a) => Hat.PreludeBasic.Eq (Hat.Hat.List a);

{-# NEED #-}
instance Hat.PreludeBasic.Eq Prelude.Int;

{-# NEED #-}
instance Hat.PreludeBasic.Eq Prelude.Char;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface IO
{-# NEED BufferMode #-}
data BufferMode;
interface NHC.FFI
{-# NEED CChar #-}
newtype {-#  #-} CChar;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;

{-# NEED HandlePosn #-}
data HandlePosn;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface NHC.FFI
{-# NEED Ptr #-}
data Ptr a;
interface Hat.Hat
{-# NEED IO #-}
newtype {-#  #-} IO a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface IO
{-# NEED IOMode #-}
data IOMode;

{-# NEED SeekMode #-}
data SeekMode;
interface Hat.PreludeBasic
{-# NEED Read #-}
class Read a;

{-# NEED Bounded #-}
class Bounded a;

{-# NEED Either #-}
data Either a b;
interface Hat.Hat
{-# NEED Tuple3 #-}
data Tuple3 a b c;
interface Hat.PreludeBasic
{-# NEED Maybe #-}
data Maybe a;
interface Hat.Hat
{-# NEED Tuple0 #-}
data Tuple0;
interface Hat.PreludeBasic
{-# NEED Ratio #-}
data (Integral a) => Ratio a;

{-# NEED Integral #-}
class (Hat.PreludeBasic.Real a,Hat.PreludeBasic.Enum a) => Integral a;

{-# NEED Enum #-}
class Enum a;

{-# NEED Real #-}
class (Hat.PreludeBasic.Num a,Hat.PreludeBasic.Ord a) => Real a;

{-# NEED Ord #-}
class (Hat.PreludeBasic.Eq a) => Ord a;

{-# NEED Num #-}
class (Hat.PreludeBasic.Eq a,Hat.PreludeBasic.Show a) => Num a;

{-# NEED Show #-}
class Show a;

{-# NEED Ordering #-}
data Ordering;

{-# NEED Eq #-}
class Eq a;
interface ! Hat.PreludeBuiltin
{-# NEED atoLower #-}
atoLower{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED gtoLower #-}
gtoLower{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Char))));

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

{-# NEED gtoUpper #-}
gtoUpper{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Char))));

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

{-# NEED gisAlphaNum #-}
gisAlphaNum{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisHexDigit #-}
gisHexDigit{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisOctDigit #-}
gisOctDigit{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisDigit #-}
gisDigit{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisAlpha #-}
gisAlpha{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisLower #-}
gisLower{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisUpper #-}
gisUpper{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisSpace #-}
gisSpace{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisPrint #-}
gisPrint{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisControl #-}
gisControl{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisLatin1 #-}
gisLatin1{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));

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

{-# NEED gisAscii #-}
gisAscii{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool))));
interface ! Hat.PreludeBasic
{-# NEED gdigitToInt #-}
gdigitToInt{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Int))));

{-# NEED hdigitToInt #-}
hdigitToInt{-# 2 #-}::((Hat.Hat.R Prelude.Char) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Int)));

{-# NEED gintToDigit #-}
gintToDigit{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int Prelude.Char))));

{-# NEED hintToDigit #-}
hintToDigit{-# 2 #-}::((Hat.Hat.R Prelude.Int) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Char)));

{-# NEED gord #-}
gord{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Int))));

{-# NEED gchr #-}
gchr{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int Prelude.Char))));

{-# NEED greadLitChar #-}
greadLitChar{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS Prelude.Char))));

{-# NEED hreadLitChar #-}
hreadLitChar{-# 2 #-}::((Hat.Hat.R (Hat.PreludeBasic.ReadS___1 Prelude.Char)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS___2 Prelude.Char))));

{-# NEED gshowLitChar #-}
gshowLitChar{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Char Hat.PreludeBasic.ShowS))));

{-# NEED hshowLitChar #-}
hshowLitChar{-# 2 #-}::((Hat.Hat.R Prelude.Char) -> (Hat.Hat.RefExp -> (Hat.Hat.R Hat.PreludeBasic.ShowS)));
interface Hat.PreludeBasic
{-# NEED ShowS #-}
type {-# 5 #-} ShowS = (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String Hat.PreludeBuiltinTypes.String);
interface ! Hat.PreludeBasic
{-# NEED glexLitChar #-}
glexLitChar{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS Hat.PreludeBuiltinTypes.String))));
interface Hat.PreludeBasic
{-# NEED ReadS #-}
type {-# 2 #-} ReadS a = (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.List (Hat.Hat.Tuple2 a Hat.PreludeBuiltinTypes.String)));
interface Hat.Hat
{-# NEED Fun #-}
newtype {-#  #-} Fun a b;

{-# NEED RefSrcPos #-}
newtype {-#  #-} RefSrcPos;
interface ! Hat.PreludeBasic
{-# NEED hlexLitChar #-}
hlexLitChar{-# 2 #-}::((Hat.Hat.R (Hat.PreludeBasic.ReadS___1 Hat.PreludeBuiltinTypes.String)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS___2 Hat.PreludeBuiltinTypes.String))));
interface Hat.PreludeBasic
{-# NEED ReadS___2 #-}
type {-# 4 #-} ReadS___2 a = (Hat.Hat.List (Hat.Hat.Tuple2 a Hat.PreludeBuiltinTypes.String));
interface Hat.Hat
{-# NEED Tuple2 #-}
data Tuple2 a b;
interface Hat.PreludeBasic
{-# NEED ReadS___1 #-}
type {-# 3 #-} ReadS___1 a = Hat.PreludeBuiltinTypes.String;
interface ! Hat.PreludeBuiltinTypes
{-# NEED String #-}
type {-# 1 #-} String = (Hat.Hat.List Prelude.Char);
interface ! Prelude
{-# NEED Char #-}
data Char;
interface Hat.Hat
{-# NEED List #-}
data List a;

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

{-# NEED RefExp #-}
newtype {-#  #-} RefExp;
interface ! Hat.PreludeBasic
{-# NEED adigitToInt #-}
adigitToInt{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

{-# NEED alexLitChar #-}
alexLitChar{-# 0 #-}::Hat.Hat.RefAtom;
interface Hat.Hat
{-# NEED RefAtom #-}
newtype {-#  #-} RefAtom;
}
