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

{-# NEED #-}
instance Ix.Ix Data.Char.GeneralCategory;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Bounded Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Functor (Text.ParserCombinators.Parsec.Prim.GenParser a b);

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

{-# NEED #-}
instance Prelude.Monad (Text.ParserCombinators.Parsec.Prim.GenParser a b);

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

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

{-# NEED #-}
instance Prelude.Num NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Real NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Enum Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Read Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Read NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Ord Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CInt;

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

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

{-# NEED #-}
instance Prelude.Eq Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CInt;

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

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

{-# NEED #-}
instance Prelude.Show Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Show NHC.FFI.CInt;

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

{-# 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.Integral NHC.FFI.CInt;
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface NHC.FFI
{-# NEED CInt #-}
newtype {-#  #-} CInt;
interface ! Text.ParserCombinators.Parsec.Pos
{-# NEED sourceName #-}
sourceName{-# 1 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> Text.ParserCombinators.Parsec.Pos.SourceName);

{-# NEED sourceLine #-}
sourceLine{-# 1 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> Text.ParserCombinators.Parsec.Pos.Line);

{-# NEED sourceColumn #-}
sourceColumn{-# 1 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> Text.ParserCombinators.Parsec.Pos.Column);

{-# NEED incSourceLine #-}
incSourceLine{-# 2 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> (Text.ParserCombinators.Parsec.Pos.Line -> Text.ParserCombinators.Parsec.Pos.SourcePos));

{-# NEED incSourceColumn #-}
incSourceColumn{-# 2 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> (Text.ParserCombinators.Parsec.Pos.Column -> Text.ParserCombinators.Parsec.Pos.SourcePos));

{-# NEED setSourceName #-}
setSourceName{-# 2 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> (Text.ParserCombinators.Parsec.Pos.SourceName -> Text.ParserCombinators.Parsec.Pos.SourcePos));

{-# NEED setSourceLine #-}
setSourceLine{-# 2 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> (Text.ParserCombinators.Parsec.Pos.Line -> Text.ParserCombinators.Parsec.Pos.SourcePos));

{-# NEED Line #-}
type {-# 3 #-} Line = Prelude.Int;

{-# NEED setSourceColumn #-}
setSourceColumn{-# 2 #-}::(Text.ParserCombinators.Parsec.Pos.SourcePos -> (Text.ParserCombinators.Parsec.Pos.Column -> Text.ParserCombinators.Parsec.Pos.SourcePos));

{-# NEED Column #-}
type {-# 4 #-} Column = Prelude.Int;
interface ! Text.ParserCombinators.Parsec.Combinator
{-# NEED choice #-}
choice{-# 1 #-}::([(Text.ParserCombinators.Parsec.Prim.GenParser a b c)] -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c));

{-# NEED option #-}
option{-# 2 #-}::(a -> ((Text.ParserCombinators.Parsec.Prim.GenParser b c a) -> (Text.ParserCombinators.Parsec.Prim.GenParser b c a)));

{-# NEED optionMaybe #-}
optionMaybe{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b (Prelude.Maybe c)));

{-# NEED optional #-}
optional{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b ()));

{-# NEED between #-}
between{-# 3 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b d) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b e) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b e))));

{-# NEED skipMany1 #-}
skipMany1{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b ()));

{-# NEED many1 #-}
many1{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c]));

{-# NEED sepBy #-}
sepBy{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b d) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c])));

{-# NEED sepBy1 #-}
sepBy1{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b d) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c])));

{-# NEED sepEndBy1 #-}
sepEndBy1{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b d) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c])));

{-# NEED sepEndBy #-}
sepEndBy{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b d) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c])));

{-# NEED endBy1 #-}
endBy1{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b d) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c])));

{-# NEED endBy #-}
endBy{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b d) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c])));

{-# NEED count #-}
count{-# 2 #-}::(Prelude.Int -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c])));

{-# NEED chainr #-}
chainr{-# 3 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b (c -> (c -> c))) -> (c -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c))));

{-# NEED chainl #-}
chainl{-# 3 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b (c -> (c -> c))) -> (c -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c))));

{-# NEED chainl1 #-}
chainl1{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b (c -> (c -> c))) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c)));

{-# NEED chainr1 #-}
chainr1{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b (c -> (c -> c))) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c)));

{-# NEED anyToken #-}
anyToken{-# 0 #-}::(Prelude.Show a) => (Text.ParserCombinators.Parsec.Prim.GenParser a b a);

{-# NEED eof #-}
eof{-# 0 #-}::(Prelude.Show a) => (Text.ParserCombinators.Parsec.Prim.GenParser a b ());

{-# NEED notFollowedBy #-}
notFollowedBy{-# 1 #-}::(Prelude.Show a) => ((Text.ParserCombinators.Parsec.Prim.GenParser a b a) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b ()));

{-# NEED manyTill #-}
manyTill{-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b d) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c])));

{-# NEED lookAhead #-}
lookAhead{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c));
interface ! Text.ParserCombinators.Parsec.Error
{-# NEED errorPos #-}
errorPos{-# 1 #-}::(Text.ParserCombinators.Parsec.Error.ParseError -> Text.ParserCombinators.Parsec.Pos.SourcePos);
interface ! Text.ParserCombinators.Parsec.Char
{-# NEED oneOf #-}
oneOf{-# 1 #-}::([Prelude.Char] -> (Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char));

{-# NEED noneOf #-}
noneOf{-# 1 #-}::([Prelude.Char] -> (Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char));

{-# NEED spaces #-}
spaces{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a ());

{-# NEED space #-}
space{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED newline #-}
newline{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED tab #-}
tab{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED upper #-}
upper{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED lower #-}
lower{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED alphaNum #-}
alphaNum{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED letter #-}
letter{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED digit #-}
digit{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED hexDigit #-}
hexDigit{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED octDigit #-}
octDigit{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED char #-}
char{-# 1 #-}::(Prelude.Char -> (Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char));

{-# NEED anyChar #-}
anyChar{-# 0 #-}::(Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char);

{-# NEED satisfy #-}
satisfy{-# 1 #-}::((Prelude.Char -> Prelude.Bool) -> (Text.ParserCombinators.Parsec.Char.CharParser a Prelude.Char));

{-# NEED string #-}
string{-# 1 #-}::(Prelude.String -> (Text.ParserCombinators.Parsec.Char.CharParser a Prelude.String));

{-# NEED CharParser #-}
type {-# 1 #-} CharParser a b = (Text.ParserCombinators.Parsec.Prim.GenParser Prelude.Char a b);
interface ! Text.ParserCombinators.Parsec.Prim
{-# NEED (<?>) #-}
(<?>){-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Prelude.String -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c)));

{-# NEED (<|>) #-}
(<|>){-# 2 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> ((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c)));

{-# NEED getState #-}
getState{-# 0 #-}::(Text.ParserCombinators.Parsec.Prim.GenParser a b b);

{-# NEED setState #-}
setState{-# 1 #-}::(a -> (Text.ParserCombinators.Parsec.Prim.GenParser b a ()));

{-# NEED updateState #-}
updateState{-# 1 #-}::((a -> a) -> (Text.ParserCombinators.Parsec.Prim.GenParser b a ()));

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

{-# NEED getInput #-}
getInput{-# 0 #-}::(Text.ParserCombinators.Parsec.Prim.GenParser a b [a]);

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

{-# NEED setInput #-}
setInput{-# 1 #-}::([a] -> (Text.ParserCombinators.Parsec.Prim.GenParser a b ()));

{-# NEED getParserState #-}
getParserState{-# 0 #-}::(Text.ParserCombinators.Parsec.Prim.GenParser a b (Text.ParserCombinators.Parsec.Prim.State a b));

{-# NEED setParserState #-}
setParserState{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.State a b) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b (Text.ParserCombinators.Parsec.Prim.State a b)));

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

{-# NEED Parser #-}
type {-# 1 #-} Parser a = (Text.ParserCombinators.Parsec.Prim.GenParser Prelude.Char () a);

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

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

{-# NEED runParser #-}
runParser{-# 4 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (b -> (Text.ParserCombinators.Parsec.Pos.SourceName -> ([a] -> (Prelude.Either Text.ParserCombinators.Parsec.Error.ParseError c)))));
interface ! Text.ParserCombinators.Parsec.Error
{-# NEED ParseError #-}
data ParseError;
interface ! Text.ParserCombinators.Parsec.Pos
{-# NEED SourceName #-}
type {-# 2 #-} SourceName = Prelude.String;
interface ! Text.ParserCombinators.Parsec.Prim
{-# NEED pzero #-}
pzero{-# 0 #-}::(Text.ParserCombinators.Parsec.Prim.GenParser a b c);

{-# NEED try #-}
try{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c));

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

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

{-# 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)) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b c)))));

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

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

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

{-# NEED many #-}
many{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [c]));

{-# NEED skipMany #-}
skipMany{-# 1 #-}::((Text.ParserCombinators.Parsec.Prim.GenParser a b c) -> (Text.ParserCombinators.Parsec.Prim.GenParser a b ()));

{-# NEED tokens #-}
tokens{-# 3 #-}::(Prelude.Eq a) => (([a] -> Prelude.String) -> ((Text.ParserCombinators.Parsec.Pos.SourcePos -> ([a] -> Text.ParserCombinators.Parsec.Pos.SourcePos)) -> ([a] -> (Text.ParserCombinators.Parsec.Prim.GenParser a b [a]))));

{-# NEED {GenParser} #-}
newtype {-#  #-} GenParser a b c
  = Unexported.Constr_16 ((Text.ParserCombinators.Parsec.Prim.State a b) -> (Text.ParserCombinators.Parsec.Prim.Consumed (Text.ParserCombinators.Parsec.Prim.Reply a b c)));
interface Text.ParserCombinators.Parsec.Prim
{-# NEED Reply #-}
data Reply a b c;

{-# NEED Consumed #-}
data Consumed a;
interface ! Text.ParserCombinators.Parsec.Prim
{-# NEED {State State stateInput statePos stateUser} #-}
data State a b
  = State {Text.ParserCombinators.Parsec.Prim.stateInput :: [a]} {Text.ParserCombinators.Parsec.Prim.statePos :: !Text.ParserCombinators.Parsec.Pos.SourcePos} {Text.ParserCombinators.Parsec.Prim.stateUser :: !b};
interface ! Text.ParserCombinators.Parsec.Pos
{-# NEED SourcePos #-}
data SourcePos;
}