interface Hat.PreludeBuiltin where {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);
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 SeekMode #-}
data SeekMode;

{-# NEED IOMode #-}
data IOMode;

{-# NEED BufferMode #-}
data BufferMode;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio 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 aprimIOErrorShow #-}
aprimIOErrorShow{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 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)))));
interface Hat.Hat
{-# NEED Tuple0 #-}
data Tuple0;
interface ! Hat.PreludeBuiltin
{-# 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)))));

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

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

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

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

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

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

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

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

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

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

{-# NEED hprimDoubleMul #-}
hprimDoubleMul{-# 3 #-}::((Hat.Hat.R Prelude.Double) -> ((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Double))));

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

{-# NEED hprimDoubleSub #-}
hprimDoubleSub{-# 3 #-}::((Hat.Hat.R Prelude.Double) -> ((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Double))));

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

{-# NEED hprimDoubleAdd #-}
hprimDoubleAdd{-# 3 #-}::((Hat.Hat.R Prelude.Double) -> ((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Double))));

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

{-# NEED hprimDoubleDiv #-}
hprimDoubleDiv{-# 3 #-}::((Hat.Hat.R Prelude.Double) -> ((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Double))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hprimEncodeDouble #-}
hprimEncodeDouble{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Int) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Double))));

{-# NEED gprimEncodeDouble #-}
gprimEncodeDouble{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer (Hat.Hat.Fun Prelude.Int Prelude.Double)))));

{-# NEED hprimDecodeDouble #-}
hprimDecodeDouble{-# 2 #-}::((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 Prelude.Integer Prelude.Int))));

{-# NEED gprimDecodeDouble #-}
gprimDecodeDouble{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Double (Hat.Hat.Tuple2 Prelude.Integer Prelude.Int)))));

{-# NEED hprimDoubleRange #-}
hprimDoubleRange{-# 2 #-}::((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 Prelude.Int Prelude.Int))));

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

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

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

{-# NEED hprimDoubleRadix #-}
hprimDoubleRadix{-# 2 #-}::((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Integer)));

{-# NEED gprimDoubleRadix #-}
gprimDoubleRadix{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Double Prelude.Integer))));

{-# NEED hprimDoubleFromInteger #-}
hprimDoubleFromInteger{-# 2 #-}::((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Double)));

{-# NEED gprimDoubleFromInteger #-}
gprimDoubleFromInteger{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer Prelude.Double))));

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

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

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

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

{-# NEED hprimFloatMul #-}
hprimFloatMul{-# 3 #-}::((Hat.Hat.R Prelude.Float) -> ((Hat.Hat.R Prelude.Float) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Float))));

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

{-# NEED hprimFloatSub #-}
hprimFloatSub{-# 3 #-}::((Hat.Hat.R Prelude.Float) -> ((Hat.Hat.R Prelude.Float) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Float))));

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

{-# NEED hprimFloatAdd #-}
hprimFloatAdd{-# 3 #-}::((Hat.Hat.R Prelude.Float) -> ((Hat.Hat.R Prelude.Float) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Float))));

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

{-# NEED hprimFloatDiv #-}
hprimFloatDiv{-# 3 #-}::((Hat.Hat.R Prelude.Float) -> ((Hat.Hat.R Prelude.Float) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Float))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hprimEncodeFloat #-}
hprimEncodeFloat{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Int) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Float))));

{-# NEED gprimEncodeFloat #-}
gprimEncodeFloat{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer (Hat.Hat.Fun Prelude.Int Prelude.Float)))));

{-# NEED hprimDecodeFloat #-}
hprimDecodeFloat{-# 2 #-}::((Hat.Hat.R Prelude.Float) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 Prelude.Integer Prelude.Int))));

{-# NEED gprimDecodeFloat #-}
gprimDecodeFloat{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Float (Hat.Hat.Tuple2 Prelude.Integer Prelude.Int)))));

{-# NEED hprimFloatRange #-}
hprimFloatRange{-# 2 #-}::((Hat.Hat.R Prelude.Float) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 Prelude.Int Prelude.Int))));

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

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

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

{-# NEED hprimFloatRadix #-}
hprimFloatRadix{-# 2 #-}::((Hat.Hat.R Prelude.Float) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Integer)));

{-# NEED gprimFloatRadix #-}
gprimFloatRadix{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Float Prelude.Integer))));

{-# NEED hprimFloatFromInteger #-}
hprimFloatFromInteger{-# 2 #-}::((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Float)));

{-# NEED gprimFloatFromInteger #-}
gprimFloatFromInteger{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer Prelude.Float))));

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

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

{-# NEED hprimIntegerMul #-}
hprimIntegerMul{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Integer))));

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

{-# NEED hprimIntegerSub #-}
hprimIntegerSub{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Integer))));

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

{-# NEED hprimIntegerAdd #-}
hprimIntegerAdd{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Integer))));

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

{-# NEED hprimIntegerQuotRem #-}
hprimIntegerQuotRem{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 Prelude.Integer Prelude.Integer)))));

{-# NEED gprimIntegerQuotRem #-}
gprimIntegerQuotRem{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer (Hat.Hat.Fun Prelude.Integer (Hat.Hat.Tuple2 Prelude.Integer Prelude.Integer))))));
interface Hat.Hat
{-# NEED Tuple2 #-}
data Tuple2 a b;
interface ! Hat.PreludeBuiltin
{-# NEED hprimIntegerRem #-}
hprimIntegerRem{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Integer))));

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

{-# NEED hprimIntegerQuot #-}
hprimIntegerQuot{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Integer))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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))));

{-# 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 ! Prelude
{-# NEED Integer #-}
data Integer;

{-# NEED Float #-}
data Float;

{-# NEED Double #-}
data Double;
interface ! Hat.Hat
{-# NEED {IO} #-}
newtype {-#  #-} IO a
  = Unexported.Constr_137 (NHC.Internal.IO (Hat.Hat.R a));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

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

{-# NEED aFalse #-}
aFalse{-# 0 #-}::Hat.Hat.RefAtom;
interface ! Prelude
{-# NEED IOError #-}
data IOError;
interface ! Hat.PreludeBuiltinTypes
{-# NEED gerror #-}
gerror{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String a))));
interface Hat.Hat
{-# NEED Fun #-}
newtype {-#  #-} Fun a b;
interface ! Hat.PreludeBuiltinTypes
{-# NEED herror #-}
herror{-# 2 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> a));

{-# NEED String #-}
type {-# 1 #-} String = (Hat.Hat.List Prelude.Char);
interface Hat.Hat
{-# NEED List #-}
data List a;
interface ! Hat.PreludeBuiltinTypes
{-# NEED aerror #-}
aerror{-# 0 #-}::Hat.Hat.RefAtom;
interface Hat.Hat
{-# NEED RefAtom #-}
newtype {-#  #-} RefAtom;
interface ! Hat.PreludeBuiltinTypes
{-# NEED gundefined #-}
gundefined{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));
interface Hat.Hat
{-# NEED R #-}
data R a;

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

{-# NEED RefSrcPos #-}
newtype {-#  #-} RefSrcPos;
interface ! Prelude
{-# NEED Int #-}
data Int;

{-# NEED {Bool False True} #-}
data Bool
  = False 
  | True ;

{-# NEED Char #-}
data Char;
}
