# Generated from ArmControl.g4 by ANTLR 4.7.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
from typing.io import TextIO
import sys


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\21")
        buf.write("X\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b")
        buf.write("\t\b\4\t\t\t\4\n\t\n\3\2\7\2\26\n\2\f\2\16\2\31\13\2\3")
        buf.write("\2\3\2\3\3\3\3\3\3\7\3 \n\3\f\3\16\3#\13\3\3\3\5\3&\n")
        buf.write("\3\3\3\5\3)\n\3\3\4\3\4\3\4\3\4\3\4\3\4\5\4\61\n\4\3\4")
        buf.write("\3\4\3\4\3\4\5\4\67\n\4\3\4\3\4\5\4;\n\4\3\5\3\5\5\5?")
        buf.write("\n\5\3\5\3\5\5\5C\n\5\7\5E\n\5\f\5\16\5H\13\5\3\5\3\5")
        buf.write("\3\6\3\6\3\7\3\7\5\7P\n\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n")
        buf.write("\2\2\13\2\4\6\b\n\f\16\20\22\2\2\2]\2\27\3\2\2\2\4(\3")
        buf.write("\2\2\2\6:\3\2\2\2\b<\3\2\2\2\nK\3\2\2\2\fO\3\2\2\2\16")
        buf.write("Q\3\2\2\2\20S\3\2\2\2\22U\3\2\2\2\24\26\5\4\3\2\25\24")
        buf.write("\3\2\2\2\26\31\3\2\2\2\27\25\3\2\2\2\27\30\3\2\2\2\30")
        buf.write("\32\3\2\2\2\31\27\3\2\2\2\32\33\7\2\2\3\33\3\3\2\2\2\34")
        buf.write("!\5\6\4\2\35\36\7\3\2\2\36 \5\6\4\2\37\35\3\2\2\2 #\3")
        buf.write("\2\2\2!\37\3\2\2\2!\"\3\2\2\2\"%\3\2\2\2#!\3\2\2\2$&\7")
        buf.write("\17\2\2%$\3\2\2\2%&\3\2\2\2&)\3\2\2\2\')\7\17\2\2(\34")
        buf.write("\3\2\2\2(\'\3\2\2\2)\5\3\2\2\2*\60\7\4\2\2+\61\5\b\5\2")
        buf.write(",-\5\n\6\2-.\5\f\7\2.\61\3\2\2\2/\61\5\n\6\2\60+\3\2\2")
        buf.write("\2\60,\3\2\2\2\60/\3\2\2\2\61;\3\2\2\2\62\63\7\5\2\2\63")
        buf.write(";\5\16\b\2\64\66\7\6\2\2\65\67\5\16\b\2\66\65\3\2\2\2")
        buf.write("\66\67\3\2\2\2\67;\3\2\2\28;\7\7\2\29;\7\b\2\2:*\3\2\2")
        buf.write("\2:\62\3\2\2\2:\64\3\2\2\2:8\3\2\2\2:9\3\2\2\2;\7\3\2")
        buf.write("\2\2<>\7\t\2\2=?\5\f\7\2>=\3\2\2\2>?\3\2\2\2?F\3\2\2\2")
        buf.write("@B\5\22\n\2AC\5\f\7\2BA\3\2\2\2BC\3\2\2\2CE\3\2\2\2D@")
        buf.write("\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2GI\3\2\2\2HF\3\2")
        buf.write("\2\2IJ\7\n\2\2J\t\3\2\2\2KL\7\13\2\2L\13\3\2\2\2MP\5\16")
        buf.write("\b\2NP\5\20\t\2OM\3\2\2\2ON\3\2\2\2P\r\3\2\2\2QR\7\f\2")
        buf.write("\2R\17\3\2\2\2ST\7\r\2\2T\21\3\2\2\2UV\7\16\2\2V\23\3")
        buf.write("\2\2\2\r\27!%(\60\66:>BFO")
        return buf.getvalue()


class ArmControlParser ( Parser ):

    grammarFileName = "ArmControl.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "';'", "'go'", "'pause'", "'wait'", "'pass'", 
                     "'whereami'", "'{'", "'}'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "','" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "NAME", "NUMBER", "HEX", "SEPERATOR", 
                      "NEWLINE", "WS", "COMMENT" ]

    RULE_prog = 0
    RULE_statement = 1
    RULE_command = 2
    RULE_coords = 3
    RULE_name = 4
    RULE_value = 5
    RULE_number = 6
    RULE_hexidecimal = 7
    RULE_seperator = 8

    ruleNames =  [ "prog", "statement", "command", "coords", "name", "value", 
                   "number", "hexidecimal", "seperator" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    NAME=9
    NUMBER=10
    HEX=11
    SEPERATOR=12
    NEWLINE=13
    WS=14
    COMMENT=15

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




    class ProgContext(ParserRuleContext):

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

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

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ArmControlParser.StatementContext)
            else:
                return self.getTypedRuleContext(ArmControlParser.StatementContext,i)


        def getRuleIndex(self):
            return ArmControlParser.RULE_prog

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

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




    def prog(self):

        localctx = ArmControlParser.ProgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_prog)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 21
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ArmControlParser.T__1) | (1 << ArmControlParser.T__2) | (1 << ArmControlParser.T__3) | (1 << ArmControlParser.T__4) | (1 << ArmControlParser.T__5) | (1 << ArmControlParser.NEWLINE))) != 0):
                self.state = 18
                self.statement()
                self.state = 23
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 24
            self.match(ArmControlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):

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

        def command(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ArmControlParser.CommandContext)
            else:
                return self.getTypedRuleContext(ArmControlParser.CommandContext,i)


        def NEWLINE(self):
            return self.getToken(ArmControlParser.NEWLINE, 0)

        def getRuleIndex(self):
            return ArmControlParser.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 statement(self):

        localctx = ArmControlParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 38
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ArmControlParser.T__1, ArmControlParser.T__2, ArmControlParser.T__3, ArmControlParser.T__4, ArmControlParser.T__5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 26
                self.command()
                self.state = 31
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ArmControlParser.T__0:
                    self.state = 27
                    self.match(ArmControlParser.T__0)
                    self.state = 28
                    self.command()
                    self.state = 33
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 35
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
                if la_ == 1:
                    self.state = 34
                    self.match(ArmControlParser.NEWLINE)


                pass
            elif token in [ArmControlParser.NEWLINE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 37
                self.match(ArmControlParser.NEWLINE)
                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 CommandContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return ArmControlParser.RULE_command

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



    class PauseContext(CommandContext):

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

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


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

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


    class PassContext(CommandContext):

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


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

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


    class GoContext(CommandContext):

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

        def coords(self):
            return self.getTypedRuleContext(ArmControlParser.CoordsContext,0)

        def name(self):
            return self.getTypedRuleContext(ArmControlParser.NameContext,0)

        def value(self):
            return self.getTypedRuleContext(ArmControlParser.ValueContext,0)


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

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


    class WhereAmIContext(CommandContext):

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


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

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


    class WaitContext(CommandContext):

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

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


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

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



    def command(self):

        localctx = ArmControlParser.CommandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_command)
        self._la = 0 # Token type
        try:
            self.state = 56
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ArmControlParser.T__1]:
                localctx = ArmControlParser.GoContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 40
                self.match(ArmControlParser.T__1)
                self.state = 46
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
                if la_ == 1:
                    self.state = 41
                    self.coords()
                    pass

                elif la_ == 2:
                    self.state = 42
                    self.name()
                    self.state = 43
                    self.value()
                    pass

                elif la_ == 3:
                    self.state = 45
                    self.name()
                    pass


                pass
            elif token in [ArmControlParser.T__2]:
                localctx = ArmControlParser.PauseContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 48
                self.match(ArmControlParser.T__2)
                self.state = 49
                self.number()
                pass
            elif token in [ArmControlParser.T__3]:
                localctx = ArmControlParser.WaitContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 50
                self.match(ArmControlParser.T__3)
                self.state = 52
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ArmControlParser.NUMBER:
                    self.state = 51
                    self.number()


                pass
            elif token in [ArmControlParser.T__4]:
                localctx = ArmControlParser.PassContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 54
                self.match(ArmControlParser.T__4)
                pass
            elif token in [ArmControlParser.T__5]:
                localctx = ArmControlParser.WhereAmIContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 55
                self.match(ArmControlParser.T__5)
                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 CoordsContext(ParserRuleContext):

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

        def value(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ArmControlParser.ValueContext)
            else:
                return self.getTypedRuleContext(ArmControlParser.ValueContext,i)


        def seperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ArmControlParser.SeperatorContext)
            else:
                return self.getTypedRuleContext(ArmControlParser.SeperatorContext,i)


        def getRuleIndex(self):
            return ArmControlParser.RULE_coords

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

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




    def coords(self):

        localctx = ArmControlParser.CoordsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_coords)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 58
            self.match(ArmControlParser.T__6)
            self.state = 60
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ArmControlParser.NUMBER or _la==ArmControlParser.HEX:
                self.state = 59
                self.value()


            self.state = 68
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ArmControlParser.SEPERATOR:
                self.state = 62
                self.seperator()
                self.state = 64
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ArmControlParser.NUMBER or _la==ArmControlParser.HEX:
                    self.state = 63
                    self.value()


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

            self.state = 71
            self.match(ArmControlParser.T__7)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameContext(ParserRuleContext):

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

        def NAME(self):
            return self.getToken(ArmControlParser.NAME, 0)

        def getRuleIndex(self):
            return ArmControlParser.RULE_name

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

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




    def name(self):

        localctx = ArmControlParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 73
            self.match(ArmControlParser.NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ValueContext(ParserRuleContext):

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

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


        def hexidecimal(self):
            return self.getTypedRuleContext(ArmControlParser.HexidecimalContext,0)


        def getRuleIndex(self):
            return ArmControlParser.RULE_value

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

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




    def value(self):

        localctx = ArmControlParser.ValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_value)
        try:
            self.state = 77
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ArmControlParser.NUMBER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 75
                self.number()
                pass
            elif token in [ArmControlParser.HEX]:
                self.enterOuterAlt(localctx, 2)
                self.state = 76
                self.hexidecimal()
                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):

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

        def NUMBER(self):
            return self.getToken(ArmControlParser.NUMBER, 0)

        def getRuleIndex(self):
            return ArmControlParser.RULE_number

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

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




    def number(self):

        localctx = ArmControlParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 79
            self.match(ArmControlParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HexidecimalContext(ParserRuleContext):

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

        def HEX(self):
            return self.getToken(ArmControlParser.HEX, 0)

        def getRuleIndex(self):
            return ArmControlParser.RULE_hexidecimal

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

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




    def hexidecimal(self):

        localctx = ArmControlParser.HexidecimalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_hexidecimal)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 81
            self.match(ArmControlParser.HEX)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SeperatorContext(ParserRuleContext):

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

        def SEPERATOR(self):
            return self.getToken(ArmControlParser.SEPERATOR, 0)

        def getRuleIndex(self):
            return ArmControlParser.RULE_seperator

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

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




    def seperator(self):

        localctx = ArmControlParser.SeperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_seperator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 83
            self.match(ArmControlParser.SEPERATOR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx