interface Hat.Hat where {

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

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

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l,Ix.Ix m,Ix.Ix n,Ix.Ix o) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l,Ix.Ix m) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j) => Ix.Ix (a,b,c,d,e,f,g,h,i,j);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i) => Ix.Ix (a,b,c,d,e,f,g,h,i);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance NHC.FFI.Storable Prelude.Float;

{-# NEED #-}
instance NHC.FFI.Storable Prelude.Double;

{-# NEED #-}
instance NHC.FFI.Storable Prelude.Char;

{-# NEED #-}
instance NHC.FFI.Storable Prelude.Bool;

{-# NEED #-}
instance NHC.FFI.Storable Prelude.Int;

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

{-# NEED #-}
instance NHC.FFI.Storable (NHC.FFI.Ptr a);
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;

{-# NEED BufferMode #-}
data BufferMode;

{-# NEED HandlePosn #-}
data HandlePosn;

{-# NEED IOMode #-}
data IOMode;

{-# NEED SeekMode #-}
data SeekMode;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface NHC.FFI
{-# NEED CChar #-}
newtype {-#  #-} CChar;

{-# NEED Ptr #-}
data Ptr a;
interface ! Hat.Hat
{-# NEED mkAbstract #-}
mkAbstract{-# 1 #-}::(Prelude.String -> RefAtom);

{-# NEED mkConstructorWFields #-}
mkConstructorWFields{-# 7 #-}::(RefModule -> (Loc -> (Loc -> (Fixity -> (Arity -> (Prelude.String -> ([RefAtom] -> RefAtom)))))));

{-# NEED mkConstructor #-}
mkConstructor{-# 6 #-}::(RefModule -> (Loc -> (Loc -> (Fixity -> (Arity -> (Prelude.String -> RefAtom))))));

{-# NEED mkVariable #-}
mkVariable{-# 7 #-}::(RefModule -> (Loc -> (Loc -> (Fixity -> (Arity -> (Prelude.String -> (Prelude.Bool -> RefAtom)))))));

{-# NEED mkDoLambda #-}
mkDoLambda{-# 0 #-}::RefAtom;

{-# NEED mkLambda #-}
mkLambda{-# 0 #-}::RefAtom;

{-# NEED mkValueUse #-}
mkValueUse{-# 3 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> RefExp)));

{-# NEED mkValueApp15 #-}
mkValueApp15{-# 18 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))))))))))));

{-# NEED mkValueApp14 #-}
mkValueApp14{-# 17 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))))))))))));

{-# NEED mkValueApp13 #-}
mkValueApp13{-# 16 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))))))))));

{-# NEED mkValueApp12 #-}
mkValueApp12{-# 15 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))))))))));

{-# NEED mkValueApp11 #-}
mkValueApp11{-# 14 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))))))));

{-# NEED mkValueApp10 #-}
mkValueApp10{-# 13 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))))))));

{-# NEED mkValueApp9 #-}
mkValueApp9{-# 12 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))))));

{-# NEED mkValueApp8 #-}
mkValueApp8{-# 11 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))))));

{-# NEED mkValueApp7 #-}
mkValueApp7{-# 10 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))));

{-# NEED mkValueApp6 #-}
mkValueApp6{-# 9 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))));

{-# NEED mkValueApp5 #-}
mkValueApp5{-# 8 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))));

{-# NEED mkValueApp4 #-}
mkValueApp4{-# 7 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))));

{-# NEED mkValueApp3 #-}
mkValueApp3{-# 6 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> (RefExp -> RefExp))))));

{-# NEED mkValueApp2 #-}
mkValueApp2{-# 5 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> (RefExp -> RefExp)))));

{-# NEED mkValueApp1 #-}
mkValueApp1{-# 4 #-}::(RefExp -> (RefSrcPos -> (RefAtom -> (RefExp -> RefExp))));

{-# NEED mkApp15 #-}
mkApp15{-# 18 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))))))))))));

{-# NEED mkApp14 #-}
mkApp14{-# 17 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))))))))))));

{-# NEED mkApp13 #-}
mkApp13{-# 16 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))))))))));

{-# NEED mkApp12 #-}
mkApp12{-# 15 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))))))))));

{-# NEED mkApp11 #-}
mkApp11{-# 14 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))))))));

{-# NEED mkApp10 #-}
mkApp10{-# 13 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))))))));

{-# NEED mkApp9 #-}
mkApp9{-# 12 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))))));

{-# NEED mkApp8 #-}
mkApp8{-# 11 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))))));

{-# NEED mkApp7 #-}
mkApp7{-# 10 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))))));

{-# NEED mkApp6 #-}
mkApp6{-# 9 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))))));

{-# NEED mkApp5 #-}
mkApp5{-# 8 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))))));

{-# NEED mkApp4 #-}
mkApp4{-# 7 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp)))))));

{-# NEED mkApp3 #-}
mkApp3{-# 6 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> (RefExp -> RefExp))))));

{-# NEED mkApp2 #-}
mkApp2{-# 5 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> (RefExp -> RefExp)))));

{-# NEED mkApp1 #-}
mkApp1{-# 4 #-}::(RefExp -> (RefSrcPos -> (RefExp -> (RefExp -> RefExp))));

{-# NEED mkSrcPos #-}
mkSrcPos{-# 3 #-}::(RefModule -> (Prelude.Int -> (Prelude.Int -> RefSrcPos)));

{-# NEED mkModule #-}
mkModule{-# 3 #-}::(Prelude.String -> (Prelude.String -> (Prelude.Bool -> RefModule)));

{-# NEED mkRoot #-}
mkRoot{-# 0 #-}::RefExp;

{-# NEED outputTrace #-}
outputTrace{-# 2 #-}::(RefExp -> (Prelude.String -> (NHC.Internal.IO ())));

{-# NEED uapp5 #-}
uapp5{-# 10 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (RefExp -> (R f))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (R f)))))))))));

{-# NEED uapp4 #-}
uapp4{-# 9 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> (RefExp -> (R e)))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> (R e))))))))));

{-# NEED uapp3 #-}
uapp3{-# 8 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> ((R b) -> ((R c) -> (RefExp -> (R d))))) -> ((R a) -> ((R b) -> ((R c) -> (R d)))))))));

{-# NEED uapp2 #-}
uapp2{-# 7 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> ((R b) -> (RefExp -> (R c)))) -> ((R a) -> ((R b) -> (R c))))))));

{-# NEED uapp1 #-}
uapp1{-# 6 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> (RefExp -> (R b))) -> ((R a) -> (R b)))))));

{-# NEED app5 #-}
app5{-# 10 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (RefExp -> (R f))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (R f)))))))))));

{-# NEED app4 #-}
app4{-# 9 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> (RefExp -> (R e)))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> (R e))))))))));

{-# NEED app3 #-}
app3{-# 8 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> ((R b) -> ((R c) -> (RefExp -> (R d))))) -> ((R a) -> ((R b) -> ((R c) -> (R d)))))))));

{-# NEED app2 #-}
app2{-# 7 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> ((R b) -> (RefExp -> (R c)))) -> ((R a) -> ((R b) -> (R c))))))));

{-# NEED app1 #-}
app1{-# 6 #-}::(RefSrcPos -> (RefSrcPos -> (RefExp -> (RefAtom -> (((R a) -> (RefExp -> (R b))) -> ((R a) -> (R b)))))));

{-# NEED fromLitString #-}
fromLitString{-# 3 #-}::(RefSrcPos -> (RefExp -> (Prelude.String -> (R (List Prelude.Char)))));

{-# NEED fromExpList #-}
fromExpList{-# 3 #-}::(RefSrcPos -> (RefExp -> ([(R a)] -> (R (List a)))));

{-# NEED mkAtomRational #-}
mkAtomRational{-# 3 #-}::(RefSrcPos -> (RefExp -> (Ratio.Rational -> RefExp)));
interface Ratio
{-# NEED Rational #-}
type {-# 1 #-} Rational = (Ratio.Ratio Prelude.Integer);

{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! Hat.Hat
{-# NEED conInteger #-}
conInteger{-# 3 #-}::(RefSrcPos -> (RefExp -> (Prelude.Integer -> (R Prelude.Integer))));

{-# NEED conChar #-}
conChar{-# 3 #-}::(RefSrcPos -> (RefExp -> (Prelude.Char -> (R Prelude.Char))));

{-# NEED projection #-}
projection{-# 3 #-}::(RefSrcPos -> (RefExp -> ((R a) -> (R a))));

{-# NEED uupdate #-}
uupdate{-# 3 #-}::(WrapVal a) => (RefExp -> ((R a) -> ((a -> a) -> (R a))));

{-# NEED update2 #-}
update2{-# 8 #-}::(WrapVal a) => (RefSrcPos -> (RefExp -> ((R a) -> ((a -> a) -> (RefAtom -> (RefAtom -> ((R b) -> ((R c) -> (R a)))))))));

{-# NEED update1 #-}
update1{-# 6 #-}::(WrapVal a) => (RefSrcPos -> (RefExp -> ((R a) -> ((a -> a) -> (RefAtom -> ((R b) -> (R a)))))));

{-# NEED {WrapVal wrapVal} #-}
class WrapVal a where {
  wrapVal{-# 3 #-}::(RefSrcPos -> (a -> (RefExp -> (R a))));
};

{-# NEED uccase #-}
uccase{-# 4 #-}::(RefSrcPos -> (RefExp -> (((R a) -> (RefExp -> (R b))) -> ((R a) -> (R b)))));

{-# NEED ccase #-}
ccase{-# 4 #-}::(RefSrcPos -> (RefExp -> (((R a) -> (RefExp -> (R b))) -> ((R a) -> (R b)))));

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

{-# NEED cif #-}
cif{-# 5 #-}::(RefSrcPos -> (RefExp -> ((R Prelude.Bool) -> ((RefExp -> (R a)) -> ((RefExp -> (R a)) -> (R a))))));

{-# NEED ucguard #-}
ucguard{-# 3 #-}::((R Prelude.Bool) -> ((R a) -> ((R a) -> (R a))));

{-# NEED cguard #-}
cguard{-# 5 #-}::(RefSrcPos -> (RefExp -> ((R Prelude.Bool) -> ((RefExp -> (R a)) -> ((RefExp -> (R a)) -> (R a))))));

{-# NEED uconstDef #-}
uconstDef{-# 3 #-}::(RefExp -> (RefAtom -> ((RefExp -> (R a)) -> (R a))));

{-# NEED constDef #-}
constDef{-# 3 #-}::(RefExp -> (RefAtom -> ((RefExp -> (R a)) -> (R a))));

{-# NEED uconstUse #-}
uconstUse{-# 3 #-}::(RefSrcPos -> (RefExp -> ((R a) -> (R a))));

{-# NEED constUse #-}
constUse{-# 3 #-}::(RefSrcPos -> (RefExp -> ((R a) -> (R a))));

{-# NEED cn12 #-}
cn12{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> m)))))))))))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l m)))))))))))))));

{-# NEED cn11 #-}
cn11{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> l))))))))))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k l))))))))))))));

{-# NEED cn10 #-}
cn10{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> k)))))))))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j k)))))))))))));

{-# NEED cn9 #-}
cn9{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> j))))))))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i j))))))))))));

{-# NEED cn8 #-}
cn8{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> i)))))))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h i)))))))))));

{-# NEED cn7 #-}
cn7{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> h))))))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g h))))))))));

{-# NEED cn6 #-}
cn6{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> g)))))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f g)))))))));

{-# NEED cn5 #-}
cn5{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> f))))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d (Fun e f))))))));

{-# NEED cn4 #-}
cn4{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> e)))) -> (RefExp -> (R (Fun a (Fun b (Fun c (Fun d e)))))));

{-# NEED cn3 #-}
cn3{-# 2 #-}::(((R a) -> ((R b) -> ((R c) -> d))) -> (RefExp -> (R (Fun a (Fun b (Fun c d))))));

{-# NEED cn2 #-}
cn2{-# 2 #-}::(((R a) -> ((R b) -> c)) -> (RefExp -> (R (Fun a (Fun b c)))));

{-# NEED cn1 #-}
cn1{-# 2 #-}::(((R a) -> b) -> (RefExp -> (R (Fun a b))));

{-# NEED pa8 #-}
pa8{-# 13 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> i)))))))) -> ((i -> (RefExp -> j)) -> (RefSrcPos -> (RefExp -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> j)))))))))))));

{-# NEED pa7 #-}
pa7{-# 12 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> h))))))) -> ((h -> (RefExp -> i)) -> (RefSrcPos -> (RefExp -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> i))))))))))));

{-# NEED pa6 #-}
pa6{-# 11 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> g)))))) -> ((g -> (RefExp -> h)) -> (RefSrcPos -> (RefExp -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> h)))))))))));

{-# NEED pa5 #-}
pa5{-# 10 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> f))))) -> ((f -> (RefExp -> g)) -> (RefSrcPos -> (RefExp -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> g))))))))));

{-# NEED pa4 #-}
pa4{-# 9 #-}::(((R a) -> ((R b) -> ((R c) -> ((R d) -> e)))) -> ((e -> (RefExp -> f)) -> (RefSrcPos -> (RefExp -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> f)))))))));

{-# NEED pa3 #-}
pa3{-# 8 #-}::(((R a) -> ((R b) -> ((R c) -> d))) -> ((d -> (RefExp -> e)) -> (RefSrcPos -> (RefExp -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> e))))))));

{-# NEED pa2 #-}
pa2{-# 7 #-}::(((R a) -> ((R b) -> c)) -> ((c -> (RefExp -> d)) -> (RefSrcPos -> (RefExp -> (RefAtom -> ((R a) -> ((R b) -> d)))))));

{-# NEED pa1 #-}
pa1{-# 6 #-}::(((R a) -> b) -> ((b -> (RefExp -> c)) -> (RefSrcPos -> (RefExp -> (RefAtom -> ((R a) -> c))))));

{-# NEED pa0 #-}
pa0{-# 5 #-}::(a -> ((a -> (RefExp -> b)) -> (RefSrcPos -> (RefExp -> (RefAtom -> b)))));

{-# NEED con15 #-}
con15{-# 19 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> ((R n) -> ((R o) -> p))))))))))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> ((R n) -> ((R o) -> (R p))))))))))))))))))));

{-# NEED con14 #-}
con14{-# 18 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> ((R n) -> o)))))))))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> ((R n) -> (R o)))))))))))))))))));

{-# NEED con13 #-}
con13{-# 17 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> n))))))))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> (R n))))))))))))))))));

{-# NEED con12 #-}
con12{-# 16 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> m)))))))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> (R m)))))))))))))))));

{-# NEED con11 #-}
con11{-# 15 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> l))))))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> (R l))))))))))))))));

{-# NEED con10 #-}
con10{-# 14 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> k)))))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> (R k)))))))))))))));

{-# NEED con9 #-}
con9{-# 13 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> j))))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> (R j))))))))))))));

{-# NEED con8 #-}
con8{-# 12 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> i)))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> (R i)))))))))))));

{-# NEED con7 #-}
con7{-# 11 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> h))))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> (R h))))))))))));

{-# NEED con6 #-}
con6{-# 10 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> g)))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> (R g)))))))))));

{-# NEED con5 #-}
con5{-# 9 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> f))))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (R f))))))))));

{-# NEED con4 #-}
con4{-# 8 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> e)))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> (R e)))))))));

{-# NEED con3 #-}
con3{-# 7 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> d))) -> (RefAtom -> ((R a) -> ((R b) -> ((R c) -> (R d))))))));

{-# NEED con2 #-}
con2{-# 6 #-}::(RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> c)) -> (RefAtom -> ((R a) -> ((R b) -> (R c)))))));

{-# NEED con1 #-}
con1{-# 5 #-}::(RefSrcPos -> (RefExp -> (((R a) -> b) -> (RefAtom -> ((R a) -> (R b))))));

{-# NEED con0 #-}
con0{-# 4 #-}::(RefSrcPos -> (RefExp -> (a -> (RefAtom -> (R a)))));

{-# NEED ufun8 #-}
ufun8{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> (RefExp -> (R i)))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h i)))))))))))));

{-# NEED ufun7 #-}
ufun7{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> (RefExp -> (R h))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g h))))))))))));

{-# NEED ufun6 #-}
ufun6{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> (RefExp -> (R g)))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f g)))))))))));

{-# NEED ufun5 #-}
ufun5{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (RefExp -> (R f))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e f))))))))));

{-# NEED ufun4 #-}
ufun4{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> (RefExp -> (R e)))))) -> (R (Fun a (Fun b (Fun c (Fun d e)))))))));

{-# NEED ufun3 #-}
ufun3{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> (RefExp -> (R d))))) -> (R (Fun a (Fun b (Fun c d))))))));

{-# NEED ufun2 #-}
ufun2{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> (RefExp -> (R c)))) -> (R (Fun a (Fun b c)))))));

{-# NEED ufun1 #-}
ufun1{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> (RefExp -> (R b))) -> (R (Fun a b))))));

{-# NEED uap8 #-}
uap8{-# 11 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h i))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> (R i))))))))))));

{-# NEED uap7 #-}
uap7{-# 10 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g h)))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> (R h)))))))))));

{-# NEED uap6 #-}
uap6{-# 9 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f g))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> (R g))))))))));

{-# NEED uap5 #-}
uap5{-# 8 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e f)))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (R f)))))))));

{-# NEED uap4 #-}
uap4{-# 7 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d e))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> (R e))))))));

{-# NEED uap3 #-}
uap3{-# 6 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c d)))) -> ((R a) -> ((R b) -> ((R c) -> (R d)))))));

{-# NEED uap2 #-}
uap2{-# 5 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b c))) -> ((R a) -> ((R b) -> (R c))))));

{-# NEED uap1 #-}
uap1{-# 4 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a b)) -> ((R a) -> (R b)))));

{-# NEED fun15 #-}
fun15{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> ((R n) -> ((R o) -> (RefExp -> (R p))))))))))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l (Fun m (Fun n (Fun o p))))))))))))))))))));

{-# NEED fun14 #-}
fun14{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> ((R n) -> (RefExp -> (R o)))))))))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l (Fun m (Fun n o)))))))))))))))))));

{-# NEED fun13 #-}
fun13{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> (RefExp -> (R n))))))))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l (Fun m n))))))))))))))))));

{-# NEED fun12 #-}
fun12{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> (RefExp -> (R m)))))))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l m)))))))))))))))));

{-# NEED fun11 #-}
fun11{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> (RefExp -> (R l))))))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k l))))))))))))))));

{-# NEED fun10 #-}
fun10{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> (RefExp -> (R k)))))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j k)))))))))))))));

{-# NEED fun9 #-}
fun9{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> (RefExp -> (R j))))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i j))))))))))))));

{-# NEED fun8 #-}
fun8{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> (RefExp -> (R i)))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h i)))))))))))));

{-# NEED fun7 #-}
fun7{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> (RefExp -> (R h))))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g h))))))))))));

{-# NEED fun6 #-}
fun6{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> (RefExp -> (R g)))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f g)))))))))));

{-# NEED fun5 #-}
fun5{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (RefExp -> (R f))))))) -> (R (Fun a (Fun b (Fun c (Fun d (Fun e f))))))))));

{-# NEED fun4 #-}
fun4{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> ((R d) -> (RefExp -> (R e)))))) -> (R (Fun a (Fun b (Fun c (Fun d e)))))))));

{-# NEED fun3 #-}
fun3{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> ((R c) -> (RefExp -> (R d))))) -> (R (Fun a (Fun b (Fun c d))))))));

{-# NEED fun2 #-}
fun2{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> ((R b) -> (RefExp -> (R c)))) -> (R (Fun a (Fun b c)))))));

{-# NEED fun1 #-}
fun1{-# 4 #-}::(RefAtom -> (RefSrcPos -> (RefExp -> (((R a) -> (RefExp -> (R b))) -> (R (Fun a b))))));

{-# NEED ap15 #-}
ap15{-# 18 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l (Fun m (Fun n (Fun o p)))))))))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> ((R n) -> ((R o) -> (R p)))))))))))))))))));

{-# NEED ap14 #-}
ap14{-# 17 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l (Fun m (Fun n o))))))))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> ((R n) -> (R o))))))))))))))))));

{-# NEED ap13 #-}
ap13{-# 16 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l (Fun m n)))))))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> ((R m) -> (R n)))))))))))))))));

{-# NEED ap12 #-}
ap12{-# 15 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k (Fun l m))))))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> ((R l) -> (R m))))))))))))))));

{-# NEED ap11 #-}
ap11{-# 14 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j (Fun k l)))))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> ((R k) -> (R l)))))))))))))));

{-# NEED ap10 #-}
ap10{-# 13 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i (Fun j k))))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> ((R j) -> (R k))))))))))))));

{-# NEED ap9 #-}
ap9{-# 12 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h (Fun i j)))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> ((R i) -> (R j)))))))))))));

{-# NEED ap8 #-}
ap8{-# 11 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g (Fun h i))))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> ((R h) -> (R i))))))))))));

{-# NEED ap7 #-}
ap7{-# 10 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f (Fun g h)))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> ((R g) -> (R h)))))))))));

{-# NEED ap6 #-}
ap6{-# 9 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e (Fun f g))))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> ((R f) -> (R g))))))))));

{-# NEED ap5 #-}
ap5{-# 8 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d (Fun e f)))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> ((R e) -> (R f)))))))));

{-# NEED ap4 #-}
ap4{-# 7 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c (Fun d e))))) -> ((R a) -> ((R b) -> ((R c) -> ((R d) -> (R e))))))));

{-# NEED ap3 #-}
ap3{-# 6 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b (Fun c d)))) -> ((R a) -> ((R b) -> ((R c) -> (R d)))))));

{-# NEED ap2 #-}
ap2{-# 5 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a (Fun b c))) -> ((R a) -> ((R b) -> (R c))))));

{-# NEED ap1 #-}
ap1{-# 4 #-}::(RefSrcPos -> (RefExp -> ((R (Fun a b)) -> ((R a) -> (R b)))));

{-# NEED uwrapForward #-}
uwrapForward{-# 2 #-}::(RefExp -> ((R a) -> (R a)));

{-# NEED wrapForward #-}
wrapForward{-# 2 #-}::(RefExp -> ((R a) -> (R a)));

{-# NEED fatal #-}
fatal{-# 1 #-}::(RefExp -> a);

{-# NEED hatError #-}
hatError{-# 2 #-}::(RefExp -> (Prelude.String -> a));

{-# NEED traceIO #-}
traceIO{-# 2 #-}::(Prelude.String -> ((R (IO a)) -> (NHC.Internal.IO ())));

{-# NEED aList #-}
aList{-# 0 #-}::RefAtom;

{-# NEED aCons #-}
aCons{-# 0 #-}::RefAtom;

{-# NEED {List Cons List} #-}
data List a
  = Cons (R a) (R (List a))
  | List ;

{-# NEED fromTuple2 #-}
fromTuple2{-# 4 #-}::((RefExp -> (a -> (R b))) -> ((RefExp -> (c -> (R d))) -> (RefExp -> ((a,c) -> (R (Tuple2 b d))))));

{-# NEED toTuple2 #-}
toTuple2{-# 4 #-}::((RefExp -> ((R a) -> b)) -> ((RefExp -> ((R c) -> d)) -> (RefExp -> ((R (Tuple2 a c)) -> (b,d)))));

{-# NEED fromTuple0 #-}
fromTuple0{-# 2 #-}::(RefExp -> (() -> (R Tuple0)));

{-# NEED toTuple0 #-}
toTuple0{-# 2 #-}::(RefExp -> ((R Tuple0) -> ()));

{-# NEED aTuple15 #-}
aTuple15{-# 0 #-}::RefAtom;

{-# NEED aTuple14 #-}
aTuple14{-# 0 #-}::RefAtom;

{-# NEED aTuple13 #-}
aTuple13{-# 0 #-}::RefAtom;

{-# NEED aTuple12 #-}
aTuple12{-# 0 #-}::RefAtom;

{-# NEED aTuple11 #-}
aTuple11{-# 0 #-}::RefAtom;

{-# NEED aTuple10 #-}
aTuple10{-# 0 #-}::RefAtom;

{-# NEED aTuple9 #-}
aTuple9{-# 0 #-}::RefAtom;

{-# NEED aTuple8 #-}
aTuple8{-# 0 #-}::RefAtom;

{-# NEED aTuple7 #-}
aTuple7{-# 0 #-}::RefAtom;

{-# NEED aTuple6 #-}
aTuple6{-# 0 #-}::RefAtom;

{-# NEED aTuple5 #-}
aTuple5{-# 0 #-}::RefAtom;

{-# NEED aTuple4 #-}
aTuple4{-# 0 #-}::RefAtom;

{-# NEED aTuple3 #-}
aTuple3{-# 0 #-}::RefAtom;

{-# NEED aTuple2 #-}
aTuple2{-# 0 #-}::RefAtom;

{-# NEED aTuple0 #-}
aTuple0{-# 0 #-}::RefAtom;

{-# NEED {Tuple15 Tuple15} #-}
data Tuple15 a b c d e f g h i j k l m n o
  = Tuple15 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k) (R l) (R m) (R n) (R o);

{-# NEED {Tuple14 Tuple14} #-}
data Tuple14 a b c d e f g h i j k l m n
  = Tuple14 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k) (R l) (R m) (R n);

{-# NEED {Tuple13 Tuple13} #-}
data Tuple13 a b c d e f g h i j k l m
  = Tuple13 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k) (R l) (R m);

{-# NEED {Tuple12 Tuple12} #-}
data Tuple12 a b c d e f g h i j k l
  = Tuple12 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k) (R l);

{-# NEED {Tuple11 Tuple11} #-}
data Tuple11 a b c d e f g h i j k
  = Tuple11 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k);

{-# NEED {Tuple10 Tuple10} #-}
data Tuple10 a b c d e f g h i j
  = Tuple10 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j);

{-# NEED {Tuple9 Tuple9} #-}
data Tuple9 a b c d e f g h i
  = Tuple9 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i);

{-# NEED {Tuple8 Tuple8} #-}
data Tuple8 a b c d e f g h
  = Tuple8 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h);

{-# NEED {Tuple7 Tuple7} #-}
data Tuple7 a b c d e f g
  = Tuple7 (R a) (R b) (R c) (R d) (R e) (R f) (R g);

{-# NEED {Tuple6 Tuple6} #-}
data Tuple6 a b c d e f
  = Tuple6 (R a) (R b) (R c) (R d) (R e) (R f);

{-# NEED {Tuple5 Tuple5} #-}
data Tuple5 a b c d e
  = Tuple5 (R a) (R b) (R c) (R d) (R e);

{-# NEED {Tuple4 Tuple4} #-}
data Tuple4 a b c d
  = Tuple4 (R a) (R b) (R c) (R d);

{-# NEED {Tuple3 Tuple3} #-}
data Tuple3 a b c
  = Tuple3 (R a) (R b) (R c);

{-# NEED {Tuple2 Tuple2} #-}
data Tuple2 a b
  = Tuple2 (R a) (R b);

{-# NEED {Tuple0 Tuple0} #-}
data Tuple0
  = Tuple0 ;

{-# NEED fromIO #-}
fromIO{-# 3 #-}::((RefExp -> (a -> (R b))) -> (RefExp -> ((NHC.Internal.IO a) -> (R (IO b)))));

{-# NEED toIO #-}
toIO{-# 3 #-}::((RefExp -> ((R a) -> b)) -> (RefExp -> ((R (IO a)) -> (NHC.Internal.IO b))));

{-# NEED {IO} #-}
newtype {-#  #-} IO a
  = IO (NHC.Internal.IO (R a));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Hat.Hat
{-# NEED {Fun Fun} #-}
newtype {-#  #-} Fun a b
  = Fun (RefExp -> ((R a) -> (R b)));

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

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

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

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

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

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

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

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

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

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

{-# NEED fromId #-}
fromId{-# 2 #-}::(RefExp -> ((R a) -> (R a)));

{-# NEED toId #-}
toId{-# 2 #-}::(RefExp -> ((R a) -> (R a)));

{-# NEED tPrelude #-}
tPrelude{-# 0 #-}::RefModule;

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

{-# NEED Arity #-}
type {-# 3 #-} Arity = Prelude.Int;

{-# NEED Fixity #-}
type {-# 2 #-} Fixity = Prelude.Int;

{-# NEED Loc #-}
type {-# 1 #-} Loc = Prelude.Int;

{-# NEED mkNoSrcPos #-}
mkNoSrcPos{-# 0 #-}::RefSrcPos;

{-# NEED {RefAtom} #-}
newtype {-#  #-} RefAtom
  = RA Prelude.Int;

{-# NEED {RefExp} #-}
newtype {-#  #-} RefExp
  = RT Prelude.Int;

{-# NEED {RefSrcPos} #-}
newtype {-#  #-} RefSrcPos
  = RSP Prelude.Int;

{-# NEED {RefModule} #-}
newtype {-#  #-} RefModule
  = RM Prelude.Int;
interface ! Prelude
{-# NEED Float #-}
data Float;

{-# NEED Double #-}
data Double;

{-# NEED Char #-}
data Char;

{-# NEED Integer #-}
data Integer;

{-# NEED Int #-}
data Int;
}
