# Generated from ./Hello.g4 by ANTLR 4.13.2
# 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():
    return [
        4,1,6,29,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,1,0,4,0,12,8,0,
        11,0,12,0,13,1,1,4,1,17,8,1,11,1,12,1,18,1,2,1,2,1,3,1,3,1,3,1,4,
        1,4,1,4,1,4,0,0,5,0,2,4,6,8,0,2,1,0,1,2,1,0,3,4,25,0,11,1,0,0,0,
        2,16,1,0,0,0,4,20,1,0,0,0,6,22,1,0,0,0,8,25,1,0,0,0,10,12,3,4,2,
        0,11,10,1,0,0,0,12,13,1,0,0,0,13,11,1,0,0,0,13,14,1,0,0,0,14,1,1,
        0,0,0,15,17,3,8,4,0,16,15,1,0,0,0,17,18,1,0,0,0,18,16,1,0,0,0,18,
        19,1,0,0,0,19,3,1,0,0,0,20,21,7,0,0,0,21,5,1,0,0,0,22,23,5,1,0,0,
        23,24,5,5,0,0,24,7,1,0,0,0,25,26,7,1,0,0,26,27,5,5,0,0,27,9,1,0,
        0,0,2,13,18
    ]

class HelloParser ( Parser ):

    grammarFileName = "Hello.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'hello'", "'hi'", "'bye'", "'goodbye'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "ID", "WS" ]

    RULE_greeting = 0
    RULE_leaving = 1
    RULE_greet = 2
    RULE_start = 3
    RULE_bye = 4

    ruleNames =  [ "greeting", "leaving", "greet", "start", "bye" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    ID=5
    WS=6

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




    class GreetingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def greet(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HelloParser.GreetContext)
            else:
                return self.getTypedRuleContext(HelloParser.GreetContext,i)


        def getRuleIndex(self):
            return HelloParser.RULE_greeting

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

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




    def greeting(self):

        localctx = HelloParser.GreetingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_greeting)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 11 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 10
                self.greet()
                self.state = 13 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==1 or _la==2):
                    break

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


    class LeavingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def bye(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HelloParser.ByeContext)
            else:
                return self.getTypedRuleContext(HelloParser.ByeContext,i)


        def getRuleIndex(self):
            return HelloParser.RULE_leaving

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

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




    def leaving(self):

        localctx = HelloParser.LeavingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_leaving)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 16 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 15
                self.bye()
                self.state = 18 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==3 or _la==4):
                    break

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


    class GreetContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return HelloParser.RULE_greet

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

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




    def greet(self):

        localctx = HelloParser.GreetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_greet)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 20
            _la = self._input.LA(1)
            if not(_la==1 or _la==2):
                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 StartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ID(self):
            return self.getToken(HelloParser.ID, 0)

        def getRuleIndex(self):
            return HelloParser.RULE_start

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

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




    def start(self):

        localctx = HelloParser.StartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_start)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 22
            self.match(HelloParser.T__0)
            self.state = 23
            self.match(HelloParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ByeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ID(self):
            return self.getToken(HelloParser.ID, 0)

        def getRuleIndex(self):
            return HelloParser.RULE_bye

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

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




    def bye(self):

        localctx = HelloParser.ByeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_bye)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 25
            _la = self._input.LA(1)
            if not(_la==3 or _la==4):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 26
            self.match(HelloParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx