interface Control.Exception where {

{-# 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.Integral a) => Prelude.Real (Ratio.Ratio a);

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Data.Typeable.TypeRep;

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

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

{-# NEED #-}
instance Data.Typeable.Typeable1 Prelude.[];

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable1 (Prelude.Either a);

{-# NEED #-}
instance Data.Typeable.Typeable1 Prelude.Maybe;

{-# NEED #-}
instance Data.Typeable.Typeable1 Ratio.Ratio;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.Internal.IO;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable1 ( (->) a);

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

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

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

{-# NEED #-}
instance Prelude.Show Data.Typeable.TypeRep;

{-# NEED #-}
instance Prelude.Show Data.Dynamic.Dynamic;

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

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Ordering;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Int;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Char;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable [a];

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Integer;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Float;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Bool;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Double;

{-# NEED #-}
instance (Data.Typeable.Typeable a,Data.Typeable.Typeable b) => Data.Typeable.Typeable (Prelude.Either a b);

{-# NEED #-}
instance Data.Typeable.Typeable ();

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (Prelude.Maybe a);

{-# NEED #-}
instance Data.Typeable.Typeable IO.Handle;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (Ratio.Ratio a);

{-# NEED #-}
instance Data.Typeable.Typeable Data.Typeable.TypeRep;

{-# NEED #-}
instance Data.Typeable.Typeable Data.Dynamic.Dynamic;

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

{-# NEED #-}
instance (Data.Typeable.Typeable a,Data.Typeable.Typeable b) => Data.Typeable.Typeable (a -> b);
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface Data.Typeable
{-# NEED TypeRep #-}
data TypeRep;
interface ! Control.Exception
{-# NEED bracketOnError #-}
bracketOnError{-# 3 #-}::((NHC.Internal.IO a) -> ((a -> (NHC.Internal.IO b)) -> ((a -> (NHC.Internal.IO c)) -> (NHC.Internal.IO c))));

{-# NEED bracket_ #-}
bracket_{-# 3 #-}::((NHC.Internal.IO a) -> ((NHC.Internal.IO b) -> ((NHC.Internal.IO c) -> (NHC.Internal.IO c))));

{-# NEED finally #-}
finally{-# 2 #-}::((NHC.Internal.IO a) -> ((NHC.Internal.IO b) -> (NHC.Internal.IO a)));

{-# NEED catchDyn #-}
catchDyn{-# 2 #-}::(Data.Typeable.Typeable b) => ((NHC.Internal.IO a) -> ((b -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)));

{-# NEED throwDyn #-}
throwDyn{-# 1 #-}::(Data.Typeable.Typeable a) => (a -> b);
interface Data.Typeable
{-# NEED Typeable #-}
class Typeable a;
interface ! Control.Exception
{-# NEED tryJust #-}
tryJust{-# 2 #-}::((Exception -> (Prelude.Maybe a)) -> ((NHC.Internal.IO b) -> (NHC.Internal.IO (Prelude.Either a b))));

{-# NEED try #-}
try{-# 1 #-}::((NHC.Internal.IO a) -> (NHC.Internal.IO (Prelude.Either Exception a)));

{-# NEED mapException #-}
mapException{-# 2 #-}::((Exception -> Exception) -> (a -> a));

{-# NEED handleJust #-}
handleJust{-# 1 #-}::((Exception -> (Prelude.Maybe a)) -> ((a -> (NHC.Internal.IO b)) -> ((NHC.Internal.IO b) -> (NHC.Internal.IO b))));

{-# NEED handle #-}
handle{-# 0 #-}::((Exception -> (NHC.Internal.IO a)) -> ((NHC.Internal.IO a) -> (NHC.Internal.IO a)));

{-# NEED catchJust #-}
catchJust{-# 3 #-}::((Exception -> (Prelude.Maybe a)) -> ((NHC.Internal.IO b) -> ((a -> (NHC.Internal.IO b)) -> (NHC.Internal.IO b))));

{-# NEED assert #-}
assert{-# 2 #-}::(Prelude.Bool -> (a -> a));

{-# NEED unblock #-}
unblock{-# 0 #-}::((NHC.Internal.IO a) -> (NHC.Internal.IO a));

{-# NEED block #-}
block{-# 0 #-}::((NHC.Internal.IO a) -> (NHC.Internal.IO a));

{-# NEED userErrors #-}
userErrors{-# 1 #-}::(Exception -> (Prelude.Maybe Prelude.String));

{-# NEED asyncExceptions #-}
asyncExceptions{-# 0 #-}::(Exception -> (Prelude.Maybe AsyncException));

{-# NEED assertions #-}
assertions{-# 0 #-}::(Exception -> (Prelude.Maybe Prelude.String));

{-# NEED dynExceptions #-}
dynExceptions{-# 0 #-}::(Exception -> (Prelude.Maybe Data.Dynamic.Dynamic));
interface Data.Dynamic
{-# NEED Dynamic #-}
data Dynamic;
interface ! Control.Exception
{-# NEED errorCalls #-}
errorCalls{-# 0 #-}::(Exception -> (Prelude.Maybe Prelude.String));

{-# NEED arithExceptions #-}
arithExceptions{-# 0 #-}::(Exception -> (Prelude.Maybe ArithException));

{-# NEED ioErrors #-}
ioErrors{-# 1 #-}::(Exception -> (Prelude.Maybe Prelude.IOError));

{-# NEED evaluate #-}
evaluate{-# 1 #-}::(a -> (NHC.Internal.IO a));

{-# NEED throw #-}
throw{-# 0 #-}::(Exception -> a);

{-# NEED throwIO #-}
throwIO{-# 0 #-}::(Exception -> (NHC.Internal.IO a));

{-# NEED AsyncException #-}
data AsyncException;

{-# NEED ArrayException #-}
data ArrayException;

{-# NEED ArithException #-}
data ArithException;

{-# NEED IOException #-}
type {-# 2 #-} IOException = Prelude.IOError;

{-# NEED Exception #-}
type {-# 1 #-} Exception = Prelude.IOError;
interface ! Prelude
{-# NEED ioError #-}
ioError{-# 1 #-}::(Prelude.IOError -> (NHC.Internal.IO a));

{-# NEED catch #-}
catch{-# 2 #-}::((NHC.Internal.IO a) -> ((Prelude.IOError -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)));
interface ! IO
{-# NEED bracket #-}
bracket{-# 3 #-}::((NHC.Internal.IO a) -> ((a -> (NHC.Internal.IO b)) -> ((a -> (NHC.Internal.IO c)) -> (NHC.Internal.IO c))));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;
interface NHC.DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface NHC.Internal
{-# NEED World #-}
data World;
}