# Generated from XPath.g4 by ANTLR 4.9.3
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3#")
        buf.write("\u0090\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2\3\2\3\3\3")
        buf.write("\3\3\3\5\3)\n\3\3\3\3\3\3\3\3\3\3\3\7\3\60\n\3\f\3\16")
        buf.write("\3\63\13\3\3\4\3\4\3\4\5\48\n\4\3\4\5\4;\n\4\3\5\3\5\3")
        buf.write("\5\3\5\5\5A\n\5\3\5\5\5D\n\5\3\6\3\6\3\6\3\6\5\6J\n\6")
        buf.write("\3\6\5\6M\n\6\3\7\3\7\3\7\5\7R\n\7\3\7\5\7U\n\7\3\b\3")
        buf.write("\b\3\b\3\b\3\b\5\b\\\n\b\5\b^\n\b\3\b\3\b\3\b\3\b\3\b")
        buf.write("\3\b\3\b\5\bg\n\b\3\b\3\b\5\bk\n\b\3\t\3\t\3\t\3\t\3\n")
        buf.write("\3\n\5\ns\n\n\3\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16\3\17")
        buf.write("\3\17\3\20\3\20\3\20\3\20\3\20\5\20\u0084\n\20\3\21\5")
        buf.write("\21\u0087\n\21\3\21\3\21\5\21\u008b\n\21\3\21\5\21\u008e")
        buf.write("\n\21\3\21\2\2\22\2\4\6\b\n\f\16\20\22\24\26\30\32\34")
        buf.write("\36 \2\4\4\2\7\7\t\16\3\2\31\32\2\u009c\2\"\3\2\2\2\4")
        buf.write("(\3\2\2\2\6\67\3\2\2\2\b<\3\2\2\2\nE\3\2\2\2\fQ\3\2\2")
        buf.write("\2\16j\3\2\2\2\20l\3\2\2\2\22r\3\2\2\2\24t\3\2\2\2\26")
        buf.write("v\3\2\2\2\30x\3\2\2\2\32z\3\2\2\2\34|\3\2\2\2\36\u0083")
        buf.write("\3\2\2\2 \u008d\3\2\2\2\"#\5\4\3\2#$\7\2\2\3$\3\3\2\2")
        buf.write("\2%)\5\6\4\2&)\5\b\5\2\')\5\n\6\2(%\3\2\2\2(&\3\2\2\2")
        buf.write("(\'\3\2\2\2)\61\3\2\2\2*\60\5\20\t\2+,\7\22\2\2,\60\5")
        buf.write("\6\4\2-.\7\3\2\2.\60\5\f\7\2/*\3\2\2\2/+\3\2\2\2/-\3\2")
        buf.write("\2\2\60\63\3\2\2\2\61/\3\2\2\2\61\62\3\2\2\2\62\5\3\2")
        buf.write("\2\2\63\61\3\2\2\2\648\7 \2\2\658\7\37\2\2\668\5\22\n")
        buf.write("\2\67\64\3\2\2\2\67\65\3\2\2\2\67\66\3\2\2\28:\3\2\2\2")
        buf.write("9;\5\16\b\2:9\3\2\2\2:;\3\2\2\2;\7\3\2\2\2<@\7\22\2\2")
        buf.write("=A\7 \2\2>A\7\37\2\2?A\5\22\n\2@=\3\2\2\2@>\3\2\2\2@?")
        buf.write("\3\2\2\2AC\3\2\2\2BD\5\16\b\2CB\3\2\2\2CD\3\2\2\2D\t\3")
        buf.write("\2\2\2EI\7\3\2\2FJ\7 \2\2GJ\7\37\2\2HJ\5\22\n\2IF\3\2")
        buf.write("\2\2IG\3\2\2\2IH\3\2\2\2JL\3\2\2\2KM\5\16\b\2LK\3\2\2")
        buf.write("\2LM\3\2\2\2M\13\3\2\2\2NR\7 \2\2OR\7\37\2\2PR\5\22\n")
        buf.write("\2QN\3\2\2\2QO\3\2\2\2QP\3\2\2\2RT\3\2\2\2SU\5\16\b\2")
        buf.write("TS\3\2\2\2TU\3\2\2\2U\r\3\2\2\2VW\7\4\2\2W]\5\4\3\2X[")
        buf.write("\5\30\r\2Y\\\5\36\20\2Z\\\5\4\3\2[Y\3\2\2\2[Z\3\2\2\2")
        buf.write("\\^\3\2\2\2]X\3\2\2\2]^\3\2\2\2^_\3\2\2\2_`\7\5\2\2`k")
        buf.write("\3\2\2\2ab\7\4\2\2bc\5\36\20\2cf\5\30\r\2dg\5\36\20\2")
        buf.write("eg\5\4\3\2fd\3\2\2\2fe\3\2\2\2gh\3\2\2\2hi\7\5\2\2ik\3")
        buf.write("\2\2\2jV\3\2\2\2ja\3\2\2\2k\17\3\2\2\2lm\7\4\2\2mn\7\35")
        buf.write("\2\2no\7\5\2\2o\21\3\2\2\2ps\5\26\f\2qs\5\24\13\2rp\3")
        buf.write("\2\2\2rq\3\2\2\2s\23\3\2\2\2tu\7\21\2\2u\25\3\2\2\2vw")
        buf.write("\7\6\2\2w\27\3\2\2\2xy\t\2\2\2y\31\3\2\2\2z{\t\3\2\2{")
        buf.write("\33\3\2\2\2|}\7\21\2\2}\35\3\2\2\2~\u0084\7\34\2\2\177")
        buf.write("\u0084\5 \21\2\u0080\u0084\7\31\2\2\u0081\u0084\7\32\2")
        buf.write("\2\u0082\u0084\7\33\2\2\u0083~\3\2\2\2\u0083\177\3\2\2")
        buf.write("\2\u0083\u0080\3\2\2\2\u0083\u0081\3\2\2\2\u0083\u0082")
        buf.write("\3\2\2\2\u0084\37\3\2\2\2\u0085\u0087\7\20\2\2\u0086\u0085")
        buf.write("\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088\3\2\2\2\u0088")
        buf.write("\u008e\7\36\2\2\u0089\u008b\7\20\2\2\u008a\u0089\3\2\2")
        buf.write("\2\u008a\u008b\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008e")
        buf.write("\7\35\2\2\u008d\u0086\3\2\2\2\u008d\u008a\3\2\2\2\u008e")
        buf.write("!\3\2\2\2\26(/\61\67:@CILQT[]fjr\u0083\u0086\u008a\u008d")
        return buf.getvalue()


class XPathParser ( Parser ):

    grammarFileName = "XPath.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'//'", "'['", "']'", "'@*'", "<INVALID>", 
                     "'<=>'", "'<>'", "'!='", "'<'", "<INVALID>", "'>'", 
                     "<INVALID>", "'+'", "'-'", "'*'", "'/'", "'%'", "'~'", 
                     "'&'", "'|'", "'||'", "'^'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "EQ", "NSEQ", "NEQ", "NEQJ", "LT", "LTE", 
                      "GT", "GTE", "PLUS", "MINUS", "ASTERISK", "SLASH", 
                      "PERCENT", "TILDE", "AMPERSAND", "PIPE", "CONCAT_PIPE", 
                      "HAT", "TRUE", "FALSE", "NULL", "STRING", "INTEGER_VALUE", 
                      "DECIMAL_VALUE", "ATTRIBUTE", "IDENTIFIER", "LETTER", 
                      "WS", "SPACE" ]

    RULE_statement = 0
    RULE_innerStatement = 1
    RULE_childSelector = 2
    RULE_rootSelector = 3
    RULE_rootDescendantSelector = 4
    RULE_descendantSelector = 5
    RULE_booleanSelector = 6
    RULE_indexSelector = 7
    RULE_allSelect = 8
    RULE_allNodes = 9
    RULE_allAttributes = 10
    RULE_comparisonOperator = 11
    RULE_booleanValue = 12
    RULE_allExpression = 13
    RULE_literal = 14
    RULE_number = 15

    ruleNames =  [ "statement", "innerStatement", "childSelector", "rootSelector", 
                   "rootDescendantSelector", "descendantSelector", "booleanSelector", 
                   "indexSelector", "allSelect", "allNodes", "allAttributes", 
                   "comparisonOperator", "booleanValue", "allExpression", 
                   "literal", "number" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    EQ=5
    NSEQ=6
    NEQ=7
    NEQJ=8
    LT=9
    LTE=10
    GT=11
    GTE=12
    PLUS=13
    MINUS=14
    ASTERISK=15
    SLASH=16
    PERCENT=17
    TILDE=18
    AMPERSAND=19
    PIPE=20
    CONCAT_PIPE=21
    HAT=22
    TRUE=23
    FALSE=24
    NULL=25
    STRING=26
    INTEGER_VALUE=27
    DECIMAL_VALUE=28
    ATTRIBUTE=29
    IDENTIFIER=30
    LETTER=31
    WS=32
    SPACE=33

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.9.3")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def innerStatement(self):
            return self.getTypedRuleContext(XPathParser.InnerStatementContext,0)


        def EOF(self):
            return self.getToken(XPathParser.EOF, 0)

        def getRuleIndex(self):
            return XPathParser.RULE_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatement" ):
                listener.enterStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatement" ):
                listener.exitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatement" ):
                return visitor.visitStatement(self)
            else:
                return visitor.visitChildren(self)




    def statement(self):

        localctx = XPathParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 32
            self.innerStatement()
            self.state = 33
            self.match(XPathParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InnerStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def childSelector(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XPathParser.ChildSelectorContext)
            else:
                return self.getTypedRuleContext(XPathParser.ChildSelectorContext,i)


        def rootSelector(self):
            return self.getTypedRuleContext(XPathParser.RootSelectorContext,0)


        def rootDescendantSelector(self):
            return self.getTypedRuleContext(XPathParser.RootDescendantSelectorContext,0)


        def indexSelector(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XPathParser.IndexSelectorContext)
            else:
                return self.getTypedRuleContext(XPathParser.IndexSelectorContext,i)


        def SLASH(self, i:int=None):
            if i is None:
                return self.getTokens(XPathParser.SLASH)
            else:
                return self.getToken(XPathParser.SLASH, i)

        def descendantSelector(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XPathParser.DescendantSelectorContext)
            else:
                return self.getTypedRuleContext(XPathParser.DescendantSelectorContext,i)


        def getRuleIndex(self):
            return XPathParser.RULE_innerStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInnerStatement" ):
                listener.enterInnerStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInnerStatement" ):
                listener.exitInnerStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInnerStatement" ):
                return visitor.visitInnerStatement(self)
            else:
                return visitor.visitChildren(self)




    def innerStatement(self):

        localctx = XPathParser.InnerStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_innerStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 38
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XPathParser.T__3, XPathParser.ASTERISK, XPathParser.ATTRIBUTE, XPathParser.IDENTIFIER]:
                self.state = 35
                self.childSelector()
                pass
            elif token in [XPathParser.SLASH]:
                self.state = 36
                self.rootSelector()
                pass
            elif token in [XPathParser.T__0]:
                self.state = 37
                self.rootDescendantSelector()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 47
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XPathParser.T__0) | (1 << XPathParser.T__1) | (1 << XPathParser.SLASH))) != 0):
                self.state = 45
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XPathParser.T__1]:
                    self.state = 40
                    self.indexSelector()
                    pass
                elif token in [XPathParser.SLASH]:
                    self.state = 41
                    self.match(XPathParser.SLASH)
                    self.state = 42
                    self.childSelector()
                    pass
                elif token in [XPathParser.T__0]:
                    self.state = 43
                    self.match(XPathParser.T__0)

                    self.state = 44
                    self.descendantSelector()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 49
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ChildSelectorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.ident = None # Token
            self.attr = None # Token
            self.allsel = None # AllSelectContext

        def IDENTIFIER(self):
            return self.getToken(XPathParser.IDENTIFIER, 0)

        def ATTRIBUTE(self):
            return self.getToken(XPathParser.ATTRIBUTE, 0)

        def allSelect(self):
            return self.getTypedRuleContext(XPathParser.AllSelectContext,0)


        def booleanSelector(self):
            return self.getTypedRuleContext(XPathParser.BooleanSelectorContext,0)


        def getRuleIndex(self):
            return XPathParser.RULE_childSelector

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterChildSelector" ):
                listener.enterChildSelector(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitChildSelector" ):
                listener.exitChildSelector(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitChildSelector" ):
                return visitor.visitChildSelector(self)
            else:
                return visitor.visitChildren(self)




    def childSelector(self):

        localctx = XPathParser.ChildSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_childSelector)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 53
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XPathParser.IDENTIFIER]:
                self.state = 50
                localctx.ident = self.match(XPathParser.IDENTIFIER)
                pass
            elif token in [XPathParser.ATTRIBUTE]:
                self.state = 51
                localctx.attr = self.match(XPathParser.ATTRIBUTE)
                pass
            elif token in [XPathParser.T__3, XPathParser.ASTERISK]:
                self.state = 52
                localctx.allsel = self.allSelect()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 56
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.state = 55
                self.booleanSelector()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RootSelectorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.ident = None # Token
            self.attr = None # Token
            self.allsel = None # AllSelectContext

        def SLASH(self):
            return self.getToken(XPathParser.SLASH, 0)

        def IDENTIFIER(self):
            return self.getToken(XPathParser.IDENTIFIER, 0)

        def ATTRIBUTE(self):
            return self.getToken(XPathParser.ATTRIBUTE, 0)

        def allSelect(self):
            return self.getTypedRuleContext(XPathParser.AllSelectContext,0)


        def booleanSelector(self):
            return self.getTypedRuleContext(XPathParser.BooleanSelectorContext,0)


        def getRuleIndex(self):
            return XPathParser.RULE_rootSelector

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRootSelector" ):
                listener.enterRootSelector(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRootSelector" ):
                listener.exitRootSelector(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRootSelector" ):
                return visitor.visitRootSelector(self)
            else:
                return visitor.visitChildren(self)




    def rootSelector(self):

        localctx = XPathParser.RootSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_rootSelector)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 58
            self.match(XPathParser.SLASH)
            self.state = 62
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XPathParser.IDENTIFIER]:
                self.state = 59
                localctx.ident = self.match(XPathParser.IDENTIFIER)
                pass
            elif token in [XPathParser.ATTRIBUTE]:
                self.state = 60
                localctx.attr = self.match(XPathParser.ATTRIBUTE)
                pass
            elif token in [XPathParser.T__3, XPathParser.ASTERISK]:
                self.state = 61
                localctx.allsel = self.allSelect()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 65
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.state = 64
                self.booleanSelector()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RootDescendantSelectorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.ident = None # Token
            self.attr = None # Token
            self.allsel = None # AllSelectContext

        def IDENTIFIER(self):
            return self.getToken(XPathParser.IDENTIFIER, 0)

        def ATTRIBUTE(self):
            return self.getToken(XPathParser.ATTRIBUTE, 0)

        def allSelect(self):
            return self.getTypedRuleContext(XPathParser.AllSelectContext,0)


        def booleanSelector(self):
            return self.getTypedRuleContext(XPathParser.BooleanSelectorContext,0)


        def getRuleIndex(self):
            return XPathParser.RULE_rootDescendantSelector

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRootDescendantSelector" ):
                listener.enterRootDescendantSelector(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRootDescendantSelector" ):
                listener.exitRootDescendantSelector(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRootDescendantSelector" ):
                return visitor.visitRootDescendantSelector(self)
            else:
                return visitor.visitChildren(self)




    def rootDescendantSelector(self):

        localctx = XPathParser.RootDescendantSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_rootDescendantSelector)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 67
            self.match(XPathParser.T__0)
            self.state = 71
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XPathParser.IDENTIFIER]:
                self.state = 68
                localctx.ident = self.match(XPathParser.IDENTIFIER)
                pass
            elif token in [XPathParser.ATTRIBUTE]:
                self.state = 69
                localctx.attr = self.match(XPathParser.ATTRIBUTE)
                pass
            elif token in [XPathParser.T__3, XPathParser.ASTERISK]:
                self.state = 70
                localctx.allsel = self.allSelect()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 74
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 73
                self.booleanSelector()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DescendantSelectorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.ident = None # Token
            self.attr = None # Token
            self.allsel = None # AllSelectContext

        def IDENTIFIER(self):
            return self.getToken(XPathParser.IDENTIFIER, 0)

        def ATTRIBUTE(self):
            return self.getToken(XPathParser.ATTRIBUTE, 0)

        def allSelect(self):
            return self.getTypedRuleContext(XPathParser.AllSelectContext,0)


        def booleanSelector(self):
            return self.getTypedRuleContext(XPathParser.BooleanSelectorContext,0)


        def getRuleIndex(self):
            return XPathParser.RULE_descendantSelector

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDescendantSelector" ):
                listener.enterDescendantSelector(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDescendantSelector" ):
                listener.exitDescendantSelector(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescendantSelector" ):
                return visitor.visitDescendantSelector(self)
            else:
                return visitor.visitChildren(self)




    def descendantSelector(self):

        localctx = XPathParser.DescendantSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_descendantSelector)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 79
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XPathParser.IDENTIFIER]:
                self.state = 76
                localctx.ident = self.match(XPathParser.IDENTIFIER)
                pass
            elif token in [XPathParser.ATTRIBUTE]:
                self.state = 77
                localctx.attr = self.match(XPathParser.ATTRIBUTE)
                pass
            elif token in [XPathParser.T__3, XPathParser.ASTERISK]:
                self.state = 78
                localctx.allsel = self.allSelect()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 82
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.state = 81
                self.booleanSelector()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanSelectorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.left = None # InnerStatementContext
            self.op = None # ComparisonOperatorContext
            self.rlit = None # LiteralContext
            self.stmt = None # InnerStatementContext
            self.llit = None # LiteralContext

        def innerStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XPathParser.InnerStatementContext)
            else:
                return self.getTypedRuleContext(XPathParser.InnerStatementContext,i)


        def comparisonOperator(self):
            return self.getTypedRuleContext(XPathParser.ComparisonOperatorContext,0)


        def literal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XPathParser.LiteralContext)
            else:
                return self.getTypedRuleContext(XPathParser.LiteralContext,i)


        def getRuleIndex(self):
            return XPathParser.RULE_booleanSelector

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBooleanSelector" ):
                listener.enterBooleanSelector(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBooleanSelector" ):
                listener.exitBooleanSelector(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBooleanSelector" ):
                return visitor.visitBooleanSelector(self)
            else:
                return visitor.visitChildren(self)




    def booleanSelector(self):

        localctx = XPathParser.BooleanSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_booleanSelector)
        self._la = 0 # Token type
        try:
            self.state = 104
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 84
                self.match(XPathParser.T__1)

                self.state = 85
                localctx.left = self.innerStatement()
                self.state = 91
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XPathParser.EQ) | (1 << XPathParser.NEQ) | (1 << XPathParser.NEQJ) | (1 << XPathParser.LT) | (1 << XPathParser.LTE) | (1 << XPathParser.GT) | (1 << XPathParser.GTE))) != 0):
                    self.state = 86
                    localctx.op = self.comparisonOperator()
                    self.state = 89
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [XPathParser.MINUS, XPathParser.TRUE, XPathParser.FALSE, XPathParser.NULL, XPathParser.STRING, XPathParser.INTEGER_VALUE, XPathParser.DECIMAL_VALUE]:
                        self.state = 87
                        localctx.rlit = self.literal()
                        pass
                    elif token in [XPathParser.T__0, XPathParser.T__3, XPathParser.ASTERISK, XPathParser.SLASH, XPathParser.ATTRIBUTE, XPathParser.IDENTIFIER]:
                        self.state = 88
                        localctx.stmt = self.innerStatement()
                        pass
                    else:
                        raise NoViableAltException(self)



                self.state = 93
                self.match(XPathParser.T__2)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 95
                self.match(XPathParser.T__1)
                self.state = 96
                localctx.llit = self.literal()
                self.state = 97
                localctx.op = self.comparisonOperator()
                self.state = 100
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XPathParser.MINUS, XPathParser.TRUE, XPathParser.FALSE, XPathParser.NULL, XPathParser.STRING, XPathParser.INTEGER_VALUE, XPathParser.DECIMAL_VALUE]:
                    self.state = 98
                    localctx.rlit = self.literal()
                    pass
                elif token in [XPathParser.T__0, XPathParser.T__3, XPathParser.ASTERISK, XPathParser.SLASH, XPathParser.ATTRIBUTE, XPathParser.IDENTIFIER]:
                    self.state = 99
                    localctx.stmt = self.innerStatement()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 102
                self.match(XPathParser.T__2)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IndexSelectorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.index = None # Token

        def INTEGER_VALUE(self):
            return self.getToken(XPathParser.INTEGER_VALUE, 0)

        def getRuleIndex(self):
            return XPathParser.RULE_indexSelector

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIndexSelector" ):
                listener.enterIndexSelector(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIndexSelector" ):
                listener.exitIndexSelector(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIndexSelector" ):
                return visitor.visitIndexSelector(self)
            else:
                return visitor.visitChildren(self)




    def indexSelector(self):

        localctx = XPathParser.IndexSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_indexSelector)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 106
            self.match(XPathParser.T__1)
            self.state = 107
            localctx.index = self.match(XPathParser.INTEGER_VALUE)
            self.state = 108
            self.match(XPathParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AllSelectContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def allAttributes(self):
            return self.getTypedRuleContext(XPathParser.AllAttributesContext,0)


        def allNodes(self):
            return self.getTypedRuleContext(XPathParser.AllNodesContext,0)


        def getRuleIndex(self):
            return XPathParser.RULE_allSelect

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAllSelect" ):
                listener.enterAllSelect(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAllSelect" ):
                listener.exitAllSelect(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAllSelect" ):
                return visitor.visitAllSelect(self)
            else:
                return visitor.visitChildren(self)




    def allSelect(self):

        localctx = XPathParser.AllSelectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_allSelect)
        try:
            self.state = 112
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XPathParser.T__3]:
                self.enterOuterAlt(localctx, 1)
                self.state = 110
                self.allAttributes()
                pass
            elif token in [XPathParser.ASTERISK]:
                self.enterOuterAlt(localctx, 2)
                self.state = 111
                self.allNodes()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AllNodesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ASTERISK(self):
            return self.getToken(XPathParser.ASTERISK, 0)

        def getRuleIndex(self):
            return XPathParser.RULE_allNodes

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAllNodes" ):
                listener.enterAllNodes(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAllNodes" ):
                listener.exitAllNodes(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAllNodes" ):
                return visitor.visitAllNodes(self)
            else:
                return visitor.visitChildren(self)




    def allNodes(self):

        localctx = XPathParser.AllNodesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_allNodes)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 114
            self.match(XPathParser.ASTERISK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AllAttributesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return XPathParser.RULE_allAttributes

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAllAttributes" ):
                listener.enterAllAttributes(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAllAttributes" ):
                listener.exitAllAttributes(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAllAttributes" ):
                return visitor.visitAllAttributes(self)
            else:
                return visitor.visitChildren(self)




    def allAttributes(self):

        localctx = XPathParser.AllAttributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_allAttributes)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 116
            self.match(XPathParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComparisonOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQ(self):
            return self.getToken(XPathParser.EQ, 0)

        def NEQ(self):
            return self.getToken(XPathParser.NEQ, 0)

        def NEQJ(self):
            return self.getToken(XPathParser.NEQJ, 0)

        def LT(self):
            return self.getToken(XPathParser.LT, 0)

        def LTE(self):
            return self.getToken(XPathParser.LTE, 0)

        def GT(self):
            return self.getToken(XPathParser.GT, 0)

        def GTE(self):
            return self.getToken(XPathParser.GTE, 0)

        def getRuleIndex(self):
            return XPathParser.RULE_comparisonOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComparisonOperator" ):
                listener.enterComparisonOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComparisonOperator" ):
                listener.exitComparisonOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComparisonOperator" ):
                return visitor.visitComparisonOperator(self)
            else:
                return visitor.visitChildren(self)




    def comparisonOperator(self):

        localctx = XPathParser.ComparisonOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_comparisonOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 118
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XPathParser.EQ) | (1 << XPathParser.NEQ) | (1 << XPathParser.NEQJ) | (1 << XPathParser.LT) | (1 << XPathParser.LTE) | (1 << XPathParser.GT) | (1 << XPathParser.GTE))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TRUE(self):
            return self.getToken(XPathParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(XPathParser.FALSE, 0)

        def getRuleIndex(self):
            return XPathParser.RULE_booleanValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBooleanValue" ):
                listener.enterBooleanValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBooleanValue" ):
                listener.exitBooleanValue(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBooleanValue" ):
                return visitor.visitBooleanValue(self)
            else:
                return visitor.visitChildren(self)




    def booleanValue(self):

        localctx = XPathParser.BooleanValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_booleanValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 120
            _la = self._input.LA(1)
            if not(_la==XPathParser.TRUE or _la==XPathParser.FALSE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AllExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ASTERISK(self):
            return self.getToken(XPathParser.ASTERISK, 0)

        def getRuleIndex(self):
            return XPathParser.RULE_allExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAllExpression" ):
                listener.enterAllExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAllExpression" ):
                listener.exitAllExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAllExpression" ):
                return visitor.visitAllExpression(self)
            else:
                return visitor.visitChildren(self)




    def allExpression(self):

        localctx = XPathParser.AllExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_allExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 122
            self.match(XPathParser.ASTERISK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return XPathParser.RULE_literal

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class NullLiteralContext(LiteralContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a XPathParser.LiteralContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NULL(self):
            return self.getToken(XPathParser.NULL, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNullLiteral" ):
                listener.enterNullLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNullLiteral" ):
                listener.exitNullLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNullLiteral" ):
                return visitor.visitNullLiteral(self)
            else:
                return visitor.visitChildren(self)


    class FalseLiteralContext(LiteralContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a XPathParser.LiteralContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def FALSE(self):
            return self.getToken(XPathParser.FALSE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFalseLiteral" ):
                listener.enterFalseLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFalseLiteral" ):
                listener.exitFalseLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFalseLiteral" ):
                return visitor.visitFalseLiteral(self)
            else:
                return visitor.visitChildren(self)


    class StringLiteralContext(LiteralContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a XPathParser.LiteralContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def STRING(self):
            return self.getToken(XPathParser.STRING, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStringLiteral" ):
                listener.enterStringLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStringLiteral" ):
                listener.exitStringLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringLiteral" ):
                return visitor.visitStringLiteral(self)
            else:
                return visitor.visitChildren(self)


    class TrueLiteralContext(LiteralContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a XPathParser.LiteralContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TRUE(self):
            return self.getToken(XPathParser.TRUE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrueLiteral" ):
                listener.enterTrueLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrueLiteral" ):
                listener.exitTrueLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrueLiteral" ):
                return visitor.visitTrueLiteral(self)
            else:
                return visitor.visitChildren(self)


    class NumberLiteralContext(LiteralContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a XPathParser.LiteralContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def number(self):
            return self.getTypedRuleContext(XPathParser.NumberContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumberLiteral" ):
                listener.enterNumberLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumberLiteral" ):
                listener.exitNumberLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumberLiteral" ):
                return visitor.visitNumberLiteral(self)
            else:
                return visitor.visitChildren(self)



    def literal(self):

        localctx = XPathParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_literal)
        try:
            self.state = 129
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XPathParser.STRING]:
                localctx = XPathParser.StringLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 124
                self.match(XPathParser.STRING)
                pass
            elif token in [XPathParser.MINUS, XPathParser.INTEGER_VALUE, XPathParser.DECIMAL_VALUE]:
                localctx = XPathParser.NumberLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 125
                self.number()
                pass
            elif token in [XPathParser.TRUE]:
                localctx = XPathParser.TrueLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 126
                self.match(XPathParser.TRUE)
                pass
            elif token in [XPathParser.FALSE]:
                localctx = XPathParser.FalseLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 127
                self.match(XPathParser.FALSE)
                pass
            elif token in [XPathParser.NULL]:
                localctx = XPathParser.NullLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 128
                self.match(XPathParser.NULL)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return XPathParser.RULE_number

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class DecimalLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a XPathParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DECIMAL_VALUE(self):
            return self.getToken(XPathParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(XPathParser.MINUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDecimalLiteral" ):
                listener.enterDecimalLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDecimalLiteral" ):
                listener.exitDecimalLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDecimalLiteral" ):
                return visitor.visitDecimalLiteral(self)
            else:
                return visitor.visitChildren(self)


    class IntegerLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a XPathParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def INTEGER_VALUE(self):
            return self.getToken(XPathParser.INTEGER_VALUE, 0)
        def MINUS(self):
            return self.getToken(XPathParser.MINUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIntegerLiteral" ):
                listener.enterIntegerLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIntegerLiteral" ):
                listener.exitIntegerLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntegerLiteral" ):
                return visitor.visitIntegerLiteral(self)
            else:
                return visitor.visitChildren(self)



    def number(self):

        localctx = XPathParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.state = 139
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                localctx = XPathParser.DecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 132
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XPathParser.MINUS:
                    self.state = 131
                    self.match(XPathParser.MINUS)


                self.state = 134
                self.match(XPathParser.DECIMAL_VALUE)
                pass

            elif la_ == 2:
                localctx = XPathParser.IntegerLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 136
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XPathParser.MINUS:
                    self.state = 135
                    self.match(XPathParser.MINUS)


                self.state = 138
                self.match(XPathParser.INTEGER_VALUE)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx