interface Hat.PreludeBasic where {

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

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

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

{-# NEED #-}
instance Show Ordering;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Read Ordering;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Monad Maybe;

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

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

{-# NEED #-}
instance Functor Maybe;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Bounded Ordering;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Enum Ordering;

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Ord Ordering;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Eq Ordering;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.Hat.WrapVal FFFormat;

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

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

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

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

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

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

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

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

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

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

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

{-# 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.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.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.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.Eq Hat.Hat.RefExp;

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

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

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

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

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

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

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

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

{-# 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.Show a) => Prelude.Show (NHC.Internal.IO a);
interface Hat.Hat
{-# NEED Tuple4 #-}
data Tuple4 a b c d;

{-# NEED Tuple5 #-}
data Tuple5 a b c d e;

{-# NEED Tuple6 #-}
data Tuple6 a b c d e f;

{-# NEED Tuple7 #-}
data Tuple7 a b c d e f g;

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

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

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

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

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

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

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

{-# NEED Tuple15 #-}
data Tuple15 a b c d e f g h i j k l m n o;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface IO
{-# NEED BufferMode #-}
data BufferMode;

{-# NEED IOMode #-}
data IOMode;

{-# NEED SeekMode #-}
data SeekMode;
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.PreludeBasic
{-# NEED aapproxRational #-}
aapproxRational{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED afromRat' #-}
afromRat'{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED azip #-}
azip{-# 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 aproduct #-}
aproduct{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED asum #-}
asum{-# 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 aor #-}
aor{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

{-# NEED aunlines #-}
aunlines{-# 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;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED happroxRational #-}
happroxRational{-# 3 #-}::(RealFrac a) => ((Hat.Hat.R a) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R Rational))));

{-# NEED gapproxRational #-}
gapproxRational{-# 2 #-}::(RealFrac a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun a Rational)))));

{-# NEED hdenominator #-}
hdenominator{-# 2 #-}::(Integral a) => ((Hat.Hat.R (Ratio a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

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

{-# NEED hnumerator #-}
hnumerator{-# 2 #-}::(Integral a) => ((Hat.Hat.R (Ratio a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

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

{-# NEED (*%) #-}
(*%){-# 3 #-}::(Integral a) => ((Hat.Hat.R a) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Ratio a)))));

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

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

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

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

{-# NEED hnonnull #-}
hnonnull{-# 3 #-}::((Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool)) -> ((Hat.Hat.R (ReadS___1 Hat.PreludeBuiltinTypes.String)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS___2 Hat.PreludeBuiltinTypes.String)))));

{-# NEED gnonnull #-}
gnonnull{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun Prelude.Char Prelude.Bool) (ReadS Hat.PreludeBuiltinTypes.String)))));

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

{-# NEED hreadFloat #-}
hreadFloat{-# 2 #-}::(RealFloat a) => ((Hat.Hat.R (ReadS___1 a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS___2 a))));

{-# NEED greadFloat #-}
greadFloat{-# 2 #-}::(RealFloat a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS a))));

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

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

{-# NEED hroundTo #-}
hroundTo{-# 4 #-}::((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R (Hat.Hat.List Prelude.Int)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 Prelude.Int (Hat.Hat.List Prelude.Int)))))));

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

{-# NEED hformatRealFloat #-}
hformatRealFloat{-# 4 #-}::(RealFloat a) => ((Hat.Hat.R FFFormat) -> ((Hat.Hat.R (Maybe Prelude.Int)) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R Hat.PreludeBuiltinTypes.String)))));

{-# NEED gformatRealFloat #-}
gformatRealFloat{-# 2 #-}::(RealFloat a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun FFFormat (Hat.Hat.Fun (Maybe Prelude.Int) (Hat.Hat.Fun a Hat.PreludeBuiltinTypes.String))))));

{-# NEED {FFFormat FFExponent FFFixed FFGeneric} #-}
data FFFormat
  = FFExponent 
  | FFFixed 
  | FFGeneric ;

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

{-# NEED hshowGFloat #-}
hshowGFloat{-# 3 #-}::(RealFloat a) => ((Hat.Hat.R (Maybe Prelude.Int)) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R ShowS))));

{-# NEED gshowGFloat #-}
gshowGFloat{-# 2 #-}::(RealFloat a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Maybe Prelude.Int) (Hat.Hat.Fun a ShowS)))));

{-# NEED hshowFFloat #-}
hshowFFloat{-# 3 #-}::(RealFloat a) => ((Hat.Hat.R (Maybe Prelude.Int)) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R ShowS))));

{-# NEED gshowFFloat #-}
gshowFFloat{-# 2 #-}::(RealFloat a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Maybe Prelude.Int) (Hat.Hat.Fun a ShowS)))));

{-# NEED hshowEFloat #-}
hshowEFloat{-# 3 #-}::(RealFloat a) => ((Hat.Hat.R (Maybe Prelude.Int)) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R ShowS))));

{-# NEED gshowEFloat #-}
gshowEFloat{-# 2 #-}::(RealFloat a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Maybe Prelude.Int) (Hat.Hat.Fun a ShowS)))));

{-# NEED greadHex #-}
greadHex{-# 2 #-}::(Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS a))));

{-# NEED greadOct #-}
greadOct{-# 2 #-}::(Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS a))));

{-# NEED greadDec #-}
greadDec{-# 2 #-}::(Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS a))));

{-# NEED hreadInt #-}
hreadInt{-# 5 #-}::(Integral a) => ((Hat.Hat.R a) -> ((Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Bool)) -> ((Hat.Hat.R (Hat.Hat.Fun Prelude.Char Prelude.Int)) -> ((Hat.Hat.R (ReadS___1 a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS___2 a)))))));

{-# NEED greadInt #-}
greadInt{-# 2 #-}::(Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.Fun Prelude.Char Prelude.Bool) (Hat.Hat.Fun (Hat.Hat.Fun Prelude.Char Prelude.Int) (ReadS a)))))));

{-# NEED hreadSigned #-}
hreadSigned{-# 2 #-}::(Real a) => ((Hat.Hat.R (ReadS a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS a))));

{-# NEED greadSigned #-}
greadSigned{-# 2 #-}::(Real a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (ReadS a) (ReadS a)))));

{-# NEED hshowIntAtBase #-}
hshowIntAtBase{-# 5 #-}::(Integral a) => ((Hat.Hat.R a) -> ((Hat.Hat.R (Hat.Hat.Fun Prelude.Int Prelude.Char)) -> ((Hat.Hat.R a) -> ((Hat.Hat.R ShowS___1) -> (Hat.Hat.RefExp -> (Hat.Hat.R ShowS___2))))));

{-# NEED gshowIntAtBase #-}
gshowIntAtBase{-# 2 #-}::(Integral a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun (Hat.Hat.Fun Prelude.Int Prelude.Char) (Hat.Hat.Fun a ShowS))))));

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

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

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

{-# NEED hshowSigned #-}
hshowSigned{-# 4 #-}::(Real a) => ((Hat.Hat.R (Hat.Hat.Fun a ShowS)) -> ((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R ShowS)))));

{-# NEED gshowSigned #-}
gshowSigned{-# 2 #-}::(Real a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.Fun a ShowS) (Hat.Hat.Fun Prelude.Int (Hat.Hat.Fun a ShowS))))));

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

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

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

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

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

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

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

{-# NEED hscaleRat #-}
hscaleRat{-# 7 #-}::((Hat.Hat.R Rational) -> ((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R Rational) -> ((Hat.Hat.R Rational) -> ((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R Rational) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 Rational Prelude.Int)))))))));

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

{-# NEED hfromRat' #-}
hfromRat'{-# 2 #-}::(RealFloat a) => ((Hat.Hat.R Rational) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

{-# NEED gfromRat' #-}
gfromRat'{-# 2 #-}::(RealFloat a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Rational a))));

{-# NEED hfromRat #-}
hfromRat{-# 2 #-}::(RealFloat a) => ((Hat.Hat.R Rational) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

{-# NEED gfromRat #-}
gfromRat{-# 2 #-}::(RealFloat a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Rational a))));

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

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

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

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

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

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

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

{-# NEED hreadLitChar #-}
hreadLitChar{-# 2 #-}::((Hat.Hat.R (ReadS___1 Prelude.Char)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS___2 Prelude.Char))));

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

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

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

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

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

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

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

{-# NEED greadLn #-}
greadLn{-# 2 #-}::(Read a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO a))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hreadParen #-}
hreadParen{-# 3 #-}::((Hat.Hat.R Prelude.Bool) -> ((Hat.Hat.R (ReadS a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS a)))));

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

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

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

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

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

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

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

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

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

{-# NEED {Read greadList sreadList greadsPrec sreadsPrec} #-}
class Read a where {
  greadList{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS (Hat.Hat.List a)))));
  sreadList{-# 0 #-}::(Hat.Hat.R (ReadS (Hat.Hat.List a)));
  greadsPrec{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Int (ReadS a)))));
  sreadsPrec{-# 0 #-}::(Hat.Hat.R (Hat.Hat.Fun Prelude.Int (ReadS a)));
};

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

{-# NEED ShowS___1 #-}
type {-# 6 #-} ShowS___1 = Hat.PreludeBuiltinTypes.String;

{-# 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 #-}::(Ord a) => ((Hat.Hat.R (Hat.Hat.List a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

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

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

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

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

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

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

{-# NEED glookup #-}
glookup{-# 2 #-}::(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)) (Maybe b))))));

{-# NEED hnotElem #-}
hnotElem{-# 2 #-}::(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 #-}::(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 #-}::(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 #-}::(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 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)))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hnumericEnumFromThenTo #-}
hnumericEnumFromThenTo{-# 4 #-}::(Fractional a,Ord a) => ((Hat.Hat.R a) -> ((Hat.Hat.R a) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a))))));

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

{-# NEED hnumericEnumFromTo #-}
hnumericEnumFromTo{-# 3 #-}::(Fractional a,Ord a) => ((Hat.Hat.R a) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List a)))));

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

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

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

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

{-# NEED hintEnumFromByTo #-}
hintEnumFromByTo{-# 4 #-}::((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R Prelude.Int) -> ((Hat.Hat.R Prelude.Int) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.List Prelude.Int))))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED (*=<<) #-}
(*=<<){-# 3 #-}::(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 #-}::(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 #-}::(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 #-}::(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 #-}::(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 #-}::(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 #-}::(Monad a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.List (a b)) (a Hat.Hat.Tuple0)))));

{-# NEED gsequence #-}
gsequence{-# 2 #-}::(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)));
};

{-# 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 grealToFrac #-}
grealToFrac{-# 2 #-}::(Real a,Fractional b) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a b))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED halt #-}
halt{-# 4 #-}::((Hat.Hat.R (ReadS a)) -> ((Hat.Hat.R (ReadS a)) -> ((Hat.Hat.R (ReadS___1 a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS___2 a))))));

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

{-# NEED hthenLex #-}
hthenLex{-# 3 #-}::((Hat.Hat.R (ReadS a)) -> ((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS a)))));

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

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

{-# NEED hlift #-}
hlift{-# 5 #-}::((Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.Fun b (ReadS c)))) -> ((Hat.Hat.R (ReadS a)) -> ((Hat.Hat.R (ReadS b)) -> ((Hat.Hat.R (ReadS___1 c)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS___2 c)))))));

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

{-# NEED hyield #-}
hyield{-# 3 #-}::((Hat.Hat.R a) -> ((Hat.Hat.R (ReadS___1 a)) -> (Hat.Hat.RefExp -> (Hat.Hat.R (ReadS___2 a)))));

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

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

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

{-# NEED ReadS #-}
type {-# 2 #-} ReadS a = (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.List (Hat.Hat.Tuple2 a Hat.PreludeBuiltinTypes.String)));
interface ! Hat.PreludeBuiltinTypes
{-# NEED gundefined #-}
gundefined{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R a)));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hprimFloatSignum #-}
hprimFloatSignum{-# 2 #-}::((Hat.Hat.R Prelude.Float) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Float)));
interface ! Prelude
{-# NEED Float #-}
data Float;
interface ! Hat.PreludeBuiltin
{-# NEED gprimDoubleFromInteger #-}
gprimDoubleFromInteger{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer Prelude.Double))));

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

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

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

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

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

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

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

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

{-# NEED hprimDecodeDouble #-}
hprimDecodeDouble{-# 2 #-}::((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Tuple2 Prelude.Integer Prelude.Int))));
interface Hat.Hat
{-# NEED Tuple2 #-}
data Tuple2 a b;
interface ! Hat.PreludeBuiltin
{-# NEED gprimEncodeDouble #-}
gprimEncodeDouble{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Integer (Hat.Hat.Fun Prelude.Int Prelude.Double)))));

{-# NEED hprimEncodeDouble #-}
hprimEncodeDouble{-# 3 #-}::((Hat.Hat.R Prelude.Integer) -> ((Hat.Hat.R Prelude.Int) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Double))));
interface ! Prelude
{-# NEED Integer #-}
data Integer;
interface ! Hat.PreludeBuiltin
{-# NEED gprimDoubleIsNaN #-}
gprimDoubleIsNaN{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.Double Prelude.Bool))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hprimDoubleGe #-}
hprimDoubleGe{-# 3 #-}::((Hat.Hat.R Prelude.Double) -> ((Hat.Hat.R Prelude.Double) -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Bool))));
interface ! Prelude
{-# NEED {Bool False True} #-}
data Bool
  = False 
  | True ;
interface ! Hat.PreludeBuiltin
{-# NEED gprimDoublePi #-}
gprimDoublePi{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R Prelude.Double)));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED RefSrcPos #-}
newtype {-#  #-} RefSrcPos;
interface ! Hat.PreludeBuiltin
{-# NEED happendFile #-}
happendFile{-# 3 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> ((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0)))));
interface Hat.Hat
{-# NEED Tuple0 #-}
data Tuple0;
interface ! Hat.Hat
{-# NEED {IO} #-}
newtype {-#  #-} IO a
  = Unexported.Constr_151 (NHC.Internal.IO (Hat.Hat.R a));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;
interface ! Prelude
{-# NEED IOError #-}
data IOError;
interface NHC.Internal
{-# NEED World #-}
data World;
interface ! Hat.PreludeBuiltinTypes
{-# NEED String #-}
type {-# 1 #-} String = (Hat.Hat.List Prelude.Char);
interface ! Prelude
{-# NEED Char #-}
data Char;
interface Hat.Hat
{-# NEED List #-}
data List a;

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

{-# NEED RefExp #-}
newtype {-#  #-} RefExp;
interface ! Hat.PreludeBuiltin
{-# NEED aseq #-}
aseq{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED aprimIOReturn #-}
aprimIOReturn{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED aprimIOErrorShow #-}
aprimIOErrorShow{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED aioError #-}
aioError{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED auserError #-}
auserError{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED acatch #-}
acatch{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED aputChar #-}
aputChar{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED areadFile #-}
areadFile{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED awriteFile #-}
awriteFile{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED aappendFile #-}
aappendFile{-# 0 #-}::Hat.Hat.RefAtom;
interface Hat.Hat
{-# NEED RefAtom #-}
newtype {-#  #-} RefAtom;
interface ! Prelude
{-# NEED Int #-}
data Int;
}
