#!/usr/bin/env python
#
# Copyright 2007 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#


import sys
from google.appengine._internal.antlr3 import *
from google.appengine._internal.antlr3.compat import set, frozenset

from google.appengine._internal.antlr3.tree import *


HIDDEN = BaseRecognizer.HIDDEN


DOLLAR=54
EXPONENT=49
LT=11
LSQUARE=23
ASCII_LETTER=52
LOG=40
SNIPPET=44
OCTAL_ESC=57
MAX=41
FLOAT=34
COUNT=38
NAME_START=50
NOT=10
HTML=28
ATOM=29
AND=7
EOF=-1
LPAREN=21
INDEX=5
QUOTE=47
RPAREN=22
DISTANCE=39
T__58=58
NAME=26
ESC_SEQ=48
POW=43
COMMA=36
PLUS=17
GEO=32
DIGIT=46
EQ=15
NE=16
GE=14
XOR=9
SWITCH=45
UNICODE_ESC=56
NUMBER=31
HEX_DIGIT=55
UNDERSCORE=53
INT=24
MIN=42
MINUS=18
RSQUARE=25
TEXT=27
GEOPOINT=33
PHRASE=35
ABS=37
WS=51
OR=8
NEG=4
GT=13
DIV=20
TIMES=19
DATE=30
COND=6
LE=12


tokenNames = [
    "<invalid>", "<EOR>", "<DOWN>", "<UP>",
    "NEG", "INDEX", "COND", "AND", "OR", "XOR", "NOT", "LT", "LE", "GT",
    "GE", "EQ", "NE", "PLUS", "MINUS", "TIMES", "DIV", "LPAREN", "RPAREN",
    "LSQUARE", "INT", "RSQUARE", "NAME", "TEXT", "HTML", "ATOM", "DATE",
    "NUMBER", "GEO", "GEOPOINT", "FLOAT", "PHRASE", "COMMA", "ABS", "COUNT",
    "DISTANCE", "LOG", "MAX", "MIN", "POW", "SNIPPET", "SWITCH", "DIGIT",
    "QUOTE", "ESC_SEQ", "EXPONENT", "NAME_START", "WS", "ASCII_LETTER",
    "UNDERSCORE", "DOLLAR", "HEX_DIGIT", "UNICODE_ESC", "OCTAL_ESC", "'.'"
]


class ExpressionParser(Parser):
    grammarFileName = ""
    antlr_version = version_str_to_tuple("3.1.1")
    antlr_version_str = "3.1.1"
    tokenNames = tokenNames

    def __init__(self, input, state=None):
        if state is None:
            state = RecognizerSharedState()

        Parser.__init__(self, input, state)


        self.dfa9 = self.DFA9(
            self, 9,
            eot = self.DFA9_eot,
            eof = self.DFA9_eof,
            min = self.DFA9_min,
            max = self.DFA9_max,
            accept = self.DFA9_accept,
            special = self.DFA9_special,
            transition = self.DFA9_transition
            )

        self.dfa10 = self.DFA10(
            self, 10,
            eot = self.DFA10_eot,
            eof = self.DFA10_eof,
            min = self.DFA10_min,
            max = self.DFA10_max,
            accept = self.DFA10_accept,
            special = self.DFA10_special,
            transition = self.DFA10_transition
            )


        self._adaptor = CommonTreeAdaptor()


    def getTreeAdaptor(self):
        return self._adaptor

    def setTreeAdaptor(self, adaptor):
        self._adaptor = adaptor

    adaptor = property(getTreeAdaptor, setTreeAdaptor)


    def mismatch(input, ttype, follow):
      raise MismatchedTokenException(ttype, input)

    def recoverFromMismatchedSet(input, e, follow):
      raise e


    class expression_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def expression(self, ):

        retval = self.expression_return()
        retval.start = self.input.LT(1)

        root_0 = None

        EOF2 = None
        conjunction1 = None


        EOF2_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                self._state.following.append(self.FOLLOW_conjunction_in_expression90)
                conjunction1 = self.conjunction()

                self._state.following.pop()
                self._adaptor.addChild(root_0, conjunction1.tree)
                EOF2=self.match(self.input, EOF, self.FOLLOW_EOF_in_expression92)

                EOF2_tree = self._adaptor.createWithPayload(EOF2)
                self._adaptor.addChild(root_0, EOF2_tree)


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class condExpr_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def condExpr(self, ):

        retval = self.condExpr_return()
        retval.start = self.input.LT(1)

        root_0 = None

        COND4 = None
        conjunction3 = None

        addExpr5 = None


        COND4_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                self._state.following.append(self.FOLLOW_conjunction_in_condExpr105)
                conjunction3 = self.conjunction()

                self._state.following.pop()
                self._adaptor.addChild(root_0, conjunction3.tree)

                alt1 = 2
                LA1_0 = self.input.LA(1)

                if (LA1_0 == COND) :
                    alt1 = 1
                if alt1 == 1:

                    pass
                    COND4=self.match(self.input, COND, self.FOLLOW_COND_in_condExpr108)

                    COND4_tree = self._adaptor.createWithPayload(COND4)
                    root_0 = self._adaptor.becomeRoot(COND4_tree, root_0)

                    self._state.following.append(self.FOLLOW_addExpr_in_condExpr111)
                    addExpr5 = self.addExpr()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, addExpr5.tree)


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class conjunction_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def conjunction(self, ):

        retval = self.conjunction_return()
        retval.start = self.input.LT(1)

        root_0 = None

        AND7 = None
        disjunction6 = None

        disjunction8 = None


        AND7_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                self._state.following.append(self.FOLLOW_disjunction_in_conjunction126)
                disjunction6 = self.disjunction()

                self._state.following.pop()
                self._adaptor.addChild(root_0, disjunction6.tree)

                while True:
                    alt2 = 2
                    LA2_0 = self.input.LA(1)

                    if (LA2_0 == AND) :
                        alt2 = 1


                    if alt2 == 1:

                        pass
                        AND7=self.match(self.input, AND, self.FOLLOW_AND_in_conjunction129)

                        AND7_tree = self._adaptor.createWithPayload(AND7)
                        root_0 = self._adaptor.becomeRoot(AND7_tree, root_0)

                        self._state.following.append(self.FOLLOW_disjunction_in_conjunction132)
                        disjunction8 = self.disjunction()

                        self._state.following.pop()
                        self._adaptor.addChild(root_0, disjunction8.tree)


                    else:
                        break


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class disjunction_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def disjunction(self, ):

        retval = self.disjunction_return()
        retval.start = self.input.LT(1)

        root_0 = None

        set10 = None
        negation9 = None

        negation11 = None


        set10_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                self._state.following.append(self.FOLLOW_negation_in_disjunction147)
                negation9 = self.negation()

                self._state.following.pop()
                self._adaptor.addChild(root_0, negation9.tree)

                while True:
                    alt3 = 2
                    LA3_0 = self.input.LA(1)

                    if ((OR <= LA3_0 <= XOR)) :
                        alt3 = 1


                    if alt3 == 1:

                        pass
                        set10 = self.input.LT(1)
                        set10 = self.input.LT(1)
                        if (OR <= self.input.LA(1) <= XOR):
                            self.input.consume()
                            root_0 = self._adaptor.becomeRoot(self._adaptor.createWithPayload(set10), root_0)
                            self._state.errorRecovery = False

                        else:
                            mse = MismatchedSetException(None, self.input)
                            raise mse


                        self._state.following.append(self.FOLLOW_negation_in_disjunction159)
                        negation11 = self.negation()

                        self._state.following.pop()
                        self._adaptor.addChild(root_0, negation11.tree)


                    else:
                        break


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class negation_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def negation(self, ):

        retval = self.negation_return()
        retval.start = self.input.LT(1)

        root_0 = None

        NOT13 = None
        cmpExpr12 = None

        cmpExpr14 = None


        NOT13_tree = None

        try:
            try:

                alt4 = 2
                LA4_0 = self.input.LA(1)

                if (LA4_0 == MINUS or LA4_0 == LPAREN or LA4_0 == INT or (NAME <= LA4_0 <= PHRASE) or (ABS <= LA4_0 <= SWITCH)) :
                    alt4 = 1
                elif (LA4_0 == NOT) :
                    alt4 = 2
                else:
                    nvae = NoViableAltException("", 4, 0, self.input)

                    raise nvae

                if alt4 == 1:

                    pass
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_cmpExpr_in_negation174)
                    cmpExpr12 = self.cmpExpr()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, cmpExpr12.tree)


                elif alt4 == 2:

                    pass
                    root_0 = self._adaptor.nil()

                    NOT13=self.match(self.input, NOT, self.FOLLOW_NOT_in_negation180)

                    NOT13_tree = self._adaptor.createWithPayload(NOT13)
                    root_0 = self._adaptor.becomeRoot(NOT13_tree, root_0)

                    self._state.following.append(self.FOLLOW_cmpExpr_in_negation183)
                    cmpExpr14 = self.cmpExpr()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, cmpExpr14.tree)


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class cmpExpr_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def cmpExpr(self, ):

        retval = self.cmpExpr_return()
        retval.start = self.input.LT(1)

        root_0 = None

        addExpr15 = None

        cmpOp16 = None

        addExpr17 = None


        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                self._state.following.append(self.FOLLOW_addExpr_in_cmpExpr196)
                addExpr15 = self.addExpr()

                self._state.following.pop()
                self._adaptor.addChild(root_0, addExpr15.tree)

                alt5 = 2
                LA5_0 = self.input.LA(1)

                if ((LT <= LA5_0 <= NE)) :
                    alt5 = 1
                if alt5 == 1:

                    pass
                    self._state.following.append(self.FOLLOW_cmpOp_in_cmpExpr199)
                    cmpOp16 = self.cmpOp()

                    self._state.following.pop()
                    root_0 = self._adaptor.becomeRoot(cmpOp16.tree, root_0)
                    self._state.following.append(self.FOLLOW_addExpr_in_cmpExpr202)
                    addExpr17 = self.addExpr()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, addExpr17.tree)


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class cmpOp_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def cmpOp(self, ):

        retval = self.cmpOp_return()
        retval.start = self.input.LT(1)

        root_0 = None

        set18 = None

        set18_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                set18 = self.input.LT(1)
                if (LT <= self.input.LA(1) <= NE):
                    self.input.consume()
                    self._adaptor.addChild(root_0, self._adaptor.createWithPayload(set18))
                    self._state.errorRecovery = False

                else:
                    mse = MismatchedSetException(None, self.input)
                    raise mse


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class addExpr_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def addExpr(self, ):

        retval = self.addExpr_return()
        retval.start = self.input.LT(1)

        root_0 = None

        multExpr19 = None

        addOp20 = None

        multExpr21 = None


        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                self._state.following.append(self.FOLLOW_multExpr_in_addExpr260)
                multExpr19 = self.multExpr()

                self._state.following.pop()
                self._adaptor.addChild(root_0, multExpr19.tree)

                while True:
                    alt6 = 2
                    LA6_0 = self.input.LA(1)

                    if ((PLUS <= LA6_0 <= MINUS)) :
                        alt6 = 1


                    if alt6 == 1:

                        pass
                        self._state.following.append(self.FOLLOW_addOp_in_addExpr263)
                        addOp20 = self.addOp()

                        self._state.following.pop()
                        root_0 = self._adaptor.becomeRoot(addOp20.tree, root_0)
                        self._state.following.append(self.FOLLOW_multExpr_in_addExpr266)
                        multExpr21 = self.multExpr()

                        self._state.following.pop()
                        self._adaptor.addChild(root_0, multExpr21.tree)


                    else:
                        break


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class addOp_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def addOp(self, ):

        retval = self.addOp_return()
        retval.start = self.input.LT(1)

        root_0 = None

        set22 = None

        set22_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                set22 = self.input.LT(1)
                if (PLUS <= self.input.LA(1) <= MINUS):
                    self.input.consume()
                    self._adaptor.addChild(root_0, self._adaptor.createWithPayload(set22))
                    self._state.errorRecovery = False

                else:
                    mse = MismatchedSetException(None, self.input)
                    raise mse


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class multExpr_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def multExpr(self, ):

        retval = self.multExpr_return()
        retval.start = self.input.LT(1)

        root_0 = None

        unary23 = None

        multOp24 = None

        unary25 = None


        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                self._state.following.append(self.FOLLOW_unary_in_multExpr300)
                unary23 = self.unary()

                self._state.following.pop()
                self._adaptor.addChild(root_0, unary23.tree)

                while True:
                    alt7 = 2
                    LA7_0 = self.input.LA(1)

                    if ((TIMES <= LA7_0 <= DIV)) :
                        alt7 = 1


                    if alt7 == 1:

                        pass
                        self._state.following.append(self.FOLLOW_multOp_in_multExpr303)
                        multOp24 = self.multOp()

                        self._state.following.pop()
                        root_0 = self._adaptor.becomeRoot(multOp24.tree, root_0)
                        self._state.following.append(self.FOLLOW_unary_in_multExpr306)
                        unary25 = self.unary()

                        self._state.following.pop()
                        self._adaptor.addChild(root_0, unary25.tree)


                    else:
                        break


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class multOp_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def multOp(self, ):

        retval = self.multOp_return()
        retval.start = self.input.LT(1)

        root_0 = None

        set26 = None

        set26_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                set26 = self.input.LT(1)
                if (TIMES <= self.input.LA(1) <= DIV):
                    self.input.consume()
                    self._adaptor.addChild(root_0, self._adaptor.createWithPayload(set26))
                    self._state.errorRecovery = False

                else:
                    mse = MismatchedSetException(None, self.input)
                    raise mse


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class unary_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def unary(self, ):

        retval = self.unary_return()
        retval.start = self.input.LT(1)

        root_0 = None

        MINUS27 = None
        atom28 = None

        atom29 = None


        MINUS27_tree = None
        stream_MINUS = RewriteRuleTokenStream(self._adaptor, "token MINUS")
        stream_atom = RewriteRuleSubtreeStream(self._adaptor, "rule atom")
        try:
            try:

                alt8 = 2
                LA8_0 = self.input.LA(1)

                if (LA8_0 == MINUS) :
                    alt8 = 1
                elif (LA8_0 == LPAREN or LA8_0 == INT or (NAME <= LA8_0 <= PHRASE) or (ABS <= LA8_0 <= SWITCH)) :
                    alt8 = 2
                else:
                    nvae = NoViableAltException("", 8, 0, self.input)

                    raise nvae

                if alt8 == 1:

                    pass
                    MINUS27=self.match(self.input, MINUS, self.FOLLOW_MINUS_in_unary340)
                    stream_MINUS.add(MINUS27)
                    self._state.following.append(self.FOLLOW_atom_in_unary342)
                    atom28 = self.atom()

                    self._state.following.pop()
                    stream_atom.add(atom28.tree)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()


                    root_1 = self._adaptor.nil()
                    root_1 = self._adaptor.becomeRoot(self._adaptor.create(NEG, "-"), root_1)

                    self._adaptor.addChild(root_1, stream_atom.nextTree())

                    self._adaptor.addChild(root_0, root_1)


                    retval.tree = root_0


                elif alt8 == 2:

                    pass
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_atom_in_unary357)
                    atom29 = self.atom()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, atom29.tree)


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class atom_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def atom(self, ):

        retval = self.atom_return()
        retval.start = self.input.LT(1)

        root_0 = None

        LPAREN34 = None
        RPAREN36 = None
        var30 = None

        num31 = None

        str32 = None

        fn33 = None

        conjunction35 = None


        LPAREN34_tree = None
        RPAREN36_tree = None
        stream_RPAREN = RewriteRuleTokenStream(self._adaptor, "token RPAREN")
        stream_LPAREN = RewriteRuleTokenStream(self._adaptor, "token LPAREN")
        stream_conjunction = RewriteRuleSubtreeStream(self._adaptor, "rule conjunction")
        try:
            try:

                alt9 = 5
                alt9 = self.dfa9.predict(self.input)
                if alt9 == 1:

                    pass
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_var_in_atom370)
                    var30 = self.var()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, var30.tree)


                elif alt9 == 2:

                    pass
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_num_in_atom376)
                    num31 = self.num()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, num31.tree)


                elif alt9 == 3:

                    pass
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_str_in_atom382)
                    str32 = self.str()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, str32.tree)


                elif alt9 == 4:

                    pass
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_fn_in_atom388)
                    fn33 = self.fn()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, fn33.tree)


                elif alt9 == 5:

                    pass
                    LPAREN34=self.match(self.input, LPAREN, self.FOLLOW_LPAREN_in_atom394)
                    stream_LPAREN.add(LPAREN34)
                    self._state.following.append(self.FOLLOW_conjunction_in_atom396)
                    conjunction35 = self.conjunction()

                    self._state.following.pop()
                    stream_conjunction.add(conjunction35.tree)
                    RPAREN36=self.match(self.input, RPAREN, self.FOLLOW_RPAREN_in_atom398)
                    stream_RPAREN.add(RPAREN36)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, stream_conjunction.nextTree())


                    retval.tree = root_0


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class var_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def var(self, ):

        retval = self.var_return()
        retval.start = self.input.LT(1)

        root_0 = None

        name37 = None

        name38 = None

        index39 = None


        stream_index = RewriteRuleSubtreeStream(self._adaptor, "rule index")
        stream_name = RewriteRuleSubtreeStream(self._adaptor, "rule name")
        try:
            try:

                alt10 = 2
                alt10 = self.dfa10.predict(self.input)
                if alt10 == 1:

                    pass
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_name_in_var415)
                    name37 = self.name()

                    self._state.following.pop()
                    self._adaptor.addChild(root_0, name37.tree)


                elif alt10 == 2:

                    pass
                    self._state.following.append(self.FOLLOW_name_in_var421)
                    name38 = self.name()

                    self._state.following.pop()
                    stream_name.add(name38.tree)
                    self._state.following.append(self.FOLLOW_index_in_var423)
                    index39 = self.index()

                    self._state.following.pop()
                    stream_index.add(index39.tree)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()


                    root_1 = self._adaptor.nil()
                    root_1 = self._adaptor.becomeRoot(self._adaptor.create(INDEX, ((index39 is not None) and [self.input.toString(index39.start,index39.stop)] or [None])[0]), root_1)

                    self._adaptor.addChild(root_1, stream_name.nextTree())

                    self._adaptor.addChild(root_0, root_1)


                    retval.tree = root_0


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class index_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def index(self, ):

        retval = self.index_return()
        retval.start = self.input.LT(1)

        root_0 = None

        x = None
        LSQUARE40 = None
        RSQUARE41 = None

        x_tree = None
        LSQUARE40_tree = None
        RSQUARE41_tree = None
        stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT")
        stream_LSQUARE = RewriteRuleTokenStream(self._adaptor, "token LSQUARE")
        stream_RSQUARE = RewriteRuleTokenStream(self._adaptor, "token RSQUARE")

        try:
            try:


                pass
                LSQUARE40=self.match(self.input, LSQUARE, self.FOLLOW_LSQUARE_in_index445)
                stream_LSQUARE.add(LSQUARE40)
                x=self.match(self.input, INT, self.FOLLOW_INT_in_index449)
                stream_INT.add(x)
                RSQUARE41=self.match(self.input, RSQUARE, self.FOLLOW_RSQUARE_in_index451)
                stream_RSQUARE.add(RSQUARE41)


                retval.tree = root_0
                stream_x = RewriteRuleTokenStream(self._adaptor, "token x", x)

                if retval is not None:
                    stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                else:
                    stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                root_0 = self._adaptor.nil()

                self._adaptor.addChild(root_0, stream_x.nextNode())


                retval.tree = root_0


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class name_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def name(self, ):

        retval = self.name_return()
        retval.start = self.input.LT(1)

        root_0 = None

        t = None
        NAME42 = None
        char_literal43 = None
        NAME44 = None

        t_tree = None
        NAME42_tree = None
        char_literal43_tree = None
        NAME44_tree = None
        stream_GEO = RewriteRuleTokenStream(self._adaptor, "token GEO")
        stream_HTML = RewriteRuleTokenStream(self._adaptor, "token HTML")
        stream_ATOM = RewriteRuleTokenStream(self._adaptor, "token ATOM")
        stream_TEXT = RewriteRuleTokenStream(self._adaptor, "token TEXT")
        stream_DATE = RewriteRuleTokenStream(self._adaptor, "token DATE")
        stream_GEOPOINT = RewriteRuleTokenStream(self._adaptor, "token GEOPOINT")
        stream_NUMBER = RewriteRuleTokenStream(self._adaptor, "token NUMBER")

        try:
            try:

                alt12 = 8
                LA12 = self.input.LA(1)
                if LA12 == NAME:
                    alt12 = 1
                elif LA12 == TEXT:
                    alt12 = 2
                elif LA12 == HTML:
                    alt12 = 3
                elif LA12 == ATOM:
                    alt12 = 4
                elif LA12 == DATE:
                    alt12 = 5
                elif LA12 == NUMBER:
                    alt12 = 6
                elif LA12 == GEO:
                    alt12 = 7
                elif LA12 == GEOPOINT:
                    alt12 = 8
                else:
                    nvae = NoViableAltException("", 12, 0, self.input)

                    raise nvae

                if alt12 == 1:

                    pass
                    root_0 = self._adaptor.nil()

                    NAME42=self.match(self.input, NAME, self.FOLLOW_NAME_in_name469)

                    NAME42_tree = self._adaptor.createWithPayload(NAME42)
                    self._adaptor.addChild(root_0, NAME42_tree)


                    while True:
                        alt11 = 2
                        LA11_0 = self.input.LA(1)

                        if (LA11_0 == 58) :
                            alt11 = 1


                        if alt11 == 1:

                            pass
                            char_literal43=self.match(self.input, 58, self.FOLLOW_58_in_name472)

                            char_literal43_tree = self._adaptor.createWithPayload(char_literal43)
                            root_0 = self._adaptor.becomeRoot(char_literal43_tree, root_0)

                            NAME44=self.match(self.input, NAME, self.FOLLOW_NAME_in_name475)

                            NAME44_tree = self._adaptor.createWithPayload(NAME44)
                            self._adaptor.addChild(root_0, NAME44_tree)


                        else:
                            break


                elif alt12 == 2:

                    pass
                    t=self.match(self.input, TEXT, self.FOLLOW_TEXT_in_name491)
                    stream_TEXT.add(t)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, self._adaptor.create(NAME, t))


                    retval.tree = root_0


                elif alt12 == 3:

                    pass
                    t=self.match(self.input, HTML, self.FOLLOW_HTML_in_name504)
                    stream_HTML.add(t)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, self._adaptor.create(NAME, t))


                    retval.tree = root_0


                elif alt12 == 4:

                    pass
                    t=self.match(self.input, ATOM, self.FOLLOW_ATOM_in_name517)
                    stream_ATOM.add(t)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, self._adaptor.create(NAME, t))


                    retval.tree = root_0


                elif alt12 == 5:

                    pass
                    t=self.match(self.input, DATE, self.FOLLOW_DATE_in_name530)
                    stream_DATE.add(t)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, self._adaptor.create(NAME, t))


                    retval.tree = root_0


                elif alt12 == 6:

                    pass
                    t=self.match(self.input, NUMBER, self.FOLLOW_NUMBER_in_name543)
                    stream_NUMBER.add(t)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, self._adaptor.create(NAME, t))


                    retval.tree = root_0


                elif alt12 == 7:

                    pass
                    t=self.match(self.input, GEO, self.FOLLOW_GEO_in_name556)
                    stream_GEO.add(t)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, self._adaptor.create(NAME, t))


                    retval.tree = root_0


                elif alt12 == 8:

                    pass
                    t=self.match(self.input, GEOPOINT, self.FOLLOW_GEOPOINT_in_name569)
                    stream_GEOPOINT.add(t)


                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()

                    self._adaptor.addChild(root_0, self._adaptor.create(NAME, t))


                    retval.tree = root_0


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class num_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def num(self, ):

        retval = self.num_return()
        retval.start = self.input.LT(1)

        root_0 = None

        set45 = None

        set45_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                set45 = self.input.LT(1)
                if self.input.LA(1) == INT or self.input.LA(1) == FLOAT:
                    self.input.consume()
                    self._adaptor.addChild(root_0, self._adaptor.createWithPayload(set45))
                    self._state.errorRecovery = False

                else:
                    mse = MismatchedSetException(None, self.input)
                    raise mse


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class str_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def str(self, ):

        retval = self.str_return()
        retval.start = self.input.LT(1)

        root_0 = None

        PHRASE46 = None

        PHRASE46_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                PHRASE46=self.match(self.input, PHRASE, self.FOLLOW_PHRASE_in_str606)

                PHRASE46_tree = self._adaptor.createWithPayload(PHRASE46)
                self._adaptor.addChild(root_0, PHRASE46_tree)


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class fn_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def fn(self, ):

        retval = self.fn_return()
        retval.start = self.input.LT(1)

        root_0 = None

        LPAREN48 = None
        COMMA50 = None
        RPAREN52 = None
        fnName47 = None

        condExpr49 = None

        condExpr51 = None


        LPAREN48_tree = None
        COMMA50_tree = None
        RPAREN52_tree = None
        stream_RPAREN = RewriteRuleTokenStream(self._adaptor, "token RPAREN")
        stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA")
        stream_LPAREN = RewriteRuleTokenStream(self._adaptor, "token LPAREN")
        stream_fnName = RewriteRuleSubtreeStream(self._adaptor, "rule fnName")
        stream_condExpr = RewriteRuleSubtreeStream(self._adaptor, "rule condExpr")
        try:
            try:


                pass
                self._state.following.append(self.FOLLOW_fnName_in_fn619)
                fnName47 = self.fnName()

                self._state.following.pop()
                stream_fnName.add(fnName47.tree)
                LPAREN48=self.match(self.input, LPAREN, self.FOLLOW_LPAREN_in_fn621)
                stream_LPAREN.add(LPAREN48)
                self._state.following.append(self.FOLLOW_condExpr_in_fn623)
                condExpr49 = self.condExpr()

                self._state.following.pop()
                stream_condExpr.add(condExpr49.tree)

                while True:
                    alt13 = 2
                    LA13_0 = self.input.LA(1)

                    if (LA13_0 == COMMA) :
                        alt13 = 1


                    if alt13 == 1:

                        pass
                        COMMA50=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_fn626)
                        stream_COMMA.add(COMMA50)
                        self._state.following.append(self.FOLLOW_condExpr_in_fn628)
                        condExpr51 = self.condExpr()

                        self._state.following.pop()
                        stream_condExpr.add(condExpr51.tree)


                    else:
                        break


                RPAREN52=self.match(self.input, RPAREN, self.FOLLOW_RPAREN_in_fn632)
                stream_RPAREN.add(RPAREN52)


                retval.tree = root_0

                if retval is not None:
                    stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", retval.tree)
                else:
                    stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                root_0 = self._adaptor.nil()


                root_1 = self._adaptor.nil()
                root_1 = self._adaptor.becomeRoot(stream_fnName.nextNode(), root_1)


                if not (stream_condExpr.hasNext()):
                    raise RewriteEarlyExitException()

                while stream_condExpr.hasNext():
                    self._adaptor.addChild(root_1, stream_condExpr.nextTree())


                stream_condExpr.reset()

                self._adaptor.addChild(root_0, root_1)


                retval.tree = root_0


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    class fnName_return(ParserRuleReturnScope):
        def __init__(self):
            ParserRuleReturnScope.__init__(self)

            self.tree = None


    def fnName(self, ):

        retval = self.fnName_return()
        retval.start = self.input.LT(1)

        root_0 = None

        set53 = None

        set53_tree = None

        try:
            try:


                pass
                root_0 = self._adaptor.nil()

                set53 = self.input.LT(1)
                if (TEXT <= self.input.LA(1) <= GEOPOINT) or (ABS <= self.input.LA(1) <= SWITCH):
                    self.input.consume()
                    self._adaptor.addChild(root_0, self._adaptor.createWithPayload(set53))
                    self._state.errorRecovery = False

                else:
                    mse = MismatchedSetException(None, self.input)
                    raise mse


                retval.stop = self.input.LT(-1)


                retval.tree = self._adaptor.rulePostProcessing(root_0)
                self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, e:
              self.reportError(e)
              raise e
        finally:

            pass

        return retval


    DFA9_eot = DFA.unpack(
        u"\15\uffff"
        )

    DFA9_eof = DFA.unpack(
        u"\2\uffff\7\1\4\uffff"
        )

    DFA9_min = DFA.unpack(
        u"\1\25\1\uffff\7\6\4\uffff"
        )

    DFA9_max = DFA.unpack(
        u"\1\55\1\uffff\7\44\4\uffff"
        )

    DFA9_accept = DFA.unpack(
        u"\1\uffff\1\1\7\uffff\1\2\1\3\1\4\1\5"
        )

    DFA9_special = DFA.unpack(
        u"\15\uffff"
        )


    DFA9_transition = [
        DFA.unpack(u"\1\14\2\uffff\1\11\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1"
        u"\7\1\10\1\11\1\12\1\uffff\11\13"),
        DFA.unpack(u""),
        DFA.unpack(u"\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1"),
        DFA.unpack(u"\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1"),
        DFA.unpack(u"\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1"),
        DFA.unpack(u"\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1"),
        DFA.unpack(u"\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1"),
        DFA.unpack(u"\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1"),
        DFA.unpack(u"\4\1\1\uffff\12\1\1\13\2\1\14\uffff\1\1"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"")
    ]


    DFA9 = DFA


    DFA10_eot = DFA.unpack(
        u"\15\uffff"
        )

    DFA10_eof = DFA.unpack(
        u"\1\uffff\10\13\3\uffff\1\13"
        )

    DFA10_min = DFA.unpack(
        u"\1\32\10\6\1\32\2\uffff\1\6"
        )

    DFA10_max = DFA.unpack(
        u"\1\41\1\72\7\44\1\32\2\uffff\1\72"
        )

    DFA10_accept = DFA.unpack(
        u"\12\uffff\1\2\1\1\1\uffff"
        )

    DFA10_special = DFA.unpack(
        u"\15\uffff"
        )


    DFA10_transition = [
        DFA.unpack(u"\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10"),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"
        u"\25\uffff\1\11"),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"),
        DFA.unpack(u"\1\14"),
        DFA.unpack(u""),
        DFA.unpack(u""),
        DFA.unpack(u"\4\13\1\uffff\12\13\1\uffff\1\13\1\12\14\uffff\1\13"
        u"\25\uffff\1\11")
    ]


    DFA10 = DFA


    FOLLOW_conjunction_in_expression90 = frozenset([])
    FOLLOW_EOF_in_expression92 = frozenset([1])
    FOLLOW_conjunction_in_condExpr105 = frozenset([1, 6])
    FOLLOW_COND_in_condExpr108 = frozenset([18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_addExpr_in_condExpr111 = frozenset([1])
    FOLLOW_disjunction_in_conjunction126 = frozenset([1, 7])
    FOLLOW_AND_in_conjunction129 = frozenset([10, 18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_disjunction_in_conjunction132 = frozenset([1, 7])
    FOLLOW_negation_in_disjunction147 = frozenset([1, 8, 9])
    FOLLOW_set_in_disjunction150 = frozenset([10, 18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_negation_in_disjunction159 = frozenset([1, 8, 9])
    FOLLOW_cmpExpr_in_negation174 = frozenset([1])
    FOLLOW_NOT_in_negation180 = frozenset([18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_cmpExpr_in_negation183 = frozenset([1])
    FOLLOW_addExpr_in_cmpExpr196 = frozenset([1, 11, 12, 13, 14, 15, 16])
    FOLLOW_cmpOp_in_cmpExpr199 = frozenset([18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_addExpr_in_cmpExpr202 = frozenset([1])
    FOLLOW_set_in_cmpOp0 = frozenset([1])
    FOLLOW_multExpr_in_addExpr260 = frozenset([1, 17, 18])
    FOLLOW_addOp_in_addExpr263 = frozenset([18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_multExpr_in_addExpr266 = frozenset([1, 17, 18])
    FOLLOW_set_in_addOp0 = frozenset([1])
    FOLLOW_unary_in_multExpr300 = frozenset([1, 19, 20])
    FOLLOW_multOp_in_multExpr303 = frozenset([18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_unary_in_multExpr306 = frozenset([1, 19, 20])
    FOLLOW_set_in_multOp0 = frozenset([1])
    FOLLOW_MINUS_in_unary340 = frozenset([18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_atom_in_unary342 = frozenset([1])
    FOLLOW_atom_in_unary357 = frozenset([1])
    FOLLOW_var_in_atom370 = frozenset([1])
    FOLLOW_num_in_atom376 = frozenset([1])
    FOLLOW_str_in_atom382 = frozenset([1])
    FOLLOW_fn_in_atom388 = frozenset([1])
    FOLLOW_LPAREN_in_atom394 = frozenset([10, 18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_conjunction_in_atom396 = frozenset([22])
    FOLLOW_RPAREN_in_atom398 = frozenset([1])
    FOLLOW_name_in_var415 = frozenset([1])
    FOLLOW_name_in_var421 = frozenset([23])
    FOLLOW_index_in_var423 = frozenset([1])
    FOLLOW_LSQUARE_in_index445 = frozenset([24])
    FOLLOW_INT_in_index449 = frozenset([25])
    FOLLOW_RSQUARE_in_index451 = frozenset([1])
    FOLLOW_NAME_in_name469 = frozenset([1, 58])
    FOLLOW_58_in_name472 = frozenset([26])
    FOLLOW_NAME_in_name475 = frozenset([1, 58])
    FOLLOW_TEXT_in_name491 = frozenset([1])
    FOLLOW_HTML_in_name504 = frozenset([1])
    FOLLOW_ATOM_in_name517 = frozenset([1])
    FOLLOW_DATE_in_name530 = frozenset([1])
    FOLLOW_NUMBER_in_name543 = frozenset([1])
    FOLLOW_GEO_in_name556 = frozenset([1])
    FOLLOW_GEOPOINT_in_name569 = frozenset([1])
    FOLLOW_set_in_num0 = frozenset([1])
    FOLLOW_PHRASE_in_str606 = frozenset([1])
    FOLLOW_fnName_in_fn619 = frozenset([21])
    FOLLOW_LPAREN_in_fn621 = frozenset([10, 18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_condExpr_in_fn623 = frozenset([22, 36])
    FOLLOW_COMMA_in_fn626 = frozenset([10, 18, 21, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 43, 44, 45])
    FOLLOW_condExpr_in_fn628 = frozenset([22, 36])
    FOLLOW_RPAREN_in_fn632 = frozenset([1])
    FOLLOW_set_in_fnName0 = frozenset([1])


def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
    from google.appengine._internal.antlr3.main import ParserMain
    main = ParserMain("ExpressionLexer", ExpressionParser)
    main.stdin = stdin
    main.stdout = stdout
    main.stderr = stderr
    main.execute(argv)


if __name__ == '__main__':
    main(sys.argv)