interface Text.ParserCombinators.Parsec.Prim where {
infixr  1 <|>;
infix   0 <?>;

{-# 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 Text.ParserCombinators.Parsec.Pos.SourcePos;

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

{-# NEED #-}
instance Prelude.Eq Text.ParserCombinators.Parsec.Pos.SourcePos;

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

{-# NEED #-}
instance Control.Monad.MonadPlus (GenParser a b);

{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.Maybe;

{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.[];

{-# NEED #-}
instance Prelude.Functor (GenParser a b);

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

{-# NEED #-}
instance Prelude.Monad (GenParser a b);

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

{-# NEED #-}
instance Prelude.Show Text.ParserCombinators.Parsec.Error.ParseError;

{-# NEED #-}
instance Prelude.Show Text.ParserCombinators.Parsec.Pos.SourcePos;

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! Text.ParserCombinators.Parsec.Prim
{-# NEED tokens #-}
tokens{-# 3 #-}::(Prelude.Eq a) => (([a] -> Prelude.String) -> ((Text.ParserCombinators.Parsec.Pos.SourcePos -> ([a] -> Text.ParserCombinators.Parsec.Pos.SourcePos)) -> ([a] -> (GenParser a b [a]))));

{-# NEED skipMany #-}
skipMany{-# 1 #-}::((GenParser a b c) -> (GenParser a b ()));

{-# NEED many #-}
many{-# 1 #-}::((GenParser a b c) -> (GenParser a b [c]));

{-# NEED unexpected #-}
unexpected{-# 1 #-}::(Prelude.String -> (GenParser a b c));

{-# NEED labels #-}
labels{-# 2 #-}::((GenParser a b c) -> ([Prelude.String] -> (GenParser a b c)));

{-# NEED label #-}
label{-# 2 #-}::((GenParser a b c) -> (Prelude.String -> (GenParser a b c)));

{-# NEED tokenPrimEx #-}
tokenPrimEx{-# 4 #-}::((a -> Prelude.String) -> ((Text.ParserCombinators.Parsec.Pos.SourcePos -> (a -> ([a] -> Text.ParserCombinators.Parsec.Pos.SourcePos))) -> ((Prelude.Maybe (Text.ParserCombinators.Parsec.Pos.SourcePos -> (a -> ([a] -> (b -> b))))) -> ((a -> (Prelude.Maybe c)) -> (GenParser a b c)))));

{-# NEED tokenPrim #-}
tokenPrim{-# 3 #-}::((a -> Prelude.String) -> ((Text.ParserCombinators.Parsec.Pos.SourcePos -> (a -> ([a] -> Text.ParserCombinators.Parsec.Pos.SourcePos))) -> ((a -> (Prelude.Maybe b)) -> (GenParser a c b))));

{-# NEED token #-}
token{-# 3 #-}::((a -> Prelude.String) -> ((a -> Text.ParserCombinators.Parsec.Pos.SourcePos) -> ((a -> (Prelude.Maybe b)) -> (GenParser a c b))));

{-# NEED try #-}
try{-# 1 #-}::((GenParser a b c) -> (GenParser a b c));

{-# NEED pzero #-}
pzero{-# 0 #-}::(GenParser a b c);

{-# NEED runParser #-}
runParser{-# 4 #-}::((GenParser a b c) -> (b -> (Text.ParserCombinators.Parsec.Pos.SourceName -> ([a] -> (Prelude.Either Text.ParserCombinators.Parsec.Error.ParseError c)))));

{-# NEED parse #-}
parse{-# 3 #-}::((GenParser a () b) -> (Text.ParserCombinators.Parsec.Pos.SourceName -> ([a] -> (Prelude.Either Text.ParserCombinators.Parsec.Error.ParseError b))));

{-# NEED parseTest #-}
parseTest{-# 2 #-}::(Prelude.Show b) => ((GenParser a () b) -> ([a] -> (NHC.Internal.IO ())));

{-# NEED parseFromFile #-}
parseFromFile{-# 2 #-}::((Parser a) -> (Text.ParserCombinators.Parsec.Pos.SourceName -> (NHC.Internal.IO (Prelude.Either Text.ParserCombinators.Parsec.Error.ParseError a))));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface Text.ParserCombinators.Parsec.Pos
{-# NEED SourceName #-}
type {-# 2 #-} SourceName = Prelude.String;
interface ! Text.ParserCombinators.Parsec.Prim
{-# NEED Parser #-}
type {-# 1 #-} Parser a = (GenParser Prelude.Char () a);

{-# NEED setParserState #-}
setParserState{-# 1 #-}::((State a b) -> (GenParser a b (State a b)));

{-# NEED getParserState #-}
getParserState{-# 0 #-}::(GenParser a b (State a b));

{-# NEED setInput #-}
setInput{-# 1 #-}::([a] -> (GenParser a b ()));

{-# NEED setPosition #-}
setPosition{-# 1 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> (GenParser a b ()));

{-# NEED getInput #-}
getInput{-# 0 #-}::(GenParser a b [a]);

{-# NEED getPosition #-}
getPosition{-# 0 #-}::(GenParser a b Text.ParserCombinators.Parsec.Pos.SourcePos);

{-# NEED updateState #-}
updateState{-# 1 #-}::((a -> a) -> (GenParser b a ()));

{-# NEED setState #-}
setState{-# 1 #-}::(a -> (GenParser b a ()));

{-# NEED getState #-}
getState{-# 0 #-}::(GenParser a b b);

{-# NEED (<|>) #-}
(<|>){-# 2 #-}::((GenParser a b c) -> ((GenParser a b c) -> (GenParser a b c)));

{-# NEED (<?>) #-}
(<?>){-# 2 #-}::((GenParser a b c) -> (Prelude.String -> (GenParser a b c)));

{-# NEED {GenParser} #-}
newtype {-#  #-} GenParser a b c
  = Parser ((State a b) -> (Consumed (Reply a b c)));
interface Text.ParserCombinators.Parsec.Prim
{-# NEED Reply #-}
data Reply a b c;
interface Text.ParserCombinators.Parsec.Error
{-# NEED ParseError #-}
data ParseError;
interface Text.ParserCombinators.Parsec.Prim
{-# NEED Consumed #-}
data Consumed a;
interface ! Text.ParserCombinators.Parsec.Prim
{-# NEED {State State stateInput statePos stateUser} #-}
data State a b
  = State {stateInput :: [a]} {statePos :: !Text.ParserCombinators.Parsec.Pos.SourcePos} {stateUser :: !b};
interface Text.ParserCombinators.Parsec.Pos
{-# NEED SourcePos #-}
data SourcePos;
}