interface Control.Exception.Base where {

{-# NEED #-}
instance Exception SomeException;

{-# NEED #-}
instance Exception System.ExitCode;

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

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

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

{-# NEED #-}
instance Prelude.Ord System.ExitCode;

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

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

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

{-# NEED #-}
instance Prelude.Eq System.ExitCode;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show System.ExitCode;

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

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

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

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

{-# 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 Prelude.[];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# 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 a) => Data.Typeable.Typeable [a];

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

{-# 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 System
{-# NEED ExitCode #-}
data ExitCode;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface Data.Typeable
{-# NEED TypeRep #-}
data TypeRep;

{-# NEED TyCon #-}
data TyCon;

{-# NEED Typeable #-}
class Typeable a;
interface ! Control.Exception.Base
{-# 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 onException #-}
onException{-# 2 #-}::((NHC.Internal.IO a) -> ((NHC.Internal.IO b) -> (NHC.Internal.IO a)));

{-# NEED tryJust #-}
tryJust{-# 2 #-}::(Exception a) => ((a -> (Prelude.Maybe b)) -> ((NHC.Internal.IO c) -> (NHC.Internal.IO (Prelude.Either b c))));

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

{-# NEED mapException #-}
mapException{-# 2 #-}::(Exception a,Exception b) => ((a -> b) -> (c -> c));

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

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

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

{-# NEED blocked #-}
blocked{-# 0 #-}::(NHC.Internal.IO Prelude.Bool);

{-# 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 mask #-}
mask{-# 1 #-}::((((NHC.Internal.IO a) -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a));

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

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

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

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

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

{-# NEED RecUpdError #-}
data RecUpdError;

{-# NEED RecSelError #-}
data RecSelError;

{-# NEED RecConError #-}
data RecConError;

{-# NEED ErrorCall #-}
data ErrorCall;

{-# NEED BlockedIndefinitelyOnSTM #-}
data BlockedIndefinitelyOnSTM;

{-# NEED BlockedIndefinitelyOnMVar #-}
data BlockedIndefinitelyOnMVar;

{-# NEED Deadlock #-}
data Deadlock;

{-# NEED NoMethodError #-}
data NoMethodError;

{-# NEED PatternMatchFail #-}
data PatternMatchFail;

{-# NEED AssertionFailed #-}
data AssertionFailed;

{-# NEED AsyncException #-}
data AsyncException;

{-# NEED ArrayException #-}
data ArrayException;

{-# NEED ArithException #-}
data ArithException;

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

{-# NEED {Exception toException fromException} {SomeException SomeException} #-}
class (Prelude.Show a) => Exception a where {
  toException{-# 1 #-}::(a -> SomeException);
  fromException{-# 1 #-}::(SomeException -> (Prelude.Maybe a));
};
data SomeException
  = forall a_fa . (Exception a_fa) => SomeException a_fa;
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 ! Prelude
{-# NEED ioError #-}
ioError{-# 1 #-}::(Prelude.IOError -> (NHC.Internal.IO a));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface NHC.DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
}
