interface Hat.Prelude where {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 o) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 b,Hat.PreludeBasic.Ord c) => Hat.PreludeBasic.Ord (Hat.Hat.Tuple3 a b c);

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

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

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

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

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

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

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

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

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

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

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

{-# 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 b,Hat.PreludeBasic.Eq c) => Hat.PreludeBasic.Eq (Hat.Hat.Tuple3 a b c);

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 b,Hat.PreludeBasic.Show c) => Hat.PreludeBasic.Show (Hat.Hat.Tuple3 a b c);

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

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

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

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

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

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

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

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

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

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

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

{-# 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 b,Hat.PreludeBasic.Read c) => Hat.PreludeBasic.Read (Hat.Hat.Tuple3 a b c);

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Read Hat.Hat.Tuple0;
interface NHC.FFI
{-# NEED Ptr #-}
data Ptr a;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED HandlePosn #-}
data HandlePosn;

{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface NHC.FFI
{-# NEED CChar #-}
newtype {-#  #-} CChar;
interface IO
{-# NEED BufferMode #-}
data BufferMode;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface IO
{-# NEED SeekMode #-}
data SeekMode;

{-# NEED IOMode #-}
data IOMode;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface ! Hat.PreludeBuiltin
{-# NEED aappendFile #-}
aappendFile{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

{-# NEED happendFile #-}
happendFile{-# 3 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> ((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED gappendFile #-}
gappendFile{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.IO Hat.Hat.Tuple0))))));

{-# NEED hwriteFile #-}
hwriteFile{-# 3 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> ((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED gwriteFile #-}
gwriteFile{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.IO Hat.Hat.Tuple0))))));

{-# NEED hreadFile #-}
hreadFile{-# 2 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.PreludeBuiltinTypes.String))));

{-# NEED greadFile #-}
greadFile{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.IO Hat.PreludeBuiltinTypes.String)))));

{-# NEED ggetContents #-}
ggetContents{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.PreludeBuiltinTypes.String))));

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

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

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

{-# NEED hcatch #-}
hcatch{-# 3 #-}::((Hat.Hat.R (Hat.Hat.IO a)) -> ((Hat.Hat.R (Hat.Hat.Fun Prelude.IOError (Hat.Hat.IO a))) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO a)))));

{-# NEED gcatch #-}
gcatch{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.IO a) (Hat.Hat.Fun (Hat.Hat.Fun Prelude.IOError (Hat.Hat.IO a)) (Hat.Hat.IO a))))));

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

{-# NEED guserError #-}
guserError{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String Prelude.IOError))));

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

{-# NEED gioError #-}
gioError{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.IOError (Hat.Hat.IO a)))));
interface ! Prelude
{-# NEED Double #-}
data Double;

{-# NEED Float #-}
data Float;
interface ! Hat.PreludeBuiltin
{-# NEED hseq #-}
hseq{-# 3 #-}::((Hat.Hat.R a) -> ((Hat.Hat.R b) -> (Hat.Hat.RefExp -> (Hat.Hat.R b))));

{-# NEED gseq #-}
gseq{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b b)))));
interface ! Hat.PreludeBuiltinTypes
{-# NEED aTrue #-}
aTrue{-# 0 #-}::Hat.Hat.RefAtom;

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

{-# NEED gerror #-}
gerror{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String a))));

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

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

{-# NEED gundefined #-}
gundefined{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));
interface ! Hat.PreludeBasic
{-# NEED {RealFloat gexponent gsignificand gscaleFloat gatan2 gfloatRadix gfloatDigits gfloatRange gdecodeFloat gencodeFloat gisNaN gisInfinite gisDenormalized gisNegativeZero gisIEEE sfloatRadix sfloatDigits sfloatRange sdecodeFloat sencodeFloat sexponent ssignificand sscaleFloat sisNaN sisInfinite sisDenormalized sisNegativeZero sisIEEE satan2} #-}
class (Hat.PreludeBasic.RealFrac a,Hat.PreludeBasic.Floating a) => RealFloat a where {
  gexponent{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Int))));
  gsignificand{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gscaleFloat{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun a a)))));
  gatan2{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gfloatRadix{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Integer))));
  gfloatDigits{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Int))));
  gfloatRange{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Tuple2 Prelude.Int Prelude.Int)))));
  gdecodeFloat{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Tuple2 Prelude.Integer Prelude.Int)))));
  gencodeFloat{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer (Hat.Hat.Fun Prelude.Int a)))));
  gisNaN{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool))));
  gisInfinite{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool))));
  gisDenormalized{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool))));
  gisNegativeZero{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool))));
  gisIEEE{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool))));
  sfloatRadix{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Integer));
  sfloatDigits{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Int));
  sfloatRange{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Tuple2 Prelude.Int Prelude.Int)));
  sdecodeFloat{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Tuple2 Prelude.Integer Prelude.Int)));
  sencodeFloat{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Prelude.Integer (Hat.Hat.Fun Prelude.Int a)));
  sexponent{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Int));
  ssignificand{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  sscaleFloat{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun a a)));
  sisNaN{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool));
  sisInfinite{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool));
  sisDenormalized{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool));
  sisNegativeZero{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool));
  sisIEEE{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool));
  satan2{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
};

{-# NEED {Floating (!**) glogBase gsqrt gtan gtanh gpi gexp glog gsin gcos gasin gacos gatan gsinh gcosh gasinh gacosh gatanh spi sexp slog ssqrt (|**) slogBase ssin scos stan sasin sacos satan ssinh scosh stanh sasinh sacosh satanh} #-}
class (Hat.PreludeBasic.Fractional a) => Floating a where {
  (!**){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  glogBase{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gsqrt{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gtan{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gtanh{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gpi{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));
  gexp{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  glog{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gsin{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gcos{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gasin{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gacos{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gatan{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gsinh{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gcosh{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gasinh{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gacosh{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gatanh{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  spi{-# 0 #-}::(Hat.Hat.R a);
  sexp{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  slog{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  ssqrt{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  (|**){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  slogBase{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  ssin{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  scos{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  stan{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  sasin{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  sacos{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  satan{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  ssinh{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  scosh{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  stanh{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  sasinh{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  sacosh{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  satanh{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
};

{-# NEED {RealFrac gtruncate ground gceiling gfloor gproperFraction sproperFraction struncate sround sceiling sfloor} #-}
class (Hat.PreludeBasic.Real a,Hat.PreludeBasic.Fractional a) => RealFrac a where {
  gtruncate{-# 2 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a b))));
  ground{-# 2 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a b))));
  gceiling{-# 2 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a b))));
  gfloor{-# 2 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a b))));
  gproperFraction{-# 2 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Tuple2 b a)))));
  sproperFraction{-# 0 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Tuple2 b a)));
  struncate{-# 0 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.R (Hat.Hat.Fun a b));
  sround{-# 0 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.R (Hat.Hat.Fun a b));
  sceiling{-# 0 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.R (Hat.Hat.Fun a b));
  sfloor{-# 0 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.R (Hat.Hat.Fun a b));
};

{-# NEED gsubtract #-}
gsubtract{-# 2 #-}::(Hat.PreludeBasic.Num a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));

{-# NEED geven #-}
geven{-# 2 #-}::(Hat.PreludeBasic.Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool))));

{-# NEED heven #-}
heven{-# 2 #-}::(Hat.PreludeBasic.Integral a) => ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Bool)));

{-# NEED godd #-}
godd{-# 2 #-}::(Hat.PreludeBasic.Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool))));

{-# NEED ggcd #-}
ggcd{-# 2 #-}::(Hat.PreludeBasic.Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));

{-# NEED hgcd #-}
hgcd{-# 3 #-}::(Hat.PreludeBasic.Integral a) => ((Hat.Hat.R a) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

{-# NEED glcm #-}
glcm{-# 2 #-}::(Hat.PreludeBasic.Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));

{-# NEED hlcm #-}
hlcm{-# 3 #-}::(Hat.PreludeBasic.Integral a) => ((Hat.Hat.R a) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

{-# NEED (!^) #-}
(!^){-# 2 #-}::(Hat.PreludeBasic.Num a,Hat.PreludeBasic.Integral b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b a)))));

{-# NEED (*^) #-}
(*^){-# 3 #-}::(Hat.PreludeBasic.Num a,Hat.PreludeBasic.Integral b) => ((Hat.Hat.R a) -> ((Hat.Hat.R b) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

{-# NEED (!^^) #-}
(!^^){-# 2 #-}::(Hat.PreludeBasic.Fractional a,Hat.PreludeBasic.Integral b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b a)))));

{-# NEED (*^^) #-}
(*^^){-# 3 #-}::(Hat.PreludeBasic.Fractional a,Hat.PreludeBasic.Integral b) => ((Hat.Hat.R a) -> ((Hat.Hat.R b) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

{-# NEED gfromIntegral #-}
gfromIntegral{-# 2 #-}::(Hat.PreludeBasic.Integral a,Hat.PreludeBasic.Num b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a b))));

{-# NEED grealToFrac #-}
grealToFrac{-# 2 #-}::(Hat.PreludeBasic.Real a,Hat.PreludeBasic.Fractional b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a b))));

{-# NEED {Fractional grecip (!/) gfromRational (|/) srecip sfromRational} #-}
class (Hat.PreludeBasic.Num a) => Fractional a where {
  grecip{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  (!/){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gfromRational{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBasic.Rational a))));
  (|/){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  srecip{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  sfromRational{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBasic.Rational a));
};

{-# NEED {Real gtoRational stoRational} {Integral gquot grem gdiv gmod gdivMod gquotRem gtoInteger squot srem sdiv smod squotRem sdivMod stoInteger} Rational Ratio #-}
class (Hat.PreludeBasic.Num a,Hat.PreludeBasic.Ord a) => Real a where {
  gtoRational{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Hat.PreludeBasic.Rational))));
  stoRational{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Hat.PreludeBasic.Rational));
};
class (Hat.PreludeBasic.Real a,Hat.PreludeBasic.Enum a) => Integral a where {
  gquot{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  grem{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gdiv{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gmod{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gdivMod{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.Tuple2 a a))))));
  gquotRem{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.Tuple2 a a))))));
  gtoInteger{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Integer))));
  squot{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  srem{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  sdiv{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  smod{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  squotRem{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.Tuple2 a a))));
  sdivMod{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.Tuple2 a a))));
  stoInteger{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Integer));
};
type {-# 9 #-} Rational = (Hat.PreludeBasic.Ratio Prelude.Integer);
data (Integral a) => Ratio a;

{-# NEED {Enum gsucc ssucc gpred spred genumFrom genumFromTo genumFromThen genumFromThenTo gtoEnum gfromEnum stoEnum sfromEnum senumFrom senumFromThen senumFromTo senumFromThenTo} #-}
class Enum a where {
  gsucc{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  ssucc{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  gpred{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  spred{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  genumFrom{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.List a)))));
  genumFromTo{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.List a))))));
  genumFromThen{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.List a))))));
  genumFromThenTo{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.List a)))))));
  gtoEnum{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int a))));
  gfromEnum{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Prelude.Int))));
  stoEnum{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Prelude.Int a));
  sfromEnum{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Prelude.Int));
  senumFrom{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.List a)));
  senumFromThen{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.List a))));
  senumFromTo{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.List a))));
  senumFromThenTo{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.Fun a (Hat.Hat.List a)))));
};

{-# NEED gsequence #-}
gsequence{-# 2 #-}::(Hat.PreludeBasic.Monad a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List (a b)) (a (Hat.Hat.List b))))));

{-# NEED gsequence_ #-}
gsequence_{-# 2 #-}::(Hat.PreludeBasic.Monad a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List (a b)) (a Hat.Hat.Tuple0)))));

{-# NEED gmapM #-}
gmapM{-# 2 #-}::(Hat.PreludeBasic.Monad b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (b c)) (Hat.Hat.Fun (Hat.Hat.List a) (b (Hat.Hat.List c)))))));

{-# NEED hmapM #-}
hmapM{-# 3 #-}::(Hat.PreludeBasic.Monad b) => ((Hat.Hat.R (Hat.Hat.Fun a (b c))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (b (Hat.Hat.List c))))));

{-# NEED gmapM_ #-}
gmapM_{-# 2 #-}::(Hat.PreludeBasic.Monad b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (b c)) (Hat.Hat.Fun (Hat.Hat.List a) (b Hat.Hat.Tuple0))))));

{-# NEED hmapM_ #-}
hmapM_{-# 3 #-}::(Hat.PreludeBasic.Monad b) => ((Hat.Hat.R (Hat.Hat.Fun a (b c))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (b Hat.Hat.Tuple0)))));

{-# NEED (!=<<) #-}
(!=<<){-# 2 #-}::(Hat.PreludeBasic.Monad b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (b c)) (Hat.Hat.Fun (b a) (b c))))));

{-# NEED (*=<<) #-}
(*=<<){-# 3 #-}::(Hat.PreludeBasic.Monad b) => ((Hat.Hat.R (Hat.Hat.Fun a (b c))) -> ((Hat.Hat.R (b a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (b c)))));

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

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

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

{-# NEED hconst #-}
hconst{-# 3 #-}::((Hat.Hat.R a) -> ((Hat.Hat.R b) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

{-# NEED (!.) #-}
(!.){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a b) (Hat.Hat.Fun (Hat.Hat.Fun c a) (Hat.Hat.Fun c b))))));

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

{-# NEED gflip #-}
gflip{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b c)) (Hat.Hat.Fun b (Hat.Hat.Fun a c))))));

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

{-# NEED (!$) #-}
(!$){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a b) (Hat.Hat.Fun a b)))));

{-# NEED (*$) #-}
(*$){-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a b)) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R b))));

{-# NEED (!$!) #-}
(!$!){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a b) (Hat.Hat.Fun a b)))));

{-# NEED (*$!) #-}
(*$!){-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a b)) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R b))));

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

{-# NEED (*&&) #-}
(*&&){-# 3 #-}::((Hat.Hat.R Prelude.Bool) -> ((Hat.Hat.R Prelude.Bool) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Bool))));

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

{-# NEED (*||) #-}
(*||){-# 3 #-}::((Hat.Hat.R Prelude.Bool) -> ((Hat.Hat.R Prelude.Bool) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Bool))));

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

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

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

{-# NEED {Monad (!>>) gfail (!>>=) greturn (|>>=) (|>>) sreturn sfail} #-}
class Monad a where {
  (!>>){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (a b) (Hat.Hat.Fun (a c) (a c))))));
  gfail{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (a b)))));
  (!>>=){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (a b) (Hat.Hat.Fun (Hat.Hat.Fun b (a c)) (a c))))));
  greturn{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun b (a b)))));
  (|>>=){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun (a b) (Hat.Hat.Fun (Hat.Hat.Fun b (a c)) (a c))));
  (|>>){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun (a b) (Hat.Hat.Fun (a c) (a c))));
  sreturn{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun b (a b)));
  sfail{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (a b)));
};

{-# NEED {Functor gfmap sfmap} #-}
class Functor a where {
  gfmap{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun b c) (Hat.Hat.Fun (a b) (a c))))));
  sfmap{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun b c) (Hat.Hat.Fun (a b) (a c))));
};

{-# NEED gmaybe #-}
gmaybe{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.Fun b a) (Hat.Hat.Fun (Hat.PreludeBasic.Maybe b) a))))));

{-# NEED hmaybe #-}
hmaybe{-# 4 #-}::((Hat.Hat.R a) -> ((Hat.Hat.R (Hat.Hat.Fun b a)) -> ((Hat.Hat.R (Hat.PreludeBasic.Maybe b)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)))));

{-# NEED geither #-}
geither{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a b) (Hat.Hat.Fun (Hat.Hat.Fun c b) (Hat.Hat.Fun (Hat.PreludeBasic.Either a c) b))))));

{-# NEED heither #-}
heither{-# 4 #-}::((Hat.Hat.R (Hat.Hat.Fun a b)) -> ((Hat.Hat.R (Hat.Hat.Fun c b)) -> ((Hat.Hat.R (Hat.PreludeBasic.Either a c)) -> (Hat.Hat.RefExp -> (Hat.Hat.R b)))));

{-# NEED {Either Left Right} #-}
data Either a b
  = Left (Hat.Hat.R a)
  | Right (Hat.Hat.R b);

{-# NEED gfst #-}
gfst{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Tuple2 a b) a))));

{-# NEED hfst #-}
hfst{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Tuple2 a b)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

{-# NEED gsnd #-}
gsnd{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Tuple2 a b) b))));

{-# NEED hsnd #-}
hsnd{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Tuple2 a b)) -> (Hat.Hat.RefExp -> (Hat.Hat.R b)));

{-# NEED gcurry #-}
gcurry{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun (Hat.Hat.Tuple2 a b) c) (Hat.Hat.Fun a (Hat.Hat.Fun b c))))));

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

{-# NEED guncurry #-}
guncurry{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b c)) (Hat.Hat.Fun (Hat.Hat.Tuple2 a b) c)))));

{-# NEED huncurry #-}
huncurry{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b c))) -> ((Hat.Hat.R (Hat.Hat.Tuple2 a b)) -> (Hat.Hat.RefExp -> (Hat.Hat.R c))));

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

{-# NEED huntil #-}
huntil{-# 4 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> ((Hat.Hat.R (Hat.Hat.Fun a a)) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)))));

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

{-# NEED g_foldr #-}
g_foldr{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b b)) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun b b))))));

{-# NEED h_foldr #-}
h_foldr{-# 4 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b b))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> ((Hat.Hat.R b) -> (Hat.Hat.RefExp -> (Hat.Hat.R b)))));

{-# NEED g_filter #-}
g_filter{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Bool (Hat.Hat.Fun (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a)) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a)))))));

{-# NEED h_filter #-}
h_filter{-# 4 #-}::((Hat.Hat.R Prelude.Bool) -> ((Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a))))));

{-# NEED gmap #-}
gmap{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a b) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List b))))));

{-# NEED hmap #-}
hmap{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a b)) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List b)))));

{-# NEED (!++) #-}
(!++){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED (*++) #-}
(*++){-# 3 #-}::((Hat.Hat.R (Hat.Hat.List a)) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

{-# NEED gfilter #-}
gfilter{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a Prelude.Bool) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED hfilter #-}
hfilter{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

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

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

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

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

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

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

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

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

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

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

{-# NEED gnull #-}
gnull{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool))));

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

{-# NEED glength #-}
glength{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Int))));

{-# NEED hlength #-}
hlength{-# 2 #-}::((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Int)));

{-# NEED (!!!) #-}
(!!!){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun Prelude.Int a)))));

{-# NEED (*!!) #-}
(*!!){-# 3 #-}::((Hat.Hat.R (Hat.Hat.List a)) -> ((Hat.Hat.R Prelude.Int) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

{-# NEED gfoldl #-}
gfoldl{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b a)) (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.List b) a))))));

{-# NEED hfoldl #-}
hfoldl{-# 4 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b a))) -> ((Hat.Hat.R a) -> ((Hat.Hat.R (Hat.Hat.List b)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)))));

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

{-# NEED hfoldl1 #-}
hfoldl1{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

{-# NEED gscanl #-}
gscanl{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b a)) (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.List a)))))));

{-# NEED hscanl #-}
hscanl{-# 4 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b a))) -> ((Hat.Hat.R a) -> ((Hat.Hat.R (Hat.Hat.List b)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a))))));

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

{-# NEED hscanl1 #-}
hscanl1{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

{-# NEED gfoldr #-}
gfoldr{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b b)) (Hat.Hat.Fun b (Hat.Hat.Fun (Hat.Hat.List a) b))))));

{-# NEED hfoldr #-}
hfoldr{-# 4 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b b))) -> ((Hat.Hat.R b) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R b)))));

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

{-# NEED hfoldr1 #-}
hfoldr1{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

{-# NEED gscanr #-}
gscanr{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b b)) (Hat.Hat.Fun b (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List b)))))));

{-# NEED hscanr #-}
hscanr{-# 4 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b b))) -> ((Hat.Hat.R b) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List b))))));

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

{-# NEED hscanr1 #-}
hscanr1{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

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

{-# NEED hiterate #-}
hiterate{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a a)) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

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

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

{-# NEED greplicate #-}
greplicate{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun a (Hat.Hat.List a))))));

{-# NEED hreplicate #-}
hreplicate{-# 3 #-}::((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

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

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

{-# NEED gtake #-}
gtake{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED htake #-}
htake{-# 3 #-}::((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

{-# NEED gdrop #-}
gdrop{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED hdrop #-}
hdrop{-# 3 #-}::((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

{-# NEED gsplitAt #-}
gsplitAt{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List a)))))));

{-# NEED hsplitAt #-}
hsplitAt{-# 3 #-}::((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED gtakeWhile #-}
gtakeWhile{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a Prelude.Bool) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED htakeWhile #-}
htakeWhile{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

{-# NEED gdropWhile #-}
gdropWhile{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a Prelude.Bool) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED hdropWhile #-}
hdropWhile{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

{-# NEED gspan #-}
gspan{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a Prelude.Bool) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List a)))))));

{-# NEED hspan #-}
hspan{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED gbreak #-}
gbreak{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a Prelude.Bool) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List a)))))));

{-# NEED hbreak #-}
hbreak{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List a))))));

{-# NEED glines #-}
glines{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.List Hat.PreludeBuiltinTypes.String)))));

{-# NEED hlines #-}
hlines{-# 2 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List Hat.PreludeBuiltinTypes.String))));

{-# NEED gwords #-}
gwords{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.List Hat.PreludeBuiltinTypes.String)))));

{-# NEED hwords #-}
hwords{-# 2 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List Hat.PreludeBuiltinTypes.String))));

{-# NEED gunlines #-}
gunlines{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List Hat.PreludeBuiltinTypes.String) Hat.PreludeBuiltinTypes.String))));

{-# NEED gunwords #-}
gunwords{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List Hat.PreludeBuiltinTypes.String) Hat.PreludeBuiltinTypes.String))));

{-# NEED hunwords #-}
hunwords{-# 2 #-}::((Hat.Hat.R (Hat.Hat.List Hat.PreludeBuiltinTypes.String)) -> (Hat.Hat.RefExp -> (Hat.Hat.R Hat.PreludeBuiltinTypes.String)));

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

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

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

{-# NEED gany #-}
gany{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a Prelude.Bool) (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool)))));

{-# NEED hany #-}
hany{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool))));

{-# NEED gall #-}
gall{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a Prelude.Bool) (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool)))));

{-# NEED hall #-}
hall{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool))));

{-# NEED gelem #-}
gelem{-# 2 #-}::(Hat.PreludeBasic.Eq a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool)))));

{-# NEED helem #-}
helem{-# 2 #-}::(Hat.PreludeBasic.Eq a) => ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool))));

{-# NEED gnotElem #-}
gnotElem{-# 2 #-}::(Hat.PreludeBasic.Eq a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool)))));

{-# NEED hnotElem #-}
hnotElem{-# 2 #-}::(Hat.PreludeBasic.Eq a) => ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) Prelude.Bool))));

{-# NEED glookup #-}
glookup{-# 2 #-}::(Hat.PreludeBasic.Eq a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.List (Hat.Hat.Tuple2 a b)) (Hat.PreludeBasic.Maybe b))))));

{-# NEED hlookup #-}
hlookup{-# 3 #-}::(Hat.PreludeBasic.Eq a) => ((Hat.Hat.R a) -> ((Hat.Hat.R (Hat.Hat.List (Hat.Hat.Tuple2 a b))) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.Maybe b)))));

{-# NEED {Maybe Nothing Just} #-}
data Maybe a
  = Nothing 
  | Just (Hat.Hat.R a);

{-# NEED gsum #-}
gsum{-# 2 #-}::(Hat.PreludeBasic.Num a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) a))));

{-# NEED gproduct #-}
gproduct{-# 2 #-}::(Hat.PreludeBasic.Num a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) a))));

{-# NEED {Num (!-) gnegate (!+) (!*) gabs gsignum gfromInteger (|+) (|-) (|*) snegate sabs ssignum sfromInteger} #-}
class (Hat.PreludeBasic.Eq a,Hat.PreludeBasic.Show a) => Num a where {
  (!-){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gnegate{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  (!+){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  (!*){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gabs{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gsignum{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a a))));
  gfromInteger{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer a))));
  (|+){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  (|-){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  (|*){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  snegate{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  sabs{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  ssignum{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a a));
  sfromInteger{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Prelude.Integer a));
};
interface ! Prelude
{-# NEED Integer #-}
data Integer;
interface ! Hat.PreludeBasic
{-# NEED gmaximum #-}
gmaximum{-# 2 #-}::(Hat.PreludeBasic.Ord a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) a))));

{-# NEED hmaximum #-}
hmaximum{-# 2 #-}::(Hat.PreludeBasic.Ord a) => ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

{-# NEED gminimum #-}
gminimum{-# 2 #-}::(Hat.PreludeBasic.Ord a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) a))));

{-# NEED hminimum #-}
hminimum{-# 2 #-}::(Hat.PreludeBasic.Ord a) => ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

{-# NEED gconcatMap #-}
gconcatMap{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.List b)) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List b))))));

{-# NEED hconcatMap #-}
hconcatMap{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.List b))) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List b)))));

{-# NEED gzip #-}
gzip{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.List (Hat.Hat.Tuple2 a b)))))));

{-# NEED {Bounded gminBound gmaxBound sminBound smaxBound} #-}
class Bounded a where {
  gminBound{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));
  gmaxBound{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));
  sminBound{-# 0 #-}::(Hat.Hat.R a);
  smaxBound{-# 0 #-}::(Hat.Hat.R a);
};

{-# NEED {Ord gcompare (!<=) (!<) (!>=) (!>) gmax gmin scompare (|<) (|<=) (|>=) (|>) smax smin} #-}
class (Hat.PreludeBasic.Eq a) => Ord a where {
  gcompare{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Hat.PreludeBasic.Ordering)))));
  (!<=){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)))));
  (!<){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)))));
  (!>=){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)))));
  (!>){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)))));
  gmax{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  gmin{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)))));
  scompare{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Hat.PreludeBasic.Ordering)));
  (|<){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)));
  (|<=){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)));
  (|>=){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)));
  (|>){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)));
  smax{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
  smin{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a a)));
};

{-# NEED {Ordering LT EQ GT} #-}
data Ordering
  = LT 
  | EQ 
  | GT ;

{-# NEED {Eq (!/=) (!==) (|==) (|/=)} #-}
class Eq a where {
  (!/=){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)))));
  (!==){-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)))));
  (|==){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)));
  (|/=){-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Prelude.Bool)));
};

{-# NEED gzip3 #-}
gzip3{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.Fun (Hat.Hat.List c) (Hat.Hat.List (Hat.Hat.Tuple3 a b c))))))));

{-# NEED gzipWith #-}
gzipWith{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b c)) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.List c)))))));

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

{-# NEED gzipWith3 #-}
gzipWith3{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c d))) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.Fun (Hat.Hat.List c) (Hat.Hat.List d))))))));

{-# NEED hzipWith3 #-}
hzipWith3{-# 5 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c d)))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> ((Hat.Hat.R (Hat.Hat.List b)) -> ((Hat.Hat.R (Hat.Hat.List c)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List d)))))));

{-# NEED gunzip #-}
gunzip{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List (Hat.Hat.Tuple2 a b)) (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List b))))));

{-# NEED gunzip3 #-}
gunzip3{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List (Hat.Hat.Tuple3 a b c)) (Hat.Hat.Tuple3 (Hat.Hat.List a) (Hat.Hat.List b) (Hat.Hat.List c))))));
interface Hat.Hat
{-# NEED Tuple3 #-}
data Tuple3 a b c;
interface ! Hat.PreludeBasic
{-# NEED ShowS___1 #-}
type {-# 6 #-} ShowS___1 = Hat.PreludeBuiltinTypes.String;

{-# NEED ShowS___2 #-}
type {-# 7 #-} ShowS___2 = Hat.PreludeBuiltinTypes.String;

{-# NEED greads #-}
greads{-# 2 #-}::(Hat.PreludeBasic.Read a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS a))));

{-# NEED gshows #-}
gshows{-# 2 #-}::(Hat.PreludeBasic.Show a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Hat.PreludeBasic.ShowS))));

{-# NEED gread #-}
gread{-# 2 #-}::(Hat.PreludeBasic.Read a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String a))));

{-# NEED hread #-}
hread{-# 2 #-}::(Hat.PreludeBasic.Read a) => ((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

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

{-# NEED gshowString #-}
gshowString{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String Hat.PreludeBasic.ShowS))));

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

{-# NEED hshowParen #-}
hshowParen{-# 3 #-}::((Hat.Hat.R Prelude.Bool) -> ((Hat.Hat.R Hat.PreludeBasic.ShowS) -> (Hat.Hat.RefExp -> (Hat.Hat.R Hat.PreludeBasic.ShowS))));

{-# NEED greadParen #-}
greadParen{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Bool (Hat.Hat.Fun (Hat.PreludeBasic.ReadS a) (Hat.PreludeBasic.ReadS a))))));

{-# NEED hreadParen #-}
hreadParen{-# 3 #-}::((Hat.Hat.R Prelude.Bool) -> ((Hat.Hat.R (Hat.PreludeBasic.ReadS a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS a)))));
interface ! Prelude
{-# NEED {Bool False True} #-}
data Bool
  = False 
  | True ;
interface ! Hat.PreludeBasic
{-# NEED glex #-}
glex{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS Hat.PreludeBuiltinTypes.String))));

{-# NEED hlex #-}
hlex{-# 2 #-}::((Hat.Hat.R (Hat.PreludeBasic.ReadS___1 Hat.PreludeBuiltinTypes.String)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS___2 Hat.PreludeBuiltinTypes.String))));

{-# NEED ReadS___2 #-}
type {-# 4 #-} ReadS___2 a = (Hat.Hat.List (Hat.Hat.Tuple2 a Hat.PreludeBuiltinTypes.String));

{-# NEED ReadS___1 #-}
type {-# 3 #-} ReadS___1 a = Hat.PreludeBuiltinTypes.String;

{-# NEED FilePath #-}
type {-# 8 #-} FilePath = Hat.PreludeBuiltinTypes.String;

{-# NEED gputStr #-}
gputStr{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED hputStr #-}
hputStr{-# 2 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))));

{-# NEED gputStrLn #-}
gputStrLn{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED hputStrLn #-}
hputStrLn{-# 2 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))));

{-# NEED gprint #-}
gprint{-# 2 #-}::(Hat.PreludeBasic.Show a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED hprint #-}
hprint{-# 2 #-}::(Hat.PreludeBasic.Show a) => ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))));

{-# NEED {Show gshowsPrec gshow gshowList sshowsPrec sshow sshowList} #-}
class Show a where {
  gshowsPrec{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun a Hat.PreludeBasic.ShowS)))));
  gshow{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a Hat.PreludeBuiltinTypes.String))));
  gshowList{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) Hat.PreludeBasic.ShowS))));
  sshowsPrec{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun a Hat.PreludeBasic.ShowS)));
  sshow{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun a Hat.PreludeBuiltinTypes.String));
  sshowList{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) Hat.PreludeBasic.ShowS));
};

{-# NEED ShowS #-}
type {-# 5 #-} ShowS = (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String Hat.PreludeBuiltinTypes.String);

{-# NEED ggetLine #-}
ggetLine{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.PreludeBuiltinTypes.String))));

{-# NEED ginteract #-}
ginteract{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String Hat.PreludeBuiltinTypes.String) (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED hinteract #-}
hinteract{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String Hat.PreludeBuiltinTypes.String)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))));
interface Hat.Hat
{-# NEED Tuple0 #-}
data Tuple0;
interface ! Hat.PreludeBasic
{-# NEED greadIO #-}
greadIO{-# 2 #-}::(Hat.PreludeBasic.Read a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.IO a)))));

{-# NEED hreadIO #-}
hreadIO{-# 2 #-}::(Hat.PreludeBasic.Read a) => ((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO a))));

{-# NEED greadLn #-}
greadLn{-# 2 #-}::(Hat.PreludeBasic.Read a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO a))));
interface ! Hat.Hat
{-# NEED {IO} #-}
newtype {-#  #-} IO a
  = Unexported.Constr_92 (NHC.Internal.IO (Hat.Hat.R a));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;
interface ! Prelude
{-# NEED IOError #-}
data IOError;
interface NHC.Internal
{-# NEED World #-}
data World;
interface ! Hat.PreludeBasic
{-# NEED {Read greadList sreadList greadsPrec sreadsPrec} #-}
class Read a where {
  greadList{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.ReadS (Hat.Hat.List a)))));
  sreadList{-# 0 #-}::(Hat.Hat.R (Hat.PreludeBasic.ReadS (Hat.Hat.List a)));
  greadsPrec{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.PreludeBasic.ReadS a)))));
  sreadsPrec{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.PreludeBasic.ReadS a)));
};

{-# 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 Tuple2 #-}
data Tuple2 a b;
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 Fun #-}
newtype {-#  #-} Fun a b;

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

{-# NEED RefExp #-}
newtype {-#  #-} RefExp;

{-# NEED RefSrcPos #-}
newtype {-#  #-} RefSrcPos;
interface ! Hat.PreludeBasic
{-# NEED aNothing #-}
aNothing{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

{-# NEED (+^) #-}
(+^){-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED (+^^) #-}
(+^^){-# 0 #-}::Hat.Hat.RefAtom;

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

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

{-# NEED (+=<<) #-}
(+=<<){-# 0 #-}::Hat.Hat.RefAtom;

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

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

{-# NEED (+.) #-}
(+.){-# 0 #-}::Hat.Hat.RefAtom;

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

{-# NEED (+$) #-}
(+$){-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED (+$!) #-}
(+$!){-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED (+&&) #-}
(+&&){-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED (+||) #-}
(+||){-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

{-# NEED (+++) #-}
(+++){-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

{-# NEED (+!!) #-}
(+!!){-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED areadIO #-}
areadIO{-# 0 #-}::Hat.Hat.RefAtom;
interface Hat.Hat
{-# NEED RefAtom #-}
newtype {-#  #-} RefAtom;
interface ! Prelude
{-# NEED Int #-}
data Int;
}
