interface Language.Haskell.ParseUtils where {

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsModule;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsExportSpec;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsImportDecl;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsImportSpec;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsAssoc;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsDecl;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsMatch;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsConDecl;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsBangType;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsRhs;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedRhs;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQualType;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsType;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsLiteral;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsExp;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsPat;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsPatField;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsStmt;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsFieldUpdate;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsAlt;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedAlts;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedAlt;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.Module;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQName;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsName;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQOp;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsOp;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsCName;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsSafety;

{-# NEED #-}
instance Prelude.Functor (Language.Haskell.Pretty.DocM a);

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

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

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

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.Module;

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.HsSpecialCon;

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.HsQName;

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.HsName;

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.HsQOp;

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.HsOp;

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.HsCName;

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.HsSafety;

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

{-# NEED #-}
instance Prelude.Ord Language.Haskell.ParseMonad.LexContext;

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.SrcLoc;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Pretty.PPLayout;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsExportSpec;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsImportDecl;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsImportSpec;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsAssoc;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsDecl;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsMatch;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsConDecl;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsBangType;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsRhs;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsGuardedRhs;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsQualType;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsType;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsLiteral;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsExp;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsPat;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsPatField;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsStmt;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsFieldUpdate;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsAlt;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsGuardedAlts;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsGuardedAlt;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.Module;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsSpecialCon;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsQName;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsName;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsQOp;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsOp;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsCName;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.HsSafety;

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

{-# NEED #-}
instance Prelude.Eq Language.Haskell.ParseMonad.LexContext;

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.SrcLoc;

{-# NEED #-}
instance Prelude.Show Text.PrettyPrint.HughesPJ.Doc;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsModule;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsExportSpec;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsImportDecl;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsImportSpec;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsAssoc;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsDecl;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsMatch;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsConDecl;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsBangType;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsRhs;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsGuardedRhs;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsQualType;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsType;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsLiteral;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsExp;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsPat;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsPatField;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsStmt;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsFieldUpdate;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsAlt;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsGuardedAlts;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsGuardedAlt;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.Module;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsSpecialCon;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsQName;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsName;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsQOp;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsOp;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsCName;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsSafety;

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

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

{-# NEED #-}
instance Prelude.Show Language.Haskell.ParseMonad.LexContext;

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Language.Haskell.ParseMonad.ParseStatus a);

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.SrcLoc;

{-# NEED #-}
instance Prelude.Monad (Language.Haskell.Pretty.DocM a);

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

{-# NEED #-}
instance Prelude.Monad Language.Haskell.ParseMonad.P;
interface Language.Haskell.Pretty
{-# NEED PPLayout #-}
data PPLayout;
interface Text.PrettyPrint.HughesPJ
{-# NEED Doc #-}
data Doc;
interface Language.Haskell.Syntax
{-# NEED HsModule #-}
data HsModule;

{-# NEED HsExportSpec #-}
data HsExportSpec;

{-# NEED HsImportDecl #-}
data HsImportDecl;

{-# NEED HsImportSpec #-}
data HsImportSpec;

{-# NEED HsCName #-}
data HsCName;
interface Language.Haskell.Pretty
{-# NEED DocM #-}
newtype {-#  #-} DocM a b;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Language.Haskell.ParseUtils
{-# NEED checkRevDecls #-}
checkRevDecls{-# 0 #-}::([Language.Haskell.Syntax.HsDecl] -> (Language.Haskell.ParseMonad.P [Language.Haskell.Syntax.HsDecl]));

{-# NEED mkRecConstrOrUpdate #-}
mkRecConstrOrUpdate{-# 2 #-}::(Language.Haskell.Syntax.HsExp -> ([Language.Haskell.Syntax.HsFieldUpdate] -> (Language.Haskell.ParseMonad.P Language.Haskell.Syntax.HsExp)));

{-# NEED checkPrec #-}
checkPrec{-# 1 #-}::(Prelude.Integer -> (Language.Haskell.ParseMonad.P Prelude.Int));

{-# NEED checkUnQual #-}
checkUnQual{-# 1 #-}::(Language.Haskell.Syntax.HsQName -> (Language.Haskell.ParseMonad.P Language.Haskell.Syntax.HsName));

{-# NEED checkClassBody #-}
checkClassBody{-# 1 #-}::([Language.Haskell.Syntax.HsDecl] -> (Language.Haskell.ParseMonad.P [Language.Haskell.Syntax.HsDecl]));

{-# NEED checkValDef #-}
checkValDef{-# 4 #-}::(Language.Haskell.Syntax.SrcLoc -> (Language.Haskell.Syntax.HsExp -> (Language.Haskell.Syntax.HsRhs -> ([Language.Haskell.Syntax.HsDecl] -> (Language.Haskell.ParseMonad.P Language.Haskell.Syntax.HsDecl)))));

{-# NEED checkExpr #-}
checkExpr{-# 1 #-}::(Language.Haskell.Syntax.HsExp -> (Language.Haskell.ParseMonad.P Language.Haskell.Syntax.HsExp));

{-# NEED checkPattern #-}
checkPattern{-# 1 #-}::(Language.Haskell.Syntax.HsExp -> (Language.Haskell.ParseMonad.P Language.Haskell.Syntax.HsPat));
interface Language.Haskell.Syntax
{-# NEED HsGuardedAlt HsGuardedAlts HsAlt HsFieldUpdate HsStmt HsExp HsGuardedRhs HsRhs HsMatch HsDecl #-}
data HsGuardedAlt;
data HsGuardedAlts;
data HsAlt;
data HsFieldUpdate;
data HsStmt;
data HsExp;
data HsGuardedRhs;
data HsRhs;
data HsMatch;
data HsDecl;

{-# NEED HsSafety #-}
data HsSafety;

{-# NEED HsOp #-}
data HsOp;

{-# NEED HsAssoc #-}
data HsAssoc;

{-# NEED HsConDecl #-}
data HsConDecl;

{-# NEED HsBangType #-}
data HsBangType;

{-# NEED HsPatField HsPat #-}
data HsPatField;
data HsPat;

{-# NEED HsQOp #-}
data HsQOp;

{-# NEED HsLiteral #-}
data HsLiteral;
interface Ratio
{-# NEED Rational #-}
type {-# 1 #-} Rational = (Ratio.Ratio Prelude.Integer);

{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! Language.Haskell.ParseUtils
{-# NEED checkInstHeader #-}
checkInstHeader{-# 1 #-}::(Language.Haskell.Syntax.HsQualType -> (Language.Haskell.ParseMonad.P (Language.Haskell.Syntax.HsContext,Language.Haskell.Syntax.HsQName,[Language.Haskell.Syntax.HsType])));

{-# NEED checkClassHeader #-}
checkClassHeader{-# 1 #-}::(Language.Haskell.Syntax.HsQualType -> (Language.Haskell.ParseMonad.P (Language.Haskell.Syntax.HsContext,Language.Haskell.Syntax.HsName,[Language.Haskell.Syntax.HsName])));

{-# NEED checkDataHeader #-}
checkDataHeader{-# 1 #-}::(Language.Haskell.Syntax.HsQualType -> (Language.Haskell.ParseMonad.P (Language.Haskell.Syntax.HsContext,Language.Haskell.Syntax.HsName,[Language.Haskell.Syntax.HsName])));
interface Language.Haskell.Syntax
{-# NEED HsQualType #-}
data HsQualType;
interface ! Language.Haskell.ParseUtils
{-# NEED checkAssertion #-}
checkAssertion{-# 0 #-}::(Language.Haskell.Syntax.HsType -> (Language.Haskell.ParseMonad.P Language.Haskell.Syntax.HsAsst));

{-# NEED checkContext #-}
checkContext{-# 1 #-}::(Language.Haskell.Syntax.HsType -> (Language.Haskell.ParseMonad.P Language.Haskell.Syntax.HsContext));
interface Language.Haskell.Syntax
{-# NEED HsContext #-}
type {-# 2 #-} HsContext = [HsAsst];

{-# NEED HsAsst #-}
type {-# 1 #-} HsAsst = (HsQName,[HsType]);
interface ! Language.Haskell.ParseUtils
{-# NEED splitTyConApp #-}
splitTyConApp{-# 1 #-}::(Language.Haskell.Syntax.HsType -> (Language.Haskell.ParseMonad.P (Language.Haskell.Syntax.HsName,[Language.Haskell.Syntax.HsType])));
interface Language.Haskell.ParseMonad
{-# NEED P #-}
newtype {-#  #-} P a;

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

{-# NEED ParseMode #-}
data ParseMode;

{-# NEED ParseState #-}
type {-# 1 #-} ParseState = [LexContext];

{-# NEED LexContext #-}
data LexContext;
interface Language.Haskell.Syntax
{-# NEED SrcLoc #-}
data SrcLoc;

{-# NEED HsType #-}
data HsType;

{-# NEED HsQName #-}
data HsQName;

{-# NEED HsSpecialCon #-}
data HsSpecialCon;

{-# NEED Module #-}
newtype {-#  #-} Module;

{-# NEED HsName #-}
data HsName;
}