interface NHC.Internal where {
infixl  7 Ratio.%;
interface ! NHC.Internal
{-# NEED unsafePerformIO #-}
unsafePerformIO{-# 1 #-}::((IO a) -> a);

{-# NEED unsafeInterleaveIO #-}
unsafeInterleaveIO{-# 1 #-}::((IO a) -> (IO a));

{-# NEED _mkIOok15 #-}
_mkIOok15{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (l -> (m -> (n -> (o -> p))))))))))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (l -> (m -> (n -> (o -> (IO p)))))))))))))))));

{-# NEED _mkIOok14 #-}
_mkIOok14{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (l -> (m -> (n -> o)))))))))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (l -> (m -> (n -> (IO o))))))))))))))));

{-# NEED _mkIOok13 #-}
_mkIOok13{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (l -> (m -> n))))))))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (l -> (m -> (IO n)))))))))))))));

{-# NEED _mkIOok12 #-}
_mkIOok12{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (l -> m)))))))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (l -> (IO m))))))))))))));

{-# NEED _mkIOok11 #-}
_mkIOok11{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> l))))))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (k -> (IO l)))))))))))));

{-# NEED _mkIOok10 #-}
_mkIOok10{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> k)))))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (j -> (IO k))))))))))));

{-# NEED _mkIOok9 #-}
_mkIOok9{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> j))))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (i -> (IO j)))))))))));

{-# NEED _mkIOok8 #-}
_mkIOok8{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> i)))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (h -> (IO i))))))))));

{-# NEED _mkIOok7 #-}
_mkIOok7{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> (g -> h))))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (g -> (IO h)))))))));

{-# NEED _mkIOok6 #-}
_mkIOok6{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> (f -> g)))))) -> (a -> (b -> (c -> (d -> (e -> (f -> (IO g))))))));

{-# NEED _mkIOok5 #-}
_mkIOok5{-# 1 #-}::((a -> (b -> (c -> (d -> (e -> f))))) -> (a -> (b -> (c -> (d -> (e -> (IO f)))))));

{-# NEED _mkIOok4 #-}
_mkIOok4{-# 1 #-}::((a -> (b -> (c -> (d -> e)))) -> (a -> (b -> (c -> (d -> (IO e))))));

{-# NEED _mkIOok3 #-}
_mkIOok3{-# 1 #-}::((a -> (b -> (c -> d))) -> (a -> (b -> (c -> (IO d)))));

{-# NEED _mkIOok2 #-}
_mkIOok2{-# 1 #-}::((a -> (b -> c)) -> (a -> (b -> (IO c))));

{-# NEED _mkIOok1 #-}
_mkIOok1{-# 1 #-}::((a -> b) -> (a -> (IO b)));

{-# NEED _mkIOok0 #-}
_mkIOok0{-# 1 #-}::((() -> a) -> (IO a));
interface Prelude
{-# NEED #-}
data ();
interface ! Ratio
{-# NEED Rational #-}
type {-# 1 #-} Rational = (Ratio.Ratio Prelude.Integer);

{-# NEED (%) #-}
(%){-# 2 #-}::(Prelude.Integral a) => (a -> (a -> (Ratio.Ratio a)));

{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface Prelude
{-# NEED Integral #-}
class (Prelude.Real a,Prelude.Enum a) => Integral a;

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

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

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

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

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

{-# NEED Eq #-}
class Eq a;
interface ! NHC.Internal
{-# NEED {IO IO} #-}
newtype {-#  #-} IO a
  = IO (World -> (Prelude.Either Prelude.IOError a));
interface ! Prelude
{-# NEED {IOError IOError EOFError PatternError UserError} #-}
data IOError
  = IOError String (Maybe String) (Maybe IO.Handle) NHC.DErrNo.ErrNo
  | EOFError String IO.Handle
  | PatternError String
  | UserError String String;
interface NHC.DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface Prelude
{-# NEED Maybe #-}
data Maybe a;

{-# NEED String #-}
type {-# 1 #-} String = [Char];

{-# NEED Char #-}
data Char;

{-# NEED [] #-}
data [] a;
interface Prelude
{-# NEED Either #-}
data Either a b;
interface ! NHC.Internal
{-# NEED {World World} #-}
data World
  = World ;

{-# NEED _eqDouble #-}
_eqDouble{-# 2 #-}::(Prelude.Double -> (Prelude.Double -> Prelude.Bool));
interface Prelude
{-# NEED Double #-}
data Double;
interface ! NHC.Internal
{-# NEED _eqFloat #-}
_eqFloat{-# 2 #-}::(Prelude.Float -> (Prelude.Float -> Prelude.Bool));
interface Prelude
{-# NEED Float #-}
data Float;
interface ! NHC.Internal
{-# NEED _eqInteger #-}
_eqInteger{-# 2 #-}::(Prelude.Integer -> (Prelude.Integer -> Prelude.Bool));

{-# NEED _patternMatchFail #-}
_patternMatchFail{-# 1 #-}::([Prelude.Char] -> a);

{-# NEED _noMethodError #-}
_noMethodError{-# 1 #-}::([Prelude.Char] -> a);

{-# NEED _recUpdError #-}
_recUpdError{-# 1 #-}::([Prelude.Char] -> a);

{-# NEED _recConError #-}
_recConError{-# 1 #-}::([Prelude.Char] -> a);

{-# NEED _recSelError #-}
_recSelError{-# 1 #-}::([Prelude.Char] -> a);
interface Prelude
{-# NEED Bool #-}
data Bool;

{-# NEED Integer #-}
data Integer;
interface ! NHC.Internal
{-# NEED _id #-}
_id{-# 1 #-}::(a -> a);

{-# NEED _apply4 #-}
_apply4{-# 5 #-}::((a -> (b -> (c -> (d -> e)))) -> (a -> (b -> (c -> (d -> e)))));

{-# NEED _apply3 #-}
_apply3{-# 4 #-}::((a -> (b -> (c -> d))) -> (a -> (b -> (c -> d))));

{-# NEED _apply2 #-}
_apply2{-# 3 #-}::((a -> (b -> c)) -> (a -> (b -> c)));

{-# NEED _apply1 #-}
_apply1{-# 2 #-}::((a -> b) -> (a -> b));
interface Prelude
{-# NEED (->) #-}
data (->) a b;
}
