# Generated from comparator.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\32")
        buf.write("\u00c4\4\2\t\2\3\2\5\2\6\n\2\3\2\5\2\t\n\2\3\2\5\2\f\n")
        buf.write("\2\3\2\5\2\17\n\2\3\2\3\2\5\2\23\n\2\3\2\3\2\5\2\27\n")
        buf.write("\2\3\2\5\2\32\n\2\3\2\3\2\5\2\36\n\2\7\2 \n\2\f\2\16\2")
        buf.write("#\13\2\3\2\5\2&\n\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\5\2/\n")
        buf.write("\2\3\2\5\2\62\n\2\3\2\5\2\65\n\2\3\2\3\2\5\29\n\2\3\2")
        buf.write("\3\2\5\2=\n\2\3\2\5\2@\n\2\3\2\3\2\5\2D\n\2\7\2F\n\2\f")
        buf.write("\2\16\2I\13\2\3\2\3\2\5\2M\n\2\3\2\5\2P\n\2\3\2\3\2\3")
        buf.write("\2\7\2U\n\2\f\2\16\2X\13\2\3\2\5\2[\n\2\5\2]\n\2\3\2\3")
        buf.write("\2\3\2\3\2\5\2c\n\2\3\2\3\2\3\2\3\2\5\2i\n\2\3\2\3\2\3")
        buf.write("\2\3\2\3\2\3\2\3\2\7\2r\n\2\f\2\16\2u\13\2\3\2\5\2x\n")
        buf.write("\2\3\2\3\2\3\2\3\2\3\2\7\2\177\n\2\f\2\16\2\u0082\13\2")
        buf.write("\3\2\3\2\3\2\3\2\3\2\5\2\u0089\n\2\3\2\3\2\3\2\3\2\3\2")
        buf.write("\7\2\u0090\n\2\f\2\16\2\u0093\13\2\3\2\3\2\3\2\5\2\u0098")
        buf.write("\n\2\3\2\3\2\3\2\3\2\3\2\7\2\u009f\n\2\f\2\16\2\u00a2")
        buf.write("\13\2\3\2\3\2\3\2\5\2\u00a7\n\2\3\2\3\2\3\2\3\2\3\2\7")
        buf.write("\2\u00ae\n\2\f\2\16\2\u00b1\13\2\3\2\3\2\3\2\3\2\3\2\3")
        buf.write("\2\3\2\7\2\u00ba\n\2\f\2\16\2\u00bd\13\2\3\2\5\2\u00c0")
        buf.write("\n\2\5\2\u00c2\n\2\3\2\2\2\3\2\2\2\2\u00f7\2\u00c1\3\2")
        buf.write("\2\2\4\6\7\5\2\2\5\4\3\2\2\2\5\6\3\2\2\2\6\b\3\2\2\2\7")
        buf.write("\t\7\3\2\2\b\7\3\2\2\2\b\t\3\2\2\2\t\13\3\2\2\2\n\f\7")
        buf.write("\5\2\2\13\n\3\2\2\2\13\f\3\2\2\2\f\16\3\2\2\2\r\17\7\3")
        buf.write("\2\2\16\r\3\2\2\2\16\17\3\2\2\2\17\20\3\2\2\2\20\22\7")
        buf.write("\t\2\2\21\23\7\4\2\2\22\21\3\2\2\2\22\23\3\2\2\2\23!\3")
        buf.write("\2\2\2\24\26\7\7\2\2\25\27\7\5\2\2\26\25\3\2\2\2\26\27")
        buf.write("\3\2\2\2\27\31\3\2\2\2\30\32\7\3\2\2\31\30\3\2\2\2\31")
        buf.write("\32\3\2\2\2\32\33\3\2\2\2\33\35\7\t\2\2\34\36\7\4\2\2")
        buf.write("\35\34\3\2\2\2\35\36\3\2\2\2\36 \3\2\2\2\37\24\3\2\2\2")
        buf.write(" #\3\2\2\2!\37\3\2\2\2!\"\3\2\2\2\"%\3\2\2\2#!\3\2\2\2")
        buf.write("$&\7\4\2\2%$\3\2\2\2%&\3\2\2\2&.\3\2\2\2\'(\7\b\2\2(/")
        buf.write("\7\21\2\2)/\7\22\2\2*/\7\6\2\2+/\7\r\2\2,/\7\16\2\2-/")
        buf.write("\7\17\2\2.\'\3\2\2\2.)\3\2\2\2.*\3\2\2\2.+\3\2\2\2.,\3")
        buf.write("\2\2\2.-\3\2\2\2./\3\2\2\2/\u00c2\3\2\2\2\60\62\7\5\2")
        buf.write("\2\61\60\3\2\2\2\61\62\3\2\2\2\62\64\3\2\2\2\63\65\7\3")
        buf.write("\2\2\64\63\3\2\2\2\64\65\3\2\2\2\65\66\3\2\2\2\668\7\t")
        buf.write("\2\2\679\7\4\2\28\67\3\2\2\289\3\2\2\29G\3\2\2\2:<\7\7")
        buf.write("\2\2;=\7\5\2\2<;\3\2\2\2<=\3\2\2\2=?\3\2\2\2>@\7\3\2\2")
        buf.write("?>\3\2\2\2?@\3\2\2\2@A\3\2\2\2AC\7\t\2\2BD\7\4\2\2CB\3")
        buf.write("\2\2\2CD\3\2\2\2DF\3\2\2\2E:\3\2\2\2FI\3\2\2\2GE\3\2\2")
        buf.write("\2GH\3\2\2\2H\\\3\2\2\2IG\3\2\2\2JL\7\b\2\2KM\7\5\2\2")
        buf.write("LK\3\2\2\2LM\3\2\2\2MO\3\2\2\2NP\7\3\2\2ON\3\2\2\2OP\3")
        buf.write("\2\2\2PQ\3\2\2\2QV\7\t\2\2RS\7\7\2\2SU\7\t\2\2TR\3\2\2")
        buf.write("\2UX\3\2\2\2VT\3\2\2\2VW\3\2\2\2WZ\3\2\2\2XV\3\2\2\2Y")
        buf.write("[\7\4\2\2ZY\3\2\2\2Z[\3\2\2\2[]\3\2\2\2\\J\3\2\2\2\\]")
        buf.write("\3\2\2\2]\u00c2\3\2\2\2^b\7\t\2\2_`\7\b\2\2`c\7\21\2\2")
        buf.write("ac\7\22\2\2b_\3\2\2\2ba\3\2\2\2bc\3\2\2\2c\u00c2\3\2\2")
        buf.write("\2dh\7\t\2\2ef\7\b\2\2fi\7\23\2\2gi\7\r\2\2he\3\2\2\2")
        buf.write("hg\3\2\2\2hi\3\2\2\2i\u00c2\3\2\2\2jw\7\t\2\2kl\7\b\2")
        buf.write("\2lm\7\5\2\2mn\7\3\2\2ns\7\t\2\2op\7\7\2\2pr\7\t\2\2q")
        buf.write("o\3\2\2\2ru\3\2\2\2sq\3\2\2\2st\3\2\2\2tv\3\2\2\2us\3")
        buf.write("\2\2\2vx\7\4\2\2wk\3\2\2\2wx\3\2\2\2x\u00c2\3\2\2\2yz")
        buf.write("\7\5\2\2z{\7\3\2\2{\u0080\7\t\2\2|}\7\7\2\2}\177\7\t\2")
        buf.write("\2~|\3\2\2\2\177\u0082\3\2\2\2\u0080~\3\2\2\2\u0080\u0081")
        buf.write("\3\2\2\2\u0081\u0083\3\2\2\2\u0082\u0080\3\2\2\2\u0083")
        buf.write("\u0088\7\4\2\2\u0084\u0085\7\b\2\2\u0085\u0089\7\21\2")
        buf.write("\2\u0086\u0089\7\22\2\2\u0087\u0089\7\6\2\2\u0088\u0084")
        buf.write("\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0087\3\2\2\2\u0088")
        buf.write("\u0089\3\2\2\2\u0089\u00c2\3\2\2\2\u008a\u008b\7\5\2\2")
        buf.write("\u008b\u008c\7\3\2\2\u008c\u0091\7\t\2\2\u008d\u008e\7")
        buf.write("\7\2\2\u008e\u0090\7\t\2\2\u008f\u008d\3\2\2\2\u0090\u0093")
        buf.write("\3\2\2\2\u0091\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092")
        buf.write("\u0094\3\2\2\2\u0093\u0091\3\2\2\2\u0094\u0097\7\4\2\2")
        buf.write("\u0095\u0096\7\b\2\2\u0096\u0098\7\t\2\2\u0097\u0095\3")
        buf.write("\2\2\2\u0097\u0098\3\2\2\2\u0098\u00c2\3\2\2\2\u0099\u009a")
        buf.write("\7\5\2\2\u009a\u009b\7\3\2\2\u009b\u00a0\7\t\2\2\u009c")
        buf.write("\u009d\7\7\2\2\u009d\u009f\7\t\2\2\u009e\u009c\3\2\2\2")
        buf.write("\u009f\u00a2\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u00a1\3")
        buf.write("\2\2\2\u00a1\u00a3\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a3\u00a6")
        buf.write("\7\4\2\2\u00a4\u00a5\7\b\2\2\u00a5\u00a7\7\r\2\2\u00a6")
        buf.write("\u00a4\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00c2\3\2\2\2")
        buf.write("\u00a8\u00a9\7\5\2\2\u00a9\u00aa\7\3\2\2\u00aa\u00af\7")
        buf.write("\t\2\2\u00ab\u00ac\7\7\2\2\u00ac\u00ae\7\t\2\2\u00ad\u00ab")
        buf.write("\3\2\2\2\u00ae\u00b1\3\2\2\2\u00af\u00ad\3\2\2\2\u00af")
        buf.write("\u00b0\3\2\2\2\u00b0\u00b2\3\2\2\2\u00b1\u00af\3\2\2\2")
        buf.write("\u00b2\u00bf\7\4\2\2\u00b3\u00b4\7\b\2\2\u00b4\u00b5\7")
        buf.write("\5\2\2\u00b5\u00b6\7\3\2\2\u00b6\u00bb\7\t\2\2\u00b7\u00b8")
        buf.write("\7\7\2\2\u00b8\u00ba\7\t\2\2\u00b9\u00b7\3\2\2\2\u00ba")
        buf.write("\u00bd\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bb\u00bc\3\2\2\2")
        buf.write("\u00bc\u00be\3\2\2\2\u00bd\u00bb\3\2\2\2\u00be\u00c0\7")
        buf.write("\4\2\2\u00bf\u00b3\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c2")
        buf.write("\3\2\2\2\u00c1\5\3\2\2\2\u00c1\61\3\2\2\2\u00c1^\3\2\2")
        buf.write("\2\u00c1d\3\2\2\2\u00c1j\3\2\2\2\u00c1y\3\2\2\2\u00c1")
        buf.write("\u008a\3\2\2\2\u00c1\u0099\3\2\2\2\u00c1\u00a8\3\2\2\2")
        buf.write("\u00c2\3\3\2\2\2\'\5\b\13\16\22\26\31\35!%.\61\648<?C")
        buf.write("GLOVZ\\bhsw\u0080\u0088\u0091\u0097\u00a0\u00a6\u00af")
        buf.write("\u00bb\u00bf\u00c1")
        return buf.getvalue()


class comparatorParser ( Parser ):

    grammarFileName = "comparator.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>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'*'", "'['", "']'", "'{'", "'}'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "METHOD", "BOOL", 
                      "OP", "COMP", "FMT1", "ATTRFMT1", "ATTRFMT2", "ATTRFMT3", 
                      "STRING", "ARRSTRING", "DICTSTRING", "QUOTESTRING", 
                      "NUMBER", "FNUMBER", "IPADDRESS", "QUOTE", "STAR", 
                      "SQOPEN", "SQCLOSE", "FLOPEN", "FLCLOSE", "WS" ]

    RULE_expression = 0

    ruleNames =  [ "expression" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    METHOD=3
    BOOL=4
    OP=5
    COMP=6
    FMT1=7
    ATTRFMT1=8
    ATTRFMT2=9
    ATTRFMT3=10
    STRING=11
    ARRSTRING=12
    DICTSTRING=13
    QUOTESTRING=14
    NUMBER=15
    FNUMBER=16
    IPADDRESS=17
    QUOTE=18
    STAR=19
    SQOPEN=20
    SQCLOSE=21
    FLOPEN=22
    FLCLOSE=23
    WS=24

    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 ExpressionContext(ParserRuleContext):

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

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

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

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

        def COMP(self):
            return self.getToken(comparatorParser.COMP, 0)

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

        def FNUMBER(self):
            return self.getToken(comparatorParser.FNUMBER, 0)

        def BOOL(self):
            return self.getToken(comparatorParser.BOOL, 0)

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

        def ARRSTRING(self):
            return self.getToken(comparatorParser.ARRSTRING, 0)

        def DICTSTRING(self):
            return self.getToken(comparatorParser.DICTSTRING, 0)

        def IPADDRESS(self):
            return self.getToken(comparatorParser.IPADDRESS, 0)

        def getRuleIndex(self):
            return comparatorParser.RULE_expression

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

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




    def expression(self):

        localctx = comparatorParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.state = 191
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 2
                    self.match(comparatorParser.METHOD)


                self.state = 6
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
                if la_ == 1:
                    self.state = 5
                    self.match(comparatorParser.T__0)


                self.state = 9
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.METHOD:
                    self.state = 8
                    self.match(comparatorParser.METHOD)


                self.state = 12
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.T__0:
                    self.state = 11
                    self.match(comparatorParser.T__0)


                self.state = 14
                self.match(comparatorParser.FMT1)
                self.state = 16
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
                if la_ == 1:
                    self.state = 15
                    self.match(comparatorParser.T__1)


                self.state = 31
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==comparatorParser.OP:
                    self.state = 18
                    self.match(comparatorParser.OP)
                    self.state = 20
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==comparatorParser.METHOD:
                        self.state = 19
                        self.match(comparatorParser.METHOD)


                    self.state = 23
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==comparatorParser.T__0:
                        self.state = 22
                        self.match(comparatorParser.T__0)


                    self.state = 25
                    self.match(comparatorParser.FMT1)
                    self.state = 27
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
                    if la_ == 1:
                        self.state = 26
                        self.match(comparatorParser.T__1)


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

                self.state = 35
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.T__1:
                    self.state = 34
                    self.match(comparatorParser.T__1)


                self.state = 44
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [comparatorParser.COMP]:
                    self.state = 37
                    self.match(comparatorParser.COMP)
                    self.state = 38
                    self.match(comparatorParser.NUMBER)
                    pass
                elif token in [comparatorParser.FNUMBER]:
                    self.state = 39
                    self.match(comparatorParser.FNUMBER)
                    pass
                elif token in [comparatorParser.BOOL]:
                    self.state = 40
                    self.match(comparatorParser.BOOL)
                    pass
                elif token in [comparatorParser.STRING]:
                    self.state = 41
                    self.match(comparatorParser.STRING)
                    pass
                elif token in [comparatorParser.ARRSTRING]:
                    self.state = 42
                    self.match(comparatorParser.ARRSTRING)
                    pass
                elif token in [comparatorParser.DICTSTRING]:
                    self.state = 43
                    self.match(comparatorParser.DICTSTRING)
                    pass
                elif token in [comparatorParser.EOF]:
                    pass
                else:
                    pass
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 47
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.METHOD:
                    self.state = 46
                    self.match(comparatorParser.METHOD)


                self.state = 50
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.T__0:
                    self.state = 49
                    self.match(comparatorParser.T__0)


                self.state = 52
                self.match(comparatorParser.FMT1)
                self.state = 54
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.T__1:
                    self.state = 53
                    self.match(comparatorParser.T__1)


                self.state = 69
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==comparatorParser.OP:
                    self.state = 56
                    self.match(comparatorParser.OP)
                    self.state = 58
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==comparatorParser.METHOD:
                        self.state = 57
                        self.match(comparatorParser.METHOD)


                    self.state = 61
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==comparatorParser.T__0:
                        self.state = 60
                        self.match(comparatorParser.T__0)


                    self.state = 63
                    self.match(comparatorParser.FMT1)
                    self.state = 65
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==comparatorParser.T__1:
                        self.state = 64
                        self.match(comparatorParser.T__1)


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

                self.state = 90
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.COMP:
                    self.state = 72
                    self.match(comparatorParser.COMP)
                    self.state = 74
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==comparatorParser.METHOD:
                        self.state = 73
                        self.match(comparatorParser.METHOD)


                    self.state = 77
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==comparatorParser.T__0:
                        self.state = 76
                        self.match(comparatorParser.T__0)


                    self.state = 79
                    self.match(comparatorParser.FMT1)
                    self.state = 84
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==comparatorParser.OP:
                        self.state = 80
                        self.match(comparatorParser.OP)
                        self.state = 81
                        self.match(comparatorParser.FMT1)
                        self.state = 86
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 88
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==comparatorParser.T__1:
                        self.state = 87
                        self.match(comparatorParser.T__1)




                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 92
                self.match(comparatorParser.FMT1)
                self.state = 96
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [comparatorParser.COMP]:
                    self.state = 93
                    self.match(comparatorParser.COMP)
                    self.state = 94
                    self.match(comparatorParser.NUMBER)
                    pass
                elif token in [comparatorParser.FNUMBER]:
                    self.state = 95
                    self.match(comparatorParser.FNUMBER)
                    pass
                elif token in [comparatorParser.EOF]:
                    pass
                else:
                    pass
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 98
                self.match(comparatorParser.FMT1)
                self.state = 102
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [comparatorParser.COMP]:
                    self.state = 99
                    self.match(comparatorParser.COMP)
                    self.state = 100
                    self.match(comparatorParser.IPADDRESS)
                    pass
                elif token in [comparatorParser.STRING]:
                    self.state = 101
                    self.match(comparatorParser.STRING)
                    pass
                elif token in [comparatorParser.EOF]:
                    pass
                else:
                    pass
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 104
                self.match(comparatorParser.FMT1)
                self.state = 117
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.COMP:
                    self.state = 105
                    self.match(comparatorParser.COMP)
                    self.state = 106
                    self.match(comparatorParser.METHOD)
                    self.state = 107
                    self.match(comparatorParser.T__0)
                    self.state = 108
                    self.match(comparatorParser.FMT1)
                    self.state = 113
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==comparatorParser.OP:
                        self.state = 109
                        self.match(comparatorParser.OP)
                        self.state = 110
                        self.match(comparatorParser.FMT1)
                        self.state = 115
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 116
                    self.match(comparatorParser.T__1)


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 119
                self.match(comparatorParser.METHOD)
                self.state = 120
                self.match(comparatorParser.T__0)
                self.state = 121
                self.match(comparatorParser.FMT1)
                self.state = 126
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==comparatorParser.OP:
                    self.state = 122
                    self.match(comparatorParser.OP)
                    self.state = 123
                    self.match(comparatorParser.FMT1)
                    self.state = 128
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 129
                self.match(comparatorParser.T__1)
                self.state = 134
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [comparatorParser.COMP]:
                    self.state = 130
                    self.match(comparatorParser.COMP)
                    self.state = 131
                    self.match(comparatorParser.NUMBER)
                    pass
                elif token in [comparatorParser.FNUMBER]:
                    self.state = 132
                    self.match(comparatorParser.FNUMBER)
                    pass
                elif token in [comparatorParser.BOOL]:
                    self.state = 133
                    self.match(comparatorParser.BOOL)
                    pass
                elif token in [comparatorParser.EOF]:
                    pass
                else:
                    pass
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 136
                self.match(comparatorParser.METHOD)
                self.state = 137
                self.match(comparatorParser.T__0)
                self.state = 138
                self.match(comparatorParser.FMT1)
                self.state = 143
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==comparatorParser.OP:
                    self.state = 139
                    self.match(comparatorParser.OP)
                    self.state = 140
                    self.match(comparatorParser.FMT1)
                    self.state = 145
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 146
                self.match(comparatorParser.T__1)
                self.state = 149
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.COMP:
                    self.state = 147
                    self.match(comparatorParser.COMP)
                    self.state = 148
                    self.match(comparatorParser.FMT1)


                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 151
                self.match(comparatorParser.METHOD)
                self.state = 152
                self.match(comparatorParser.T__0)
                self.state = 153
                self.match(comparatorParser.FMT1)
                self.state = 158
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==comparatorParser.OP:
                    self.state = 154
                    self.match(comparatorParser.OP)
                    self.state = 155
                    self.match(comparatorParser.FMT1)
                    self.state = 160
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 161
                self.match(comparatorParser.T__1)
                self.state = 164
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.COMP:
                    self.state = 162
                    self.match(comparatorParser.COMP)
                    self.state = 163
                    self.match(comparatorParser.STRING)


                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 166
                self.match(comparatorParser.METHOD)
                self.state = 167
                self.match(comparatorParser.T__0)
                self.state = 168
                self.match(comparatorParser.FMT1)
                self.state = 173
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==comparatorParser.OP:
                    self.state = 169
                    self.match(comparatorParser.OP)
                    self.state = 170
                    self.match(comparatorParser.FMT1)
                    self.state = 175
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 176
                self.match(comparatorParser.T__1)
                self.state = 189
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==comparatorParser.COMP:
                    self.state = 177
                    self.match(comparatorParser.COMP)
                    self.state = 178
                    self.match(comparatorParser.METHOD)
                    self.state = 179
                    self.match(comparatorParser.T__0)
                    self.state = 180
                    self.match(comparatorParser.FMT1)
                    self.state = 185
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==comparatorParser.OP:
                        self.state = 181
                        self.match(comparatorParser.OP)
                        self.state = 182
                        self.match(comparatorParser.FMT1)
                        self.state = 187
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 188
                    self.match(comparatorParser.T__1)


                pass


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





