interface Hat.List where {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Hat.PreludeBasic.Bounded a,Hat.PreludeBasic.Bounded b,Hat.PreludeBasic.Bounded c,Hat.PreludeBasic.Bounded d,Hat.PreludeBasic.Bounded e,Hat.PreludeBasic.Bounded f) => Hat.PreludeBasic.Bounded (Hat.Hat.Tuple6 a b c d e f);

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Hat.PreludeBasic.Read a,Hat.PreludeBasic.Read b,Hat.PreludeBasic.Read c,Hat.PreludeBasic.Read d,Hat.PreludeBasic.Read e,Hat.PreludeBasic.Read f) => Hat.PreludeBasic.Read (Hat.Hat.Tuple6 a b c d e f);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Hat.PreludeBasic.Ord a,Hat.PreludeBasic.Ord b,Hat.PreludeBasic.Ord c,Hat.PreludeBasic.Ord d,Hat.PreludeBasic.Ord e,Hat.PreludeBasic.Ord f) => Hat.PreludeBasic.Ord (Hat.Hat.Tuple6 a b c d e f);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Hat.PreludeBasic.Show a,Hat.PreludeBasic.Show b,Hat.PreludeBasic.Show c,Hat.PreludeBasic.Show d,Hat.PreludeBasic.Show e,Hat.PreludeBasic.Show f) => Hat.PreludeBasic.Show (Hat.Hat.Tuple6 a b c d e f);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Hat.PreludeBasic.Eq a,Hat.PreludeBasic.Eq b,Hat.PreludeBasic.Eq c,Hat.PreludeBasic.Eq d,Hat.PreludeBasic.Eq e,Hat.PreludeBasic.Eq f) => Hat.PreludeBasic.Eq (Hat.Hat.Tuple6 a b c d e f);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED World #-}
data World;
interface Hat.PreludeBasic
{-# NEED Bounded #-}
class Bounded a;

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

{-# NEED SeekMode #-}
data SeekMode;
interface Hat.PreludeBasic
{-# NEED Either #-}
data Either a b;
interface Hat.Hat
{-# NEED Tuple0 #-}
data Tuple0;
interface Hat.PreludeBasic
{-# NEED Ratio #-}
data (Integral a) => Ratio a;
interface ! Hat.List
{-# NEED azipWith7 #-}
azipWith7{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED gunzip7 #-}
gunzip7{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List (Hat.Hat.Tuple7 a b c d e f g)) (Hat.Hat.Tuple7 (Hat.Hat.List a) (Hat.Hat.List b) (Hat.Hat.List c) (Hat.Hat.List d) (Hat.Hat.List e) (Hat.Hat.List f) (Hat.Hat.List g))))));

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

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

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

{-# NEED hzipWith7 #-}
hzipWith7{-# 9 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c (Hat.Hat.Fun d (Hat.Hat.Fun e (Hat.Hat.Fun f (Hat.Hat.Fun g h)))))))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> ((Hat.Hat.R (Hat.Hat.List b)) -> ((Hat.Hat.R (Hat.Hat.List c)) -> ((Hat.Hat.R (Hat.Hat.List d)) -> ((Hat.Hat.R (Hat.Hat.List e)) -> ((Hat.Hat.R (Hat.Hat.List f)) -> ((Hat.Hat.R (Hat.Hat.List g)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List h)))))))))));

{-# NEED gzipWith7 #-}
gzipWith7{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c (Hat.Hat.Fun d (Hat.Hat.Fun e (Hat.Hat.Fun f (Hat.Hat.Fun g h))))))) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.Fun (Hat.Hat.List c) (Hat.Hat.Fun (Hat.Hat.List d) (Hat.Hat.Fun (Hat.Hat.List e) (Hat.Hat.Fun (Hat.Hat.List f) (Hat.Hat.Fun (Hat.Hat.List g) (Hat.Hat.List h))))))))))));

{-# NEED hzipWith6 #-}
hzipWith6{-# 8 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b (Hat.Hat.Fun c (Hat.Hat.Fun d (Hat.Hat.Fun e (Hat.Hat.Fun f g))))))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> ((Hat.Hat.R (Hat.Hat.List b)) -> ((Hat.Hat.R (Hat.Hat.List c)) -> ((Hat.Hat.R (Hat.Hat.List d)) -> ((Hat.Hat.R (Hat.Hat.List e)) -> ((Hat.Hat.R (Hat.Hat.List f)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List g))))))))));

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

{-# NEED hzipWith5 #-}
hzipWith5{-# 7 #-}::((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.R (Hat.Hat.List a)) -> ((Hat.Hat.R (Hat.Hat.List b)) -> ((Hat.Hat.R (Hat.Hat.List c)) -> ((Hat.Hat.R (Hat.Hat.List d)) -> ((Hat.Hat.R (Hat.Hat.List e)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List f)))))))));

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

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

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

{-# NEED gzip7 #-}
gzip7{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.Fun (Hat.Hat.List c) (Hat.Hat.Fun (Hat.Hat.List d) (Hat.Hat.Fun (Hat.Hat.List e) (Hat.Hat.Fun (Hat.Hat.List f) (Hat.Hat.Fun (Hat.Hat.List g) (Hat.Hat.List (Hat.Hat.Tuple7 a b c d e f g))))))))))));
interface Hat.Hat
{-# NEED Tuple7 #-}
data Tuple7 a b c d e f g;
interface ! Hat.List
{-# NEED gzip6 #-}
gzip6{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.Fun (Hat.Hat.List c) (Hat.Hat.Fun (Hat.Hat.List d) (Hat.Hat.Fun (Hat.Hat.List e) (Hat.Hat.Fun (Hat.Hat.List f) (Hat.Hat.List (Hat.Hat.Tuple6 a b c d e f)))))))))));
interface Hat.Hat
{-# NEED Tuple6 #-}
data Tuple6 a b c d e f;
interface ! Hat.List
{-# NEED gzip5 #-}
gzip5{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.Fun (Hat.Hat.List c) (Hat.Hat.Fun (Hat.Hat.List d) (Hat.Hat.Fun (Hat.Hat.List e) (Hat.Hat.List (Hat.Hat.Tuple5 a b c d e))))))))));
interface Hat.Hat
{-# NEED Tuple5 #-}
data Tuple5 a b c d e;
interface ! Hat.List
{-# NEED gzip4 #-}
gzip4{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.Fun (Hat.Hat.List c) (Hat.Hat.Fun (Hat.Hat.List d) (Hat.Hat.List (Hat.Hat.Tuple4 a b c d)))))))));
interface Hat.Hat
{-# NEED Tuple4 #-}
data Tuple4 a b c d;
interface ! Hat.List
{-# NEED hgenericReplicate #-}
hgenericReplicate{-# 3 #-}::(Hat.PreludeBasic.Integral a) => ((Hat.Hat.R a) -> ((Hat.Hat.R b) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List b)))));

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

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

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

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

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

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

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

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

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

{-# NEED hgenericLength #-}
hgenericLength{-# 2 #-}::(Hat.PreludeBasic.Integral b) => ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R b)));

{-# NEED ggenericLength #-}
ggenericLength{-# 2 #-}::(Hat.PreludeBasic.Integral b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) b))));
interface Hat.PreludeBasic
{-# NEED Integral #-}
class (Hat.PreludeBasic.Real a,Hat.PreludeBasic.Enum a) => Integral a;

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

{-# NEED Real #-}
class (Hat.PreludeBasic.Num a,Hat.PreludeBasic.Ord a) => Real a;
interface ! Hat.List
{-# NEED hminimumBy #-}
hminimumBy{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Hat.PreludeBasic.Ordering))) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a))));

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

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

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

{-# NEED hinsertBy #-}
hinsertBy{-# 4 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Hat.PreludeBasic.Ordering))) -> ((Hat.Hat.R a) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a))))));

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

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

{-# NEED hsortBy #-}
hsortBy{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Hat.PreludeBasic.Ordering))) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a)))));

{-# NEED gsortBy #-}
gsortBy{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a (Hat.Hat.Fun a Hat.PreludeBasic.Ordering)) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a))))));
interface Hat.PreludeBasic
{-# NEED Ordering #-}
data Ordering;
interface ! Hat.List
{-# NEED gsort #-}
gsort{-# 2 #-}::(Hat.PreludeBasic.Ord a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List a)))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED gelemIndex #-}
gelemIndex{-# 2 #-}::(Hat.PreludeBasic.Eq a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.List a) (Hat.PreludeBasic.Maybe Prelude.Int))))));
interface ! Hat.PreludeBasic
{-# NEED azipWith3 #-}
azipWith3{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED amap #-}
amap{-# 0 #-}::Hat.Hat.RefAtom;
interface Hat.Hat
{-# NEED RefAtom #-}
newtype {-#  #-} RefAtom;
interface ! Hat.PreludeBasic
{-# NEED gunzip3 #-}
gunzip3{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List (Hat.Hat.Tuple3 a b c)) (Hat.Hat.Tuple3 (Hat.Hat.List a) (Hat.Hat.List b) (Hat.Hat.List c))))));

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

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

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

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

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

{-# NEED gzip3 #-}
gzip3{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.Fun (Hat.Hat.List c) (Hat.Hat.List (Hat.Hat.Tuple3 a b c))))))));
interface Hat.Hat
{-# NEED Tuple3 #-}
data Tuple3 a b c;
interface ! Hat.PreludeBasic
{-# NEED gzip #-}
gzip{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Fun (Hat.Hat.List b) (Hat.Hat.List (Hat.Hat.Tuple2 a b)))))));

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

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

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

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

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

{-# NEED gmaximum #-}
gmaximum{-# 2 #-}::(Hat.PreludeBasic.Ord a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) a))));
interface Hat.PreludeBasic
{-# NEED Ord #-}
class (Hat.PreludeBasic.Eq a) => Ord a;
interface ! Hat.PreludeBasic
{-# NEED gproduct #-}
gproduct{-# 2 #-}::(Hat.PreludeBasic.Num a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) a))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED glines #-}
glines{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.List Hat.PreludeBuiltinTypes.String)))));
interface Hat.PreludeBuiltinTypes
{-# NEED String #-}
type {-# 1 #-} String = (Hat.Hat.List Prelude.Char);
interface ! Hat.PreludeBasic
{-# NEED hbreak #-}
hbreak{-# 2 #-}::((Hat.Hat.R (Hat.Hat.Fun a Prelude.Bool)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List a))))));

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

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

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

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

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

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

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

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

{-# NEED gsplitAt #-}
gsplitAt{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.Tuple2 (Hat.Hat.List a) (Hat.Hat.List a)))))));
interface Hat.Hat
{-# NEED Tuple2 #-}
data Tuple2 a b;
interface ! Hat.PreludeBasic
{-# NEED hdrop #-}
hdrop{-# 3 #-}::((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED gmap #-}
gmap{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a b) (Hat.Hat.Fun (Hat.Hat.List a) (Hat.Hat.List b))))));
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;
}
