interface Hat.IO where {

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

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

{-# NEED #-}
instance Hat.Ix.Ix Hat.IOBuiltinTypes.SeekMode;

{-# NEED #-}
instance Hat.Ix.Ix Hat.IOBuiltinTypes.IOMode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.Hat.WrapVal Hat.IOBuiltinTypes.BufferMode;

{-# NEED #-}
instance Hat.Hat.WrapVal Hat.IOBuiltinTypes.SeekMode;

{-# NEED #-}
instance Hat.Hat.WrapVal Hat.IOBuiltinTypes.IOMode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Bounded Hat.IOBuiltinTypes.SeekMode;

{-# NEED #-}
instance Hat.PreludeBasic.Bounded Hat.IOBuiltinTypes.IOMode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Read Hat.IOBuiltinTypes.BufferMode;

{-# NEED #-}
instance Hat.PreludeBasic.Read Hat.IOBuiltinTypes.SeekMode;

{-# NEED #-}
instance Hat.PreludeBasic.Read Hat.IOBuiltinTypes.IOMode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Enum Hat.IOBuiltinTypes.SeekMode;

{-# NEED #-}
instance Hat.PreludeBasic.Enum Hat.IOBuiltinTypes.IOMode;

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Ord Hat.IOBuiltinTypes.BufferMode;

{-# NEED #-}
instance Hat.PreludeBasic.Ord Hat.IOBuiltinTypes.SeekMode;

{-# NEED #-}
instance Hat.PreludeBasic.Ord Hat.IOBuiltinTypes.IOMode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Show Hat.IOBuiltinTypes.BufferMode;

{-# NEED #-}
instance Hat.PreludeBasic.Show Hat.IOBuiltinTypes.SeekMode;

{-# NEED #-}
instance Hat.PreludeBasic.Show Hat.IOBuiltinTypes.IOMode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Show IO.Handle;

{-# NEED #-}
instance Hat.PreludeBasic.Eq Hat.IOBuiltinTypes.BufferMode;

{-# NEED #-}
instance Hat.PreludeBasic.Eq Hat.IOBuiltinTypes.SeekMode;

{-# NEED #-}
instance Hat.PreludeBasic.Eq Hat.IOBuiltinTypes.IOMode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Eq IO.HandlePosn;

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

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

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

{-# NEED #-}
instance Hat.PreludeBasic.Eq IO.Handle;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show IO.Handle;
interface Hat.Ix
{-# NEED Ix #-}
class (Hat.PreludeBasic.Ord a) => Ix a;
interface Hat.PreludeBasic
{-# NEED Bounded #-}
class Bounded a;
interface Hat.Hat
{-# NEED Tuple15 #-}
data Tuple15 a b c d e f g h i j k l m n o;

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

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

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

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

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

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

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

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

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

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

{-# NEED Tuple4 #-}
data Tuple4 a b c d;

{-# NEED Tuple3 #-}
data Tuple3 a b c;

{-# NEED Tuple2 #-}
data Tuple2 a b;
interface Hat.PreludeBasic
{-# NEED Ratio #-}
data (Integral a) => Ratio a;

{-# NEED Integral #-}
class (Hat.PreludeBasic.Real a,Hat.PreludeBasic.Enum a) => Integral a;

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

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

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

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

{-# NEED Ordering #-}
data Ordering;

{-# NEED Eq #-}
class Eq a;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface NHC.FFI
{-# NEED Ptr #-}
data Ptr a;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface NHC.FFI
{-# NEED CChar #-}
newtype {-#  #-} CChar;
interface IO
{-# NEED IOMode #-}
data IOMode;

{-# NEED BufferMode #-}
data BufferMode;

{-# NEED SeekMode #-}
data SeekMode;
interface ! Hat.IO
{-# NEED abracket_ #-}
abracket_{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED gbracket_ #-}
gbracket_{-# 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.Fun (Hat.Hat.IO c) (Hat.Hat.IO c)))))));

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

{-# NEED gbracket #-}
gbracket{-# 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.Fun (Hat.Hat.Fun a (Hat.Hat.IO c)) (Hat.Hat.IO c)))))));

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

{-# NEED gtry #-}
gtry{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun (Hat.Hat.IO a) (Hat.Hat.IO (Hat.PreludeBasic.Either Prelude.IOError a))))));
interface Hat.PreludeBasic
{-# NEED Either #-}
data Either a b;
interface ! Hat.IO
{-# NEED hioeGetFileName #-}
hioeGetFileName{-# 2 #-}::((Hat.Hat.R Prelude.IOError) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.Maybe Hat.PreludeBuiltinTypes.String))));

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

{-# NEED hioeGetHandle #-}
hioeGetHandle{-# 2 #-}::((Hat.Hat.R Prelude.IOError) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.PreludeBasic.Maybe IO.Handle))));

{-# NEED gioeGetHandle #-}
gioeGetHandle{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Prelude.IOError (Hat.PreludeBasic.Maybe IO.Handle)))));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hhPrint #-}
hhPrint{-# 3 #-}::(Hat.PreludeBasic.Show a) => ((Hat.Hat.R IO.Handle) -> ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0)))));

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

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

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

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

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

{-# NEED hhPutChar #-}
hhPutChar{-# 3 #-}::((Hat.Hat.R IO.Handle) -> ((Hat.Hat.R Prelude.Char) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0)))));

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED hhSeek #-}
hhSeek{-# 4 #-}::((Hat.Hat.R IO.Handle) -> ((Hat.Hat.R Hat.IOBuiltinTypes.SeekMode) -> ((Hat.Hat.R Prelude.Integer) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))))));

{-# NEED ghSeek #-}
ghSeek{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun IO.Handle (Hat.Hat.Fun Hat.IOBuiltinTypes.SeekMode (Hat.Hat.Fun Prelude.Integer (Hat.Hat.IO Hat.Hat.Tuple0)))))));

{-# NEED hhSetPosn #-}
hhSetPosn{-# 2 #-}::((Hat.Hat.R IO.HandlePosn) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))));

{-# NEED ghSetPosn #-}
ghSetPosn{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun IO.HandlePosn (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED hhGetPosn #-}
hhGetPosn{-# 2 #-}::((Hat.Hat.R IO.Handle) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO IO.HandlePosn))));

{-# NEED ghGetPosn #-}
ghGetPosn{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun IO.Handle (Hat.Hat.IO IO.HandlePosn)))));

{-# NEED hhFlush #-}
hhFlush{-# 2 #-}::((Hat.Hat.R IO.Handle) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))));

{-# NEED ghFlush #-}
ghFlush{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun IO.Handle (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED hhGetBuffering #-}
hhGetBuffering{-# 2 #-}::((Hat.Hat.R IO.Handle) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.IOBuiltinTypes.BufferMode))));

{-# NEED ghGetBuffering #-}
ghGetBuffering{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun IO.Handle (Hat.Hat.IO Hat.IOBuiltinTypes.BufferMode)))));

{-# NEED hhSetBuffering #-}
hhSetBuffering{-# 3 #-}::((Hat.Hat.R IO.Handle) -> ((Hat.Hat.R Hat.IOBuiltinTypes.BufferMode) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED ghSetBuffering #-}
ghSetBuffering{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun IO.Handle (Hat.Hat.Fun Hat.IOBuiltinTypes.BufferMode (Hat.Hat.IO Hat.Hat.Tuple0))))));

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

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

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

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

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

{-# NEED hhClose #-}
hhClose{-# 2 #-}::((Hat.Hat.R IO.Handle) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))));

{-# NEED ghClose #-}
ghClose{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun IO.Handle (Hat.Hat.IO Hat.Hat.Tuple0)))));

{-# NEED hopenFile #-}
hopenFile{-# 3 #-}::((Hat.Hat.R Hat.PreludeBuiltinTypes.String) -> ((Hat.Hat.R Hat.IOBuiltinTypes.IOMode) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO IO.Handle)))));

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

{-# NEED gstderr #-}
gstderr{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R IO.Handle)));

{-# NEED gstdout #-}
gstdout{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R IO.Handle)));

{-# NEED gstdin #-}
gstdin{-# 2 #-}::(Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R IO.Handle)));
interface ! Hat.IOBuiltinTypes
{-# NEED aReadMode #-}
aReadMode{-# 0 #-}::Hat.Hat.RefAtom;

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

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

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

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

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

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

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

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

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

{-# NEED {BufferMode NoBuffering LineBuffering BlockBuffering} #-}
data BufferMode
  = NoBuffering 
  | LineBuffering 
  | BlockBuffering (Hat.Hat.R (Hat.PreludeBasic.Maybe Prelude.Int));
interface Hat.PreludeBasic
{-# NEED Maybe #-}
data Maybe a;
interface ! Hat.IOBuiltinTypes
{-# NEED {SeekMode AbsoluteSeek RelativeSeek SeekFromEnd} #-}
data SeekMode
  = AbsoluteSeek 
  | RelativeSeek 
  | SeekFromEnd ;

{-# NEED {IOMode ReadMode WriteMode AppendMode ReadWriteMode} #-}
data IOMode
  = ReadMode 
  | WriteMode 
  | AppendMode 
  | ReadWriteMode ;
interface ! Hat.PreludeBasic
{-# NEED areadIO #-}
areadIO{-# 0 #-}::Hat.Hat.RefAtom;

{-# NEED ainteract #-}
ainteract{-# 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 greadLn #-}
greadLn{-# 2 #-}::(Hat.PreludeBasic.Read a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO a))));

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

{-# NEED greadIO #-}
greadIO{-# 2 #-}::(Hat.PreludeBasic.Read a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun Hat.PreludeBuiltinTypes.String (Hat.Hat.IO a)))));
interface Hat.PreludeBasic
{-# NEED Read #-}
class Read a;
interface ! Hat.PreludeBasic
{-# 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 #-}::(Hat.PreludeBasic.Show a) => ((Hat.Hat.R a) -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.IO Hat.Hat.Tuple0))));

{-# NEED gprint #-}
gprint{-# 2 #-}::(Hat.PreludeBasic.Show a) => (Hat.Hat.RefSrcPos -> (Hat.Hat.RefExp -> (Hat.Hat.R (Hat.Hat.Fun a (Hat.Hat.IO Hat.Hat.Tuple0)))));
interface Hat.PreludeBasic
{-# NEED Show #-}
class Show a;
interface ! Hat.PreludeBasic
{-# 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;
interface ! Hat.PreludeBuiltin
{-# 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.PreludeBuiltinTypes
{-# NEED String #-}
type {-# 1 #-} String = (Hat.Hat.List Prelude.Char);
interface Hat.Hat
{-# NEED List #-}
data List a;
interface ! Hat.PreludeBuiltin
{-# 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 ! Hat.Hat
{-# NEED {IO} #-}
newtype {-#  #-} IO a
  = Unexported.Constr_146 (NHC.Internal.IO (Hat.Hat.R a));
interface Hat.Hat
{-# NEED R #-}
data R a;

{-# NEED RefExp #-}
newtype {-#  #-} RefExp;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! IO
{-# NEED HandlePosn #-}
data HandlePosn;
interface ! Prelude
{-# NEED IOError #-}
data IOError;
interface ! IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
}
