# Generated from /home/erik/PycharmProjects/pythonProject/grammar/ANF.g4 by ANTLR 4.13.1
# 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,14,66,2,0,7,0,2,1,7,1,2,2,7,2,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
        0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
        0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,3,0,39,8,0,1,1,1,1,1,1,1,1,1,1,
        5,1,46,8,1,10,1,12,1,49,9,1,1,1,1,1,1,1,3,1,54,8,1,1,2,1,2,1,2,1,
        2,1,2,1,2,1,2,1,2,3,2,64,8,2,1,2,0,0,3,0,2,4,0,0,71,0,38,1,0,0,0,
        2,53,1,0,0,0,4,63,1,0,0,0,6,39,5,12,0,0,7,39,5,13,0,0,8,9,5,1,0,
        0,9,10,3,0,0,0,10,11,5,2,0,0,11,12,3,0,0,0,12,13,5,3,0,0,13,39,1,
        0,0,0,14,15,5,1,0,0,15,16,3,0,0,0,16,17,5,4,0,0,17,18,3,0,0,0,18,
        19,5,3,0,0,19,39,1,0,0,0,20,21,5,1,0,0,21,22,3,0,0,0,22,23,5,5,0,
        0,23,24,3,0,0,0,24,25,5,3,0,0,25,39,1,0,0,0,26,27,5,1,0,0,27,28,
        3,0,0,0,28,29,5,6,0,0,29,30,3,0,0,0,30,31,5,3,0,0,31,39,1,0,0,0,
        32,33,5,1,0,0,33,34,5,12,0,0,34,35,5,7,0,0,35,36,3,4,2,0,36,37,5,
        3,0,0,37,39,1,0,0,0,38,6,1,0,0,0,38,7,1,0,0,0,38,8,1,0,0,0,38,14,
        1,0,0,0,38,20,1,0,0,0,38,26,1,0,0,0,38,32,1,0,0,0,39,1,1,0,0,0,40,
        41,5,12,0,0,41,42,5,1,0,0,42,47,3,0,0,0,43,44,5,8,0,0,44,46,3,0,
        0,0,45,43,1,0,0,0,46,49,1,0,0,0,47,45,1,0,0,0,47,48,1,0,0,0,48,50,
        1,0,0,0,49,47,1,0,0,0,50,51,5,3,0,0,51,54,1,0,0,0,52,54,3,0,0,0,
        53,40,1,0,0,0,53,52,1,0,0,0,54,3,1,0,0,0,55,56,5,9,0,0,56,57,5,12,
        0,0,57,58,5,10,0,0,58,59,3,2,1,0,59,60,5,11,0,0,60,61,3,4,2,0,61,
        64,1,0,0,0,62,64,3,2,1,0,63,55,1,0,0,0,63,62,1,0,0,0,64,5,1,0,0,
        0,4,38,47,53,63
    ]

class ANFParser ( Parser ):

    grammarFileName = "ANF.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'('", "'+'", "')'", "'-'", "'*'", "'/'", 
                     "':'", "','", "'let'", "'='", "'in'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "IDENT", "NUMBER", "WS" ]

    RULE_aexp = 0
    RULE_funcall = 1
    RULE_cexp = 2

    ruleNames =  [ "aexp", "funcall", "cexp" ]

    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
    T__8=9
    T__9=10
    T__10=11
    IDENT=12
    NUMBER=13
    WS=14

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




    class AexpContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return ANFParser.RULE_aexp

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



    class AddContext(AexpContext):

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

        def aexp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ANFParser.AexpContext)
            else:
                return self.getTypedRuleContext(ANFParser.AexpContext,i)


        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAdd" ):
                return visitor.visitAdd(self)
            else:
                return visitor.visitChildren(self)


    class DivContext(AexpContext):

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

        def aexp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ANFParser.AexpContext)
            else:
                return self.getTypedRuleContext(ANFParser.AexpContext,i)


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

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

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


    class SubContext(AexpContext):

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

        def aexp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ANFParser.AexpContext)
            else:
                return self.getTypedRuleContext(ANFParser.AexpContext,i)


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

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

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


    class MulContext(AexpContext):

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

        def aexp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ANFParser.AexpContext)
            else:
                return self.getTypedRuleContext(ANFParser.AexpContext,i)


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

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

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


    class VarContext(AexpContext):

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

        def IDENT(self):
            return self.getToken(ANFParser.IDENT, 0)

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

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

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


    class NumContext(AexpContext):

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

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

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

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

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


    class LamContext(AexpContext):

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

        def IDENT(self):
            return self.getToken(ANFParser.IDENT, 0)
        def cexp(self):
            return self.getTypedRuleContext(ANFParser.CexpContext,0)


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

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

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



    def aexp(self):

        localctx = ANFParser.AexpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_aexp)
        try:
            self.state = 38
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                localctx = ANFParser.VarContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 6
                self.match(ANFParser.IDENT)
                pass

            elif la_ == 2:
                localctx = ANFParser.NumContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 7
                self.match(ANFParser.NUMBER)
                pass

            elif la_ == 3:
                localctx = ANFParser.AddContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 8
                self.match(ANFParser.T__0)
                self.state = 9
                self.aexp()
                self.state = 10
                self.match(ANFParser.T__1)
                self.state = 11
                self.aexp()
                self.state = 12
                self.match(ANFParser.T__2)
                pass

            elif la_ == 4:
                localctx = ANFParser.SubContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 14
                self.match(ANFParser.T__0)
                self.state = 15
                self.aexp()
                self.state = 16
                self.match(ANFParser.T__3)
                self.state = 17
                self.aexp()
                self.state = 18
                self.match(ANFParser.T__2)
                pass

            elif la_ == 5:
                localctx = ANFParser.MulContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 20
                self.match(ANFParser.T__0)
                self.state = 21
                self.aexp()
                self.state = 22
                self.match(ANFParser.T__4)
                self.state = 23
                self.aexp()
                self.state = 24
                self.match(ANFParser.T__2)
                pass

            elif la_ == 6:
                localctx = ANFParser.DivContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 26
                self.match(ANFParser.T__0)
                self.state = 27
                self.aexp()
                self.state = 28
                self.match(ANFParser.T__5)
                self.state = 29
                self.aexp()
                self.state = 30
                self.match(ANFParser.T__2)
                pass

            elif la_ == 7:
                localctx = ANFParser.LamContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 32
                self.match(ANFParser.T__0)
                self.state = 33
                self.match(ANFParser.IDENT)
                self.state = 34
                self.match(ANFParser.T__6)
                self.state = 35
                self.cexp()
                self.state = 36
                self.match(ANFParser.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 FuncallContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return ANFParser.RULE_funcall

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



    class CallContext(FuncallContext):

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

        def IDENT(self):
            return self.getToken(ANFParser.IDENT, 0)
        def aexp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ANFParser.AexpContext)
            else:
                return self.getTypedRuleContext(ANFParser.AexpContext,i)


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

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

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


    class AtomContext(FuncallContext):

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

        def aexp(self):
            return self.getTypedRuleContext(ANFParser.AexpContext,0)


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

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

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



    def funcall(self):

        localctx = ANFParser.FuncallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_funcall)
        self._la = 0 # Token type
        try:
            self.state = 53
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                localctx = ANFParser.CallContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 40
                self.match(ANFParser.IDENT)
                self.state = 41
                self.match(ANFParser.T__0)
                self.state = 42
                self.aexp()
                self.state = 47
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==8:
                    self.state = 43
                    self.match(ANFParser.T__7)
                    self.state = 44
                    self.aexp()
                    self.state = 49
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 50
                self.match(ANFParser.T__2)
                pass

            elif la_ == 2:
                localctx = ANFParser.AtomContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 52
                self.aexp()
                pass


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


    class CexpContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return ANFParser.RULE_cexp

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



    class LetContext(CexpContext):

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

        def IDENT(self):
            return self.getToken(ANFParser.IDENT, 0)
        def funcall(self):
            return self.getTypedRuleContext(ANFParser.FuncallContext,0)

        def cexp(self):
            return self.getTypedRuleContext(ANFParser.CexpContext,0)


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

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

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


    class FcContext(CexpContext):

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

        def funcall(self):
            return self.getTypedRuleContext(ANFParser.FuncallContext,0)


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

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

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



    def cexp(self):

        localctx = ANFParser.CexpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_cexp)
        try:
            self.state = 63
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9]:
                localctx = ANFParser.LetContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 55
                self.match(ANFParser.T__8)
                self.state = 56
                self.match(ANFParser.IDENT)
                self.state = 57
                self.match(ANFParser.T__9)
                self.state = 58
                self.funcall()
                self.state = 59
                self.match(ANFParser.T__10)
                self.state = 60
                self.cexp()
                pass
            elif token in [1, 12, 13]:
                localctx = ANFParser.FcContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 62
                self.funcall()
                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