interface Hat.Monad where {

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

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

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

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

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

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

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

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

{-# NEED #-}
instance MonadPlus Hat.Hat.List;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Monad Hat.Hat.List;
interface Hat.PreludeBasic
{-# NEED #-}
class Bounded a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

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

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

{-# NEED IOMode #-}
data IOMode;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface Hat.PreludeBasic
{-# NEED Show #-}
class Show a;

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

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

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

{-# NEED Ordering #-}
data Ordering;

{-# NEED Maybe #-}
data Maybe a;
interface ! Hat.Monad
{-# NEED aliftM5 #-}
aliftM5{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hliftM5 #-}
hliftM5{-# 2 #-}::(Hat.PreludeBasic.Monad g) => ((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c (Hat.Hat.Fun d (Hat.Hat.Fun e f)))))) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (g a) (Hat.Hat.Fun (g b) (Hat.Hat.Fun (g c) (Hat.Hat.Fun (g d) (Hat.Hat.Fun (g e) (g f)))))))));

{-# NEED gliftM5 #-}
gliftM5{-# 2 #-}::(Hat.PreludeBasic.Monad g) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c (Hat.Hat.Fun d (Hat.Hat.Fun e f))))) (Hat.Hat.Fun (g a) (Hat.Hat.Fun (g b) (Hat.Hat.Fun (g c) (Hat.Hat.Fun (g d) (Hat.Hat.Fun (g e) (g f))))))))));

{-# NEED hliftM4 #-}
hliftM4{-# 2 #-}::(Hat.PreludeBasic.Monad f) => ((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c (Hat.Hat.Fun d e))))) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (f a) (Hat.Hat.Fun (f b) (Hat.Hat.Fun (f c) (Hat.Hat.Fun (f d) (f e))))))));

{-# NEED gliftM4 #-}
gliftM4{-# 2 #-}::(Hat.PreludeBasic.Monad f) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c (Hat.Hat.Fun d e)))) (Hat.Hat.Fun (f a) (Hat.Hat.Fun (f b) (Hat.Hat.Fun (f c) (Hat.Hat.Fun (f d) (f e)))))))));

{-# NEED hliftM3 #-}
hliftM3{-# 2 #-}::(Hat.PreludeBasic.Monad e) => ((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c d)))) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (e a) (Hat.Hat.Fun (e b) (Hat.Hat.Fun (e c) (e d)))))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED gmapAndUnzipM #-}
gmapAndUnzipM{-# 2 #-}::(Hat.PreludeBasic.Monad b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (b (Hat.Hat.Tuple2 c d))) (Hat.Hat.Fun (Hat.Hat.List a) (b (Hat.Hat.Tuple2 (Hat.Hat.List c) (Hat.Hat.List d))))))));
interface Hat.Hat
{-# NEED Tuple2 #-}
data Tuple2 a b;
interface ! Hat.Monad
{-# NEED hguard #-}
hguard{-# 2 #-}::(MonadPlus a) => ((Hat.Hat.R Prelude.Bool) -> (Hat.Hat.RefExp -> (Hat.Hat.R (a Hat.Hat.Tuple0))));

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

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

{-# NEED hunless #-}
hunless{-# 3 #-}::(Hat.PreludeBasic.Monad a) => ((Hat.Hat.R Prelude.Bool) -> ((Hat.Hat.R (a Hat.Hat.Tuple0)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (a Hat.Hat.Tuple0)))));

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

{-# NEED hwhen #-}
hwhen{-# 3 #-}::(Hat.PreludeBasic.Monad a) => ((Hat.Hat.R Prelude.Bool) -> ((Hat.Hat.R (a Hat.Hat.Tuple0)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (a Hat.Hat.Tuple0)))));

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

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

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

{-# NEED hmsum #-}
hmsum{-# 2 #-}::(MonadPlus a) => ((Hat.Hat.R (Hat.Hat.List (a b))) -> (Hat.Hat.RefExp -> (Hat.Hat.R (a b))));

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

{-# NEED {MonadPlus gmzero gmplus smzero smplus} #-}
class (Hat.PreludeBasic.Monad a) => MonadPlus a where {
  gmzero{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (a b))));
  gmplus{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (a b) (Hat.Hat.Fun (a b) (a b))))));
  smzero{-# 0 #-}::(Hat.Hat.R (a b));
  smplus{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun (a b) (Hat.Hat.Fun (a b) (a b))));
};
interface ! Hat.PreludeBasic
{-# NEED (+=<<) #-}
(+=<<){-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

{-# NEED Fun #-}
newtype {-#  #-} Fun a b;

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

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

{-# NEED RefSrcPos #-}
newtype {-#  #-} RefSrcPos;
}
