# Generated from syntax.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\23")
        buf.write("\u00e9\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\3\2\6\2 \n\2\r\2\16\2!\3\2\3\2\3\3\3\3")
        buf.write("\3\3\3\3\5\3*\n\3\3\4\6\4-\n\4\r\4\16\4.\3\5\3\5\3\5\3")
        buf.write("\5\3\5\3\5\3\5\3\5\3\5\5\5:\n\5\3\6\3\6\5\6>\n\6\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\5\7x\n\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
        buf.write("\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b")
        buf.write("\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
        buf.write("\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b")
        buf.write("\3\b\3\b\3\b\3\b\3\b\5\b\u00b2\n\b\3\t\3\t\3\t\3\t\3\t")
        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00d0\n\t\3")
        buf.write("\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\r")
        buf.write("\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\2")
        buf.write("\2\20\2\4\6\b\n\f\16\20\22\24\26\30\32\34\2\3\3\2\20\21")
        buf.write("\2\u00f7\2\37\3\2\2\2\4)\3\2\2\2\6,\3\2\2\2\b9\3\2\2\2")
        buf.write("\n;\3\2\2\2\fw\3\2\2\2\16\u00b1\3\2\2\2\20\u00cf\3\2\2")
        buf.write("\2\22\u00d1\3\2\2\2\24\u00d5\3\2\2\2\26\u00d9\3\2\2\2")
        buf.write("\30\u00dd\3\2\2\2\32\u00e1\3\2\2\2\34\u00e5\3\2\2\2\36")
        buf.write(" \5\4\3\2\37\36\3\2\2\2 !\3\2\2\2!\37\3\2\2\2!\"\3\2\2")
        buf.write("\2\"#\3\2\2\2#$\7\2\2\3$\3\3\2\2\2%*\5\6\4\2&\'\5\n\6")
        buf.write("\2\'(\5\6\4\2(*\3\2\2\2)%\3\2\2\2)&\3\2\2\2*\5\3\2\2\2")
        buf.write("+-\5\b\5\2,+\3\2\2\2-.\3\2\2\2.,\3\2\2\2./\3\2\2\2/\7")
        buf.write("\3\2\2\2\60:\5\f\7\2\61:\5\20\t\2\62:\5\16\b\2\63:\5\22")
        buf.write("\n\2\64:\5\24\13\2\65:\5\26\f\2\66:\5\30\r\2\67:\5\32")
        buf.write("\16\28:\5\34\17\29\60\3\2\2\29\61\3\2\2\29\62\3\2\2\2")
        buf.write("9\63\3\2\2\29\64\3\2\2\29\65\3\2\2\29\66\3\2\2\29\67\3")
        buf.write("\2\2\298\3\2\2\2:\t\3\2\2\2;=\7\20\2\2<>\7\3\2\2=<\3\2")
        buf.write("\2\2=>\3\2\2\2>\13\3\2\2\2?@\7\7\2\2@A\7\20\2\2AB\7\4")
        buf.write("\2\2BC\7\20\2\2Cx\7\23\2\2DE\7\7\2\2EF\7\20\2\2FG\7\4")
        buf.write("\2\2GH\7\21\2\2Hx\7\23\2\2IJ\7\7\2\2JK\7\20\2\2KL\7\4")
        buf.write("\2\2LM\7\5\2\2MN\7\20\2\2NO\7\6\2\2Ox\7\23\2\2PQ\7\7\2")
        buf.write("\2QR\7\20\2\2RS\7\4\2\2ST\7\5\2\2TU\7\21\2\2UV\7\6\2\2")
        buf.write("Vx\7\23\2\2WX\7\7\2\2XY\7\5\2\2YZ\7\20\2\2Z[\7\6\2\2[")
        buf.write("\\\7\4\2\2\\]\7\20\2\2]x\7\23\2\2^_\7\7\2\2_`\7\5\2\2")
        buf.write("`a\7\20\2\2ab\7\6\2\2bc\7\4\2\2cd\7\21\2\2dx\7\23\2\2")
        buf.write("ef\7\7\2\2fg\7\5\2\2gh\7\20\2\2hi\7\6\2\2ij\7\4\2\2jk")
        buf.write("\7\5\2\2kl\7\20\2\2lm\7\6\2\2mx\7\23\2\2no\7\7\2\2op\7")
        buf.write("\5\2\2pq\7\20\2\2qr\7\6\2\2rs\7\4\2\2st\7\5\2\2tu\7\21")
        buf.write("\2\2uv\7\6\2\2vx\7\23\2\2w?\3\2\2\2wD\3\2\2\2wI\3\2\2")
        buf.write("\2wP\3\2\2\2wW\3\2\2\2w^\3\2\2\2we\3\2\2\2wn\3\2\2\2x")
        buf.write("\r\3\2\2\2yz\7\b\2\2z{\7\20\2\2{|\7\4\2\2|}\7\20\2\2}")
        buf.write("\u00b2\7\23\2\2~\177\7\b\2\2\177\u0080\7\20\2\2\u0080")
        buf.write("\u0081\7\4\2\2\u0081\u0082\7\21\2\2\u0082\u00b2\7\23\2")
        buf.write("\2\u0083\u0084\7\b\2\2\u0084\u0085\7\20\2\2\u0085\u0086")
        buf.write("\7\4\2\2\u0086\u0087\7\5\2\2\u0087\u0088\7\20\2\2\u0088")
        buf.write("\u0089\7\6\2\2\u0089\u00b2\7\23\2\2\u008a\u008b\7\b\2")
        buf.write("\2\u008b\u008c\7\20\2\2\u008c\u008d\7\4\2\2\u008d\u008e")
        buf.write("\7\5\2\2\u008e\u008f\7\21\2\2\u008f\u0090\7\6\2\2\u0090")
        buf.write("\u00b2\7\23\2\2\u0091\u0092\7\b\2\2\u0092\u0093\7\5\2")
        buf.write("\2\u0093\u0094\7\20\2\2\u0094\u0095\7\6\2\2\u0095\u0096")
        buf.write("\7\4\2\2\u0096\u0097\7\20\2\2\u0097\u00b2\7\23\2\2\u0098")
        buf.write("\u0099\7\b\2\2\u0099\u009a\7\5\2\2\u009a\u009b\7\20\2")
        buf.write("\2\u009b\u009c\7\6\2\2\u009c\u009d\7\4\2\2\u009d\u009e")
        buf.write("\7\21\2\2\u009e\u00b2\7\23\2\2\u009f\u00a0\7\b\2\2\u00a0")
        buf.write("\u00a1\7\5\2\2\u00a1\u00a2\7\20\2\2\u00a2\u00a3\7\6\2")
        buf.write("\2\u00a3\u00a4\7\4\2\2\u00a4\u00a5\7\5\2\2\u00a5\u00a6")
        buf.write("\7\20\2\2\u00a6\u00a7\7\6\2\2\u00a7\u00b2\7\23\2\2\u00a8")
        buf.write("\u00a9\7\b\2\2\u00a9\u00aa\7\5\2\2\u00aa\u00ab\7\20\2")
        buf.write("\2\u00ab\u00ac\7\6\2\2\u00ac\u00ad\7\4\2\2\u00ad\u00ae")
        buf.write("\7\5\2\2\u00ae\u00af\7\21\2\2\u00af\u00b0\7\6\2\2\u00b0")
        buf.write("\u00b2\7\23\2\2\u00b1y\3\2\2\2\u00b1~\3\2\2\2\u00b1\u0083")
        buf.write("\3\2\2\2\u00b1\u008a\3\2\2\2\u00b1\u0091\3\2\2\2\u00b1")
        buf.write("\u0098\3\2\2\2\u00b1\u009f\3\2\2\2\u00b1\u00a8\3\2\2\2")
        buf.write("\u00b2\17\3\2\2\2\u00b3\u00b4\7\t\2\2\u00b4\u00b5\t\2")
        buf.write("\2\2\u00b5\u00b6\7\4\2\2\u00b6\u00b7\t\2\2\2\u00b7\u00d0")
        buf.write("\7\23\2\2\u00b8\u00b9\7\t\2\2\u00b9\u00ba\7\5\2\2\u00ba")
        buf.write("\u00bb\t\2\2\2\u00bb\u00bc\7\6\2\2\u00bc\u00bd\7\4\2\2")
        buf.write("\u00bd\u00be\t\2\2\2\u00be\u00d0\7\23\2\2\u00bf\u00c0")
        buf.write("\7\t\2\2\u00c0\u00c1\t\2\2\2\u00c1\u00c2\7\4\2\2\u00c2")
        buf.write("\u00c3\7\5\2\2\u00c3\u00c4\t\2\2\2\u00c4\u00c5\7\6\2\2")
        buf.write("\u00c5\u00d0\7\23\2\2\u00c6\u00c7\7\t\2\2\u00c7\u00c8")
        buf.write("\7\5\2\2\u00c8\u00c9\t\2\2\2\u00c9\u00ca\7\6\2\2\u00ca")
        buf.write("\u00cb\7\4\2\2\u00cb\u00cc\7\5\2\2\u00cc\u00cd\t\2\2\2")
        buf.write("\u00cd\u00ce\7\6\2\2\u00ce\u00d0\7\23\2\2\u00cf\u00b3")
        buf.write("\3\2\2\2\u00cf\u00b8\3\2\2\2\u00cf\u00bf\3\2\2\2\u00cf")
        buf.write("\u00c6\3\2\2\2\u00d0\21\3\2\2\2\u00d1\u00d2\7\n\2\2\u00d2")
        buf.write("\u00d3\7\20\2\2\u00d3\u00d4\7\23\2\2\u00d4\23\3\2\2\2")
        buf.write("\u00d5\u00d6\7\13\2\2\u00d6\u00d7\5\n\6\2\u00d7\u00d8")
        buf.write("\7\23\2\2\u00d8\25\3\2\2\2\u00d9\u00da\7\f\2\2\u00da\u00db")
        buf.write("\5\n\6\2\u00db\u00dc\7\23\2\2\u00dc\27\3\2\2\2\u00dd\u00de")
        buf.write("\7\r\2\2\u00de\u00df\5\n\6\2\u00df\u00e0\7\23\2\2\u00e0")
        buf.write("\31\3\2\2\2\u00e1\u00e2\7\16\2\2\u00e2\u00e3\t\2\2\2\u00e3")
        buf.write("\u00e4\7\23\2\2\u00e4\33\3\2\2\2\u00e5\u00e6\7\17\2\2")
        buf.write("\u00e6\u00e7\7\23\2\2\u00e7\35\3\2\2\2\n!).9=w\u00b1\u00cf")
        return buf.getvalue()


class syntaxParser ( Parser ):

    grammarFileName = "syntax.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "':'", "','", "'['", "']'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "';'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "MOV", "ADD", "CMP", "DEC", "JE", "JMP", 
                      "JG", "PRT", "RET", "ID", "INT", "WS", "COL" ]

    RULE_prog = 0
    RULE_stat = 1
    RULE_block = 2
    RULE_line = 3
    RULE_lab = 4
    RULE_mov = 5
    RULE_add = 6
    RULE_cmp = 7
    RULE_dec = 8
    RULE_je = 9
    RULE_jmp = 10
    RULE_jg = 11
    RULE_prt = 12
    RULE_ret = 13

    ruleNames =  [ "prog", "stat", "block", "line", "lab", "mov", "add", 
                   "cmp", "dec", "je", "jmp", "jg", "prt", "ret" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    MOV=5
    ADD=6
    CMP=7
    DEC=8
    JE=9
    JMP=10
    JG=11
    PRT=12
    RET=13
    ID=14
    INT=15
    WS=16
    COL=17

    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(syntaxParser.EOF, 0)

        def stat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(syntaxParser.StatContext)
            else:
                return self.getTypedRuleContext(syntaxParser.StatContext,i)


        def getRuleIndex(self):
            return syntaxParser.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 = syntaxParser.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 = 29 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 28
                self.stat()
                self.state = 31 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << syntaxParser.MOV) | (1 << syntaxParser.ADD) | (1 << syntaxParser.CMP) | (1 << syntaxParser.DEC) | (1 << syntaxParser.JE) | (1 << syntaxParser.JMP) | (1 << syntaxParser.JG) | (1 << syntaxParser.PRT) | (1 << syntaxParser.RET) | (1 << syntaxParser.ID))) != 0)):
                    break

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


    class StatContext(ParserRuleContext):

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

        def block(self):
            return self.getTypedRuleContext(syntaxParser.BlockContext,0)


        def lab(self):
            return self.getTypedRuleContext(syntaxParser.LabContext,0)


        def getRuleIndex(self):
            return syntaxParser.RULE_stat

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

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




    def stat(self):

        localctx = syntaxParser.StatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_stat)
        try:
            self.state = 39
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [syntaxParser.MOV, syntaxParser.ADD, syntaxParser.CMP, syntaxParser.DEC, syntaxParser.JE, syntaxParser.JMP, syntaxParser.JG, syntaxParser.PRT, syntaxParser.RET]:
                self.enterOuterAlt(localctx, 1)
                self.state = 35
                self.block()
                pass
            elif token in [syntaxParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 36
                self.lab()
                self.state = 37
                self.block()
                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 BlockContext(ParserRuleContext):

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

        def line(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(syntaxParser.LineContext)
            else:
                return self.getTypedRuleContext(syntaxParser.LineContext,i)


        def getRuleIndex(self):
            return syntaxParser.RULE_block

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

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




    def block(self):

        localctx = syntaxParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_block)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 42 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 41
                    self.line()

                else:
                    raise NoViableAltException(self)
                self.state = 44 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)

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


    class LineContext(ParserRuleContext):

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

        def mov(self):
            return self.getTypedRuleContext(syntaxParser.MovContext,0)


        def cmp(self):
            return self.getTypedRuleContext(syntaxParser.CmpContext,0)


        def add(self):
            return self.getTypedRuleContext(syntaxParser.AddContext,0)


        def dec(self):
            return self.getTypedRuleContext(syntaxParser.DecContext,0)


        def je(self):
            return self.getTypedRuleContext(syntaxParser.JeContext,0)


        def jmp(self):
            return self.getTypedRuleContext(syntaxParser.JmpContext,0)


        def jg(self):
            return self.getTypedRuleContext(syntaxParser.JgContext,0)


        def prt(self):
            return self.getTypedRuleContext(syntaxParser.PrtContext,0)


        def ret(self):
            return self.getTypedRuleContext(syntaxParser.RetContext,0)


        def getRuleIndex(self):
            return syntaxParser.RULE_line

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

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




    def line(self):

        localctx = syntaxParser.LineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_line)
        try:
            self.state = 55
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [syntaxParser.MOV]:
                self.enterOuterAlt(localctx, 1)
                self.state = 46
                self.mov()
                pass
            elif token in [syntaxParser.CMP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 47
                self.cmp()
                pass
            elif token in [syntaxParser.ADD]:
                self.enterOuterAlt(localctx, 3)
                self.state = 48
                self.add()
                pass
            elif token in [syntaxParser.DEC]:
                self.enterOuterAlt(localctx, 4)
                self.state = 49
                self.dec()
                pass
            elif token in [syntaxParser.JE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 50
                self.je()
                pass
            elif token in [syntaxParser.JMP]:
                self.enterOuterAlt(localctx, 6)
                self.state = 51
                self.jmp()
                pass
            elif token in [syntaxParser.JG]:
                self.enterOuterAlt(localctx, 7)
                self.state = 52
                self.jg()
                pass
            elif token in [syntaxParser.PRT]:
                self.enterOuterAlt(localctx, 8)
                self.state = 53
                self.prt()
                pass
            elif token in [syntaxParser.RET]:
                self.enterOuterAlt(localctx, 9)
                self.state = 54
                self.ret()
                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 LabContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return syntaxParser.RULE_lab

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

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




    def lab(self):

        localctx = syntaxParser.LabContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_lab)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 57
            localctx.labelName = self.match(syntaxParser.ID)
            self.state = 59
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==syntaxParser.T__0:
                self.state = 58
                self.match(syntaxParser.T__0)


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


    class MovContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.toId = None # Token
            self.fromId = None # Token
            self.fromInt = None # Token
            self.fromIdAddress = None # Token
            self.fromIntAddress = None # Token
            self.toIdAddress = None # Token

        def MOV(self):
            return self.getToken(syntaxParser.MOV, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

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

        def INT(self):
            return self.getToken(syntaxParser.INT, 0)

        def getRuleIndex(self):
            return syntaxParser.RULE_mov

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

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




    def mov(self):

        localctx = syntaxParser.MovContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_mov)
        try:
            self.state = 117
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 61
                self.match(syntaxParser.MOV)
                self.state = 62
                localctx.toId = self.match(syntaxParser.ID)
                self.state = 63
                self.match(syntaxParser.T__1)
                self.state = 64
                localctx.fromId = self.match(syntaxParser.ID)
                self.state = 65
                self.match(syntaxParser.COL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 66
                self.match(syntaxParser.MOV)
                self.state = 67
                localctx.toId = self.match(syntaxParser.ID)
                self.state = 68
                self.match(syntaxParser.T__1)
                self.state = 69
                localctx.fromInt = self.match(syntaxParser.INT)
                self.state = 70
                self.match(syntaxParser.COL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 71
                self.match(syntaxParser.MOV)
                self.state = 72
                localctx.toId = self.match(syntaxParser.ID)
                self.state = 73
                self.match(syntaxParser.T__1)
                self.state = 74
                self.match(syntaxParser.T__2)
                self.state = 75
                localctx.fromIdAddress = self.match(syntaxParser.ID)
                self.state = 76
                self.match(syntaxParser.T__3)
                self.state = 77
                self.match(syntaxParser.COL)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 78
                self.match(syntaxParser.MOV)
                self.state = 79
                localctx.toId = self.match(syntaxParser.ID)
                self.state = 80
                self.match(syntaxParser.T__1)
                self.state = 81
                self.match(syntaxParser.T__2)
                self.state = 82
                localctx.fromIntAddress = self.match(syntaxParser.INT)
                self.state = 83
                self.match(syntaxParser.T__3)
                self.state = 84
                self.match(syntaxParser.COL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 85
                self.match(syntaxParser.MOV)
                self.state = 86
                self.match(syntaxParser.T__2)
                self.state = 87
                localctx.toIdAddress = self.match(syntaxParser.ID)
                self.state = 88
                self.match(syntaxParser.T__3)
                self.state = 89
                self.match(syntaxParser.T__1)
                self.state = 90
                localctx.fromId = self.match(syntaxParser.ID)
                self.state = 91
                self.match(syntaxParser.COL)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 92
                self.match(syntaxParser.MOV)
                self.state = 93
                self.match(syntaxParser.T__2)
                self.state = 94
                localctx.toIdAddress = self.match(syntaxParser.ID)
                self.state = 95
                self.match(syntaxParser.T__3)
                self.state = 96
                self.match(syntaxParser.T__1)
                self.state = 97
                localctx.fromInt = self.match(syntaxParser.INT)
                self.state = 98
                self.match(syntaxParser.COL)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 99
                self.match(syntaxParser.MOV)
                self.state = 100
                self.match(syntaxParser.T__2)
                self.state = 101
                localctx.toIdAddress = self.match(syntaxParser.ID)
                self.state = 102
                self.match(syntaxParser.T__3)
                self.state = 103
                self.match(syntaxParser.T__1)
                self.state = 104
                self.match(syntaxParser.T__2)
                self.state = 105
                localctx.fromIdAddress = self.match(syntaxParser.ID)
                self.state = 106
                self.match(syntaxParser.T__3)
                self.state = 107
                self.match(syntaxParser.COL)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 108
                self.match(syntaxParser.MOV)
                self.state = 109
                self.match(syntaxParser.T__2)
                self.state = 110
                localctx.toIdAddress = self.match(syntaxParser.ID)
                self.state = 111
                self.match(syntaxParser.T__3)
                self.state = 112
                self.match(syntaxParser.T__1)
                self.state = 113
                self.match(syntaxParser.T__2)
                self.state = 114
                localctx.fromIntAddress = self.match(syntaxParser.INT)
                self.state = 115
                self.match(syntaxParser.T__3)
                self.state = 116
                self.match(syntaxParser.COL)
                pass


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


    class AddContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.toId = None # Token
            self.fromId = None # Token
            self.fromInt = None # Token
            self.fromIdAddress = None # Token
            self.fromIntAddress = None # Token
            self.toIdAddress = None # Token

        def ADD(self):
            return self.getToken(syntaxParser.ADD, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

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

        def INT(self):
            return self.getToken(syntaxParser.INT, 0)

        def getRuleIndex(self):
            return syntaxParser.RULE_add

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

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




    def add(self):

        localctx = syntaxParser.AddContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_add)
        try:
            self.state = 175
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 119
                self.match(syntaxParser.ADD)
                self.state = 120
                localctx.toId = self.match(syntaxParser.ID)
                self.state = 121
                self.match(syntaxParser.T__1)
                self.state = 122
                localctx.fromId = self.match(syntaxParser.ID)
                self.state = 123
                self.match(syntaxParser.COL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 124
                self.match(syntaxParser.ADD)
                self.state = 125
                localctx.toId = self.match(syntaxParser.ID)
                self.state = 126
                self.match(syntaxParser.T__1)
                self.state = 127
                localctx.fromInt = self.match(syntaxParser.INT)
                self.state = 128
                self.match(syntaxParser.COL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 129
                self.match(syntaxParser.ADD)
                self.state = 130
                localctx.toId = self.match(syntaxParser.ID)
                self.state = 131
                self.match(syntaxParser.T__1)
                self.state = 132
                self.match(syntaxParser.T__2)
                self.state = 133
                localctx.fromIdAddress = self.match(syntaxParser.ID)
                self.state = 134
                self.match(syntaxParser.T__3)
                self.state = 135
                self.match(syntaxParser.COL)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 136
                self.match(syntaxParser.ADD)
                self.state = 137
                localctx.toId = self.match(syntaxParser.ID)
                self.state = 138
                self.match(syntaxParser.T__1)
                self.state = 139
                self.match(syntaxParser.T__2)
                self.state = 140
                localctx.fromIntAddress = self.match(syntaxParser.INT)
                self.state = 141
                self.match(syntaxParser.T__3)
                self.state = 142
                self.match(syntaxParser.COL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 143
                self.match(syntaxParser.ADD)
                self.state = 144
                self.match(syntaxParser.T__2)
                self.state = 145
                localctx.toIdAddress = self.match(syntaxParser.ID)
                self.state = 146
                self.match(syntaxParser.T__3)
                self.state = 147
                self.match(syntaxParser.T__1)
                self.state = 148
                localctx.fromId = self.match(syntaxParser.ID)
                self.state = 149
                self.match(syntaxParser.COL)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 150
                self.match(syntaxParser.ADD)
                self.state = 151
                self.match(syntaxParser.T__2)
                self.state = 152
                localctx.toIdAddress = self.match(syntaxParser.ID)
                self.state = 153
                self.match(syntaxParser.T__3)
                self.state = 154
                self.match(syntaxParser.T__1)
                self.state = 155
                localctx.fromInt = self.match(syntaxParser.INT)
                self.state = 156
                self.match(syntaxParser.COL)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 157
                self.match(syntaxParser.ADD)
                self.state = 158
                self.match(syntaxParser.T__2)
                self.state = 159
                localctx.toIdAddress = self.match(syntaxParser.ID)
                self.state = 160
                self.match(syntaxParser.T__3)
                self.state = 161
                self.match(syntaxParser.T__1)
                self.state = 162
                self.match(syntaxParser.T__2)
                self.state = 163
                localctx.fromIdAddress = self.match(syntaxParser.ID)
                self.state = 164
                self.match(syntaxParser.T__3)
                self.state = 165
                self.match(syntaxParser.COL)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 166
                self.match(syntaxParser.ADD)
                self.state = 167
                self.match(syntaxParser.T__2)
                self.state = 168
                localctx.toIdAddress = self.match(syntaxParser.ID)
                self.state = 169
                self.match(syntaxParser.T__3)
                self.state = 170
                self.match(syntaxParser.T__1)
                self.state = 171
                self.match(syntaxParser.T__2)
                self.state = 172
                localctx.fromIntAddress = self.match(syntaxParser.INT)
                self.state = 173
                self.match(syntaxParser.T__3)
                self.state = 174
                self.match(syntaxParser.COL)
                pass


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


    class CmpContext(ParserRuleContext):

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

        def CMP(self):
            return self.getToken(syntaxParser.CMP, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

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

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

        def getRuleIndex(self):
            return syntaxParser.RULE_cmp

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

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




    def cmp(self):

        localctx = syntaxParser.CmpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_cmp)
        self._la = 0 # Token type
        try:
            self.state = 205
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 177
                self.match(syntaxParser.CMP)
                self.state = 178
                localctx.a = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                    localctx.a = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 179
                self.match(syntaxParser.T__1)
                self.state = 180
                localctx.b = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                    localctx.b = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 181
                self.match(syntaxParser.COL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 182
                self.match(syntaxParser.CMP)
                self.state = 183
                self.match(syntaxParser.T__2)
                self.state = 184
                localctx.addressA = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                    localctx.addressA = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 185
                self.match(syntaxParser.T__3)
                self.state = 186
                self.match(syntaxParser.T__1)
                self.state = 187
                localctx.b = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                    localctx.b = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 188
                self.match(syntaxParser.COL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 189
                self.match(syntaxParser.CMP)
                self.state = 190
                localctx.a = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                    localctx.a = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 191
                self.match(syntaxParser.T__1)
                self.state = 192
                self.match(syntaxParser.T__2)
                self.state = 193
                localctx.addressB = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                    localctx.addressB = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 194
                self.match(syntaxParser.T__3)
                self.state = 195
                self.match(syntaxParser.COL)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 196
                self.match(syntaxParser.CMP)
                self.state = 197
                self.match(syntaxParser.T__2)
                self.state = 198
                localctx.addressA = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                    localctx.addressA = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 199
                self.match(syntaxParser.T__3)
                self.state = 200
                self.match(syntaxParser.T__1)
                self.state = 201
                self.match(syntaxParser.T__2)
                self.state = 202
                localctx.addressB = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                    localctx.addressB = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 203
                self.match(syntaxParser.T__3)
                self.state = 204
                self.match(syntaxParser.COL)
                pass


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


    class DecContext(ParserRuleContext):

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

        def DEC(self):
            return self.getToken(syntaxParser.DEC, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

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

        def getRuleIndex(self):
            return syntaxParser.RULE_dec

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

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




    def dec(self):

        localctx = syntaxParser.DecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_dec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 207
            self.match(syntaxParser.DEC)
            self.state = 208
            localctx.var = self.match(syntaxParser.ID)
            self.state = 209
            self.match(syntaxParser.COL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JeContext(ParserRuleContext):

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

        def JE(self):
            return self.getToken(syntaxParser.JE, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

        def lab(self):
            return self.getTypedRuleContext(syntaxParser.LabContext,0)


        def getRuleIndex(self):
            return syntaxParser.RULE_je

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

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




    def je(self):

        localctx = syntaxParser.JeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_je)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self.match(syntaxParser.JE)
            self.state = 212
            localctx.labelName = self.lab()
            self.state = 213
            self.match(syntaxParser.COL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JmpContext(ParserRuleContext):

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

        def JMP(self):
            return self.getToken(syntaxParser.JMP, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

        def lab(self):
            return self.getTypedRuleContext(syntaxParser.LabContext,0)


        def getRuleIndex(self):
            return syntaxParser.RULE_jmp

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

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




    def jmp(self):

        localctx = syntaxParser.JmpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_jmp)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 215
            self.match(syntaxParser.JMP)
            self.state = 216
            localctx.labelName = self.lab()
            self.state = 217
            self.match(syntaxParser.COL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JgContext(ParserRuleContext):

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

        def JG(self):
            return self.getToken(syntaxParser.JG, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

        def lab(self):
            return self.getTypedRuleContext(syntaxParser.LabContext,0)


        def getRuleIndex(self):
            return syntaxParser.RULE_jg

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

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




    def jg(self):

        localctx = syntaxParser.JgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_jg)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 219
            self.match(syntaxParser.JG)
            self.state = 220
            localctx.labelName = self.lab()
            self.state = 221
            self.match(syntaxParser.COL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrtContext(ParserRuleContext):

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

        def PRT(self):
            return self.getToken(syntaxParser.PRT, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

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

        def INT(self):
            return self.getToken(syntaxParser.INT, 0)

        def getRuleIndex(self):
            return syntaxParser.RULE_prt

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

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




    def prt(self):

        localctx = syntaxParser.PrtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_prt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 223
            self.match(syntaxParser.PRT)
            self.state = 224
            localctx.a = self._input.LT(1)
            _la = self._input.LA(1)
            if not(_la==syntaxParser.ID or _la==syntaxParser.INT):
                localctx.a = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 225
            self.match(syntaxParser.COL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RetContext(ParserRuleContext):

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

        def RET(self):
            return self.getToken(syntaxParser.RET, 0)

        def COL(self):
            return self.getToken(syntaxParser.COL, 0)

        def getRuleIndex(self):
            return syntaxParser.RULE_ret

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

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




    def ret(self):

        localctx = syntaxParser.RetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_ret)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 227
            self.match(syntaxParser.RET)
            self.state = 228
            self.match(syntaxParser.COL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





