# Generated from ../eoq3.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,27,182,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,
        6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,
        2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,
        7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,
        1,0,1,0,1,0,5,0,58,8,0,10,0,12,0,61,9,0,1,0,3,0,64,8,0,1,1,5,1,67,
        8,1,10,1,12,1,70,9,1,1,1,1,1,1,1,5,1,75,8,1,10,1,12,1,78,9,1,1,1,
        3,1,81,8,1,1,2,1,2,1,3,1,3,1,3,1,3,1,4,1,4,1,4,3,4,92,8,4,1,5,1,
        5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,104,8,5,1,6,1,6,1,7,1,7,1,
        8,1,8,1,9,1,9,1,10,1,10,1,11,1,11,1,12,1,12,1,13,1,13,3,13,122,8,
        13,1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,3,18,134,8,
        18,1,18,1,18,5,18,138,8,18,10,18,12,18,141,9,18,1,18,1,18,1,19,1,
        19,1,19,5,19,148,8,19,10,19,12,19,151,9,19,1,19,1,19,1,20,1,20,3,
        20,157,8,20,1,20,1,20,5,20,161,8,20,10,20,12,20,164,9,20,1,21,1,
        21,3,21,168,8,21,1,22,1,22,3,22,172,8,22,1,23,1,23,1,24,1,24,1,25,
        1,25,1,26,1,26,1,26,0,0,27,0,2,4,6,8,10,12,14,16,18,20,22,24,26,
        28,30,32,34,36,38,40,42,44,46,48,50,52,0,1,2,0,13,13,16,18,178,0,
        54,1,0,0,0,2,68,1,0,0,0,4,82,1,0,0,0,6,84,1,0,0,0,8,91,1,0,0,0,10,
        103,1,0,0,0,12,105,1,0,0,0,14,107,1,0,0,0,16,109,1,0,0,0,18,111,
        1,0,0,0,20,113,1,0,0,0,22,115,1,0,0,0,24,117,1,0,0,0,26,121,1,0,
        0,0,28,123,1,0,0,0,30,125,1,0,0,0,32,127,1,0,0,0,34,129,1,0,0,0,
        36,131,1,0,0,0,38,144,1,0,0,0,40,154,1,0,0,0,42,167,1,0,0,0,44,171,
        1,0,0,0,46,173,1,0,0,0,48,175,1,0,0,0,50,177,1,0,0,0,52,179,1,0,
        0,0,54,59,3,2,1,0,55,56,5,15,0,0,56,58,3,2,1,0,57,55,1,0,0,0,58,
        61,1,0,0,0,59,57,1,0,0,0,59,60,1,0,0,0,60,63,1,0,0,0,61,59,1,0,0,
        0,62,64,5,15,0,0,63,62,1,0,0,0,63,64,1,0,0,0,64,1,1,0,0,0,65,67,
        5,12,0,0,66,65,1,0,0,0,67,70,1,0,0,0,68,66,1,0,0,0,68,69,1,0,0,0,
        69,71,1,0,0,0,70,68,1,0,0,0,71,76,5,13,0,0,72,73,5,14,0,0,73,75,
        3,4,2,0,74,72,1,0,0,0,75,78,1,0,0,0,76,74,1,0,0,0,76,77,1,0,0,0,
        77,80,1,0,0,0,78,76,1,0,0,0,79,81,3,6,3,0,80,79,1,0,0,0,80,81,1,
        0,0,0,81,3,1,0,0,0,82,83,3,8,4,0,83,5,1,0,0,0,84,85,5,1,0,0,85,86,
        3,46,23,0,86,87,3,26,13,0,87,7,1,0,0,0,88,92,3,10,5,0,89,92,3,38,
        19,0,90,92,3,36,18,0,91,88,1,0,0,0,91,89,1,0,0,0,91,90,1,0,0,0,92,
        9,1,0,0,0,93,104,3,12,6,0,94,104,3,14,7,0,95,104,3,16,8,0,96,104,
        3,18,9,0,97,104,3,20,10,0,98,104,3,22,11,0,99,104,3,24,12,0,100,
        104,3,32,16,0,101,104,3,34,17,0,102,104,3,26,13,0,103,93,1,0,0,0,
        103,94,1,0,0,0,103,95,1,0,0,0,103,96,1,0,0,0,103,97,1,0,0,0,103,
        98,1,0,0,0,103,99,1,0,0,0,103,100,1,0,0,0,103,101,1,0,0,0,103,102,
        1,0,0,0,104,11,1,0,0,0,105,106,5,20,0,0,106,13,1,0,0,0,107,108,5,
        21,0,0,108,15,1,0,0,0,109,110,5,22,0,0,110,17,1,0,0,0,111,112,5,
        23,0,0,112,19,1,0,0,0,113,114,5,24,0,0,114,21,1,0,0,0,115,116,5,
        25,0,0,116,23,1,0,0,0,117,118,5,26,0,0,118,25,1,0,0,0,119,122,3,
        28,14,0,120,122,3,30,15,0,121,119,1,0,0,0,121,120,1,0,0,0,122,27,
        1,0,0,0,123,124,7,0,0,0,124,29,1,0,0,0,125,126,5,8,0,0,126,31,1,
        0,0,0,127,128,5,27,0,0,128,33,1,0,0,0,129,130,5,19,0,0,130,35,1,
        0,0,0,131,133,5,2,0,0,132,134,3,8,4,0,133,132,1,0,0,0,133,134,1,
        0,0,0,134,139,1,0,0,0,135,136,5,3,0,0,136,138,3,8,4,0,137,135,1,
        0,0,0,138,141,1,0,0,0,139,137,1,0,0,0,139,140,1,0,0,0,140,142,1,
        0,0,0,141,139,1,0,0,0,142,143,5,4,0,0,143,37,1,0,0,0,144,145,5,5,
        0,0,145,149,3,40,20,0,146,148,3,40,20,0,147,146,1,0,0,0,148,151,
        1,0,0,0,149,147,1,0,0,0,149,150,1,0,0,0,150,152,1,0,0,0,151,149,
        1,0,0,0,152,153,5,6,0,0,153,39,1,0,0,0,154,156,3,42,21,0,155,157,
        3,52,26,0,156,155,1,0,0,0,156,157,1,0,0,0,157,162,1,0,0,0,158,159,
        5,7,0,0,159,161,3,52,26,0,160,158,1,0,0,0,161,164,1,0,0,0,162,160,
        1,0,0,0,162,163,1,0,0,0,163,41,1,0,0,0,164,162,1,0,0,0,165,168,3,
        44,22,0,166,168,3,50,25,0,167,165,1,0,0,0,167,166,1,0,0,0,168,43,
        1,0,0,0,169,172,3,46,23,0,170,172,3,48,24,0,171,169,1,0,0,0,171,
        170,1,0,0,0,172,45,1,0,0,0,173,174,5,10,0,0,174,47,1,0,0,0,175,176,
        5,11,0,0,176,49,1,0,0,0,177,178,5,9,0,0,178,51,1,0,0,0,179,180,3,
        8,4,0,180,53,1,0,0,0,15,59,63,68,76,80,91,103,121,133,139,149,156,
        162,167,171
    ]

class eoq3Parser ( Parser ):

    grammarFileName = "eoq3.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>", "'n0'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "STR_QUOTE", "QRY_FULL", "QRY_SHORT_HIS", "QRY_SHORT_OTH", 
                      "CMD_INDENT", "CMD_ID", "CMD_ARG_SEP", "CMD_SEP", 
                      "STR_SIMPLE_1", "STR_SIMPLE_2", "STR_SIMPLE_3", "NONE", 
                      "BOOL", "UINT32", "UINT64", "INT32", "INT64", "FLOAT32", 
                      "FLOAT64", "DATETIME" ]

    RULE_cmds = 0
    RULE_cmd = 1
    RULE_cmd_arg = 2
    RULE_cmd_res_name = 3
    RULE_val = 4
    RULE_val_prim = 5
    RULE_val_bol = 6
    RULE_val_u32 = 7
    RULE_val_u64 = 8
    RULE_val_i32 = 9
    RULE_val_i64 = 10
    RULE_val_f32 = 11
    RULE_val_f64 = 12
    RULE_val_str = 13
    RULE_val_str_simple = 14
    RULE_val_str_quote = 15
    RULE_val_dat = 16
    RULE_val_non = 17
    RULE_val_lst = 18
    RULE_val_qry = 19
    RULE_qry_seg = 20
    RULE_qry_sym = 21
    RULE_qry_sym_short = 22
    RULE_qry_sym_his = 23
    RULE_qry_sym_other = 24
    RULE_qry_sym_full = 25
    RULE_qry_arg = 26

    ruleNames =  [ "cmds", "cmd", "cmd_arg", "cmd_res_name", "val", "val_prim", 
                   "val_bol", "val_u32", "val_u64", "val_i32", "val_i64", 
                   "val_f32", "val_f64", "val_str", "val_str_simple", "val_str_quote", 
                   "val_dat", "val_non", "val_lst", "val_qry", "qry_seg", 
                   "qry_sym", "qry_sym_short", "qry_sym_his", "qry_sym_other", 
                   "qry_sym_full", "qry_arg" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    STR_QUOTE=8
    QRY_FULL=9
    QRY_SHORT_HIS=10
    QRY_SHORT_OTH=11
    CMD_INDENT=12
    CMD_ID=13
    CMD_ARG_SEP=14
    CMD_SEP=15
    STR_SIMPLE_1=16
    STR_SIMPLE_2=17
    STR_SIMPLE_3=18
    NONE=19
    BOOL=20
    UINT32=21
    UINT64=22
    INT32=23
    INT64=24
    FLOAT32=25
    FLOAT64=26
    DATETIME=27

    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 CmdsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def cmd(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(eoq3Parser.CmdContext)
            else:
                return self.getTypedRuleContext(eoq3Parser.CmdContext,i)


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

        def getRuleIndex(self):
            return eoq3Parser.RULE_cmds

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

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




    def cmds(self):

        localctx = eoq3Parser.CmdsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_cmds)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 54
            self.cmd()
            self.state = 59
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 55
                    self.match(eoq3Parser.CMD_SEP)
                    self.state = 56
                    self.cmd() 
                self.state = 61
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,0,self._ctx)

            self.state = 63
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==15:
                self.state = 62
                self.match(eoq3Parser.CMD_SEP)


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


    class CmdContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CMD_ID(self):
            return self.getToken(eoq3Parser.CMD_ID, 0)

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

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

        def cmd_arg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(eoq3Parser.Cmd_argContext)
            else:
                return self.getTypedRuleContext(eoq3Parser.Cmd_argContext,i)


        def cmd_res_name(self):
            return self.getTypedRuleContext(eoq3Parser.Cmd_res_nameContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_cmd

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

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




    def cmd(self):

        localctx = eoq3Parser.CmdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_cmd)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 68
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==12:
                self.state = 65
                self.match(eoq3Parser.CMD_INDENT)
                self.state = 70
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 71
            self.match(eoq3Parser.CMD_ID)
            self.state = 76
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==14:
                self.state = 72
                self.match(eoq3Parser.CMD_ARG_SEP)
                self.state = 73
                self.cmd_arg()
                self.state = 78
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 80
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==1:
                self.state = 79
                self.cmd_res_name()


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


    class Cmd_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def val(self):
            return self.getTypedRuleContext(eoq3Parser.ValContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_cmd_arg

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

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




    def cmd_arg(self):

        localctx = eoq3Parser.Cmd_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_cmd_arg)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 82
            self.val()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Cmd_res_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qry_sym_his(self):
            return self.getTypedRuleContext(eoq3Parser.Qry_sym_hisContext,0)


        def val_str(self):
            return self.getTypedRuleContext(eoq3Parser.Val_strContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_cmd_res_name

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

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




    def cmd_res_name(self):

        localctx = eoq3Parser.Cmd_res_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_cmd_res_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 84
            self.match(eoq3Parser.T__0)
            self.state = 85
            self.qry_sym_his()
            self.state = 86
            self.val_str()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ValContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def val_prim(self):
            return self.getTypedRuleContext(eoq3Parser.Val_primContext,0)


        def val_qry(self):
            return self.getTypedRuleContext(eoq3Parser.Val_qryContext,0)


        def val_lst(self):
            return self.getTypedRuleContext(eoq3Parser.Val_lstContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_val

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

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




    def val(self):

        localctx = eoq3Parser.ValContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_val)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 91
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [8, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]:
                self.state = 88
                self.val_prim()
                pass
            elif token in [5]:
                self.state = 89
                self.val_qry()
                pass
            elif token in [2]:
                self.state = 90
                self.val_lst()
                pass
            else:
                raise NoViableAltException(self)

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


    class Val_primContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def val_bol(self):
            return self.getTypedRuleContext(eoq3Parser.Val_bolContext,0)


        def val_u32(self):
            return self.getTypedRuleContext(eoq3Parser.Val_u32Context,0)


        def val_u64(self):
            return self.getTypedRuleContext(eoq3Parser.Val_u64Context,0)


        def val_i32(self):
            return self.getTypedRuleContext(eoq3Parser.Val_i32Context,0)


        def val_i64(self):
            return self.getTypedRuleContext(eoq3Parser.Val_i64Context,0)


        def val_f32(self):
            return self.getTypedRuleContext(eoq3Parser.Val_f32Context,0)


        def val_f64(self):
            return self.getTypedRuleContext(eoq3Parser.Val_f64Context,0)


        def val_dat(self):
            return self.getTypedRuleContext(eoq3Parser.Val_datContext,0)


        def val_non(self):
            return self.getTypedRuleContext(eoq3Parser.Val_nonContext,0)


        def val_str(self):
            return self.getTypedRuleContext(eoq3Parser.Val_strContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_val_prim

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

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




    def val_prim(self):

        localctx = eoq3Parser.Val_primContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_val_prim)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 103
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [20]:
                self.state = 93
                self.val_bol()
                pass
            elif token in [21]:
                self.state = 94
                self.val_u32()
                pass
            elif token in [22]:
                self.state = 95
                self.val_u64()
                pass
            elif token in [23]:
                self.state = 96
                self.val_i32()
                pass
            elif token in [24]:
                self.state = 97
                self.val_i64()
                pass
            elif token in [25]:
                self.state = 98
                self.val_f32()
                pass
            elif token in [26]:
                self.state = 99
                self.val_f64()
                pass
            elif token in [27]:
                self.state = 100
                self.val_dat()
                pass
            elif token in [19]:
                self.state = 101
                self.val_non()
                pass
            elif token in [8, 13, 16, 17, 18]:
                self.state = 102
                self.val_str()
                pass
            else:
                raise NoViableAltException(self)

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


    class Val_bolContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_bol

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

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




    def val_bol(self):

        localctx = eoq3Parser.Val_bolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_val_bol)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 105
            self.match(eoq3Parser.BOOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_u32Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def UINT32(self):
            return self.getToken(eoq3Parser.UINT32, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_u32

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

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




    def val_u32(self):

        localctx = eoq3Parser.Val_u32Context(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_val_u32)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 107
            self.match(eoq3Parser.UINT32)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_u64Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def UINT64(self):
            return self.getToken(eoq3Parser.UINT64, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_u64

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

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




    def val_u64(self):

        localctx = eoq3Parser.Val_u64Context(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_val_u64)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 109
            self.match(eoq3Parser.UINT64)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_i32Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def INT32(self):
            return self.getToken(eoq3Parser.INT32, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_i32

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

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




    def val_i32(self):

        localctx = eoq3Parser.Val_i32Context(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_val_i32)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 111
            self.match(eoq3Parser.INT32)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_i64Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def INT64(self):
            return self.getToken(eoq3Parser.INT64, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_i64

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

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




    def val_i64(self):

        localctx = eoq3Parser.Val_i64Context(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_val_i64)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 113
            self.match(eoq3Parser.INT64)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_f32Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def FLOAT32(self):
            return self.getToken(eoq3Parser.FLOAT32, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_f32

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

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




    def val_f32(self):

        localctx = eoq3Parser.Val_f32Context(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_val_f32)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 115
            self.match(eoq3Parser.FLOAT32)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_f64Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def FLOAT64(self):
            return self.getToken(eoq3Parser.FLOAT64, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_f64

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

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




    def val_f64(self):

        localctx = eoq3Parser.Val_f64Context(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_val_f64)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 117
            self.match(eoq3Parser.FLOAT64)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_strContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def val_str_simple(self):
            return self.getTypedRuleContext(eoq3Parser.Val_str_simpleContext,0)


        def val_str_quote(self):
            return self.getTypedRuleContext(eoq3Parser.Val_str_quoteContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_val_str

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

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




    def val_str(self):

        localctx = eoq3Parser.Val_strContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_val_str)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 121
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [13, 16, 17, 18]:
                self.state = 119
                self.val_str_simple()
                pass
            elif token in [8]:
                self.state = 120
                self.val_str_quote()
                pass
            else:
                raise NoViableAltException(self)

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


    class Val_str_simpleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def STR_SIMPLE_1(self):
            return self.getToken(eoq3Parser.STR_SIMPLE_1, 0)

        def STR_SIMPLE_2(self):
            return self.getToken(eoq3Parser.STR_SIMPLE_2, 0)

        def STR_SIMPLE_3(self):
            return self.getToken(eoq3Parser.STR_SIMPLE_3, 0)

        def CMD_ID(self):
            return self.getToken(eoq3Parser.CMD_ID, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_str_simple

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

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




    def val_str_simple(self):

        localctx = eoq3Parser.Val_str_simpleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_val_str_simple)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 123
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 466944) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_str_quoteContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def STR_QUOTE(self):
            return self.getToken(eoq3Parser.STR_QUOTE, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_str_quote

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

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




    def val_str_quote(self):

        localctx = eoq3Parser.Val_str_quoteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_val_str_quote)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 125
            self.match(eoq3Parser.STR_QUOTE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_datContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DATETIME(self):
            return self.getToken(eoq3Parser.DATETIME, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_dat

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

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




    def val_dat(self):

        localctx = eoq3Parser.Val_datContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_val_dat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 127
            self.match(eoq3Parser.DATETIME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_nonContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NONE(self):
            return self.getToken(eoq3Parser.NONE, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_val_non

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

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




    def val_non(self):

        localctx = eoq3Parser.Val_nonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_val_non)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 129
            self.match(eoq3Parser.NONE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_lstContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def val(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(eoq3Parser.ValContext)
            else:
                return self.getTypedRuleContext(eoq3Parser.ValContext,i)


        def getRuleIndex(self):
            return eoq3Parser.RULE_val_lst

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

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




    def val_lst(self):

        localctx = eoq3Parser.Val_lstContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_val_lst)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 131
            self.match(eoq3Parser.T__1)
            self.state = 133
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 268378404) != 0):
                self.state = 132
                self.val()


            self.state = 139
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==3:
                self.state = 135
                self.match(eoq3Parser.T__2)
                self.state = 136
                self.val()
                self.state = 141
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 142
            self.match(eoq3Parser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Val_qryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qry_seg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(eoq3Parser.Qry_segContext)
            else:
                return self.getTypedRuleContext(eoq3Parser.Qry_segContext,i)


        def getRuleIndex(self):
            return eoq3Parser.RULE_val_qry

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

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




    def val_qry(self):

        localctx = eoq3Parser.Val_qryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_val_qry)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 144
            self.match(eoq3Parser.T__4)
            self.state = 145
            self.qry_seg()
            self.state = 149
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3584) != 0):
                self.state = 146
                self.qry_seg()
                self.state = 151
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 152
            self.match(eoq3Parser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qry_segContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qry_sym(self):
            return self.getTypedRuleContext(eoq3Parser.Qry_symContext,0)


        def qry_arg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(eoq3Parser.Qry_argContext)
            else:
                return self.getTypedRuleContext(eoq3Parser.Qry_argContext,i)


        def getRuleIndex(self):
            return eoq3Parser.RULE_qry_seg

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

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




    def qry_seg(self):

        localctx = eoq3Parser.Qry_segContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_qry_seg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 154
            self.qry_sym()
            self.state = 156
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 268378404) != 0):
                self.state = 155
                self.qry_arg()


            self.state = 162
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==7:
                self.state = 158
                self.match(eoq3Parser.T__6)
                self.state = 159
                self.qry_arg()
                self.state = 164
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Qry_symContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qry_sym_short(self):
            return self.getTypedRuleContext(eoq3Parser.Qry_sym_shortContext,0)


        def qry_sym_full(self):
            return self.getTypedRuleContext(eoq3Parser.Qry_sym_fullContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_qry_sym

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

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




    def qry_sym(self):

        localctx = eoq3Parser.Qry_symContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_qry_sym)
        try:
            self.state = 167
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [10, 11]:
                self.enterOuterAlt(localctx, 1)
                self.state = 165
                self.qry_sym_short()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 166
                self.qry_sym_full()
                pass
            else:
                raise NoViableAltException(self)

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


    class Qry_sym_shortContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qry_sym_his(self):
            return self.getTypedRuleContext(eoq3Parser.Qry_sym_hisContext,0)


        def qry_sym_other(self):
            return self.getTypedRuleContext(eoq3Parser.Qry_sym_otherContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_qry_sym_short

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

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




    def qry_sym_short(self):

        localctx = eoq3Parser.Qry_sym_shortContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_qry_sym_short)
        try:
            self.state = 171
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [10]:
                self.enterOuterAlt(localctx, 1)
                self.state = 169
                self.qry_sym_his()
                pass
            elif token in [11]:
                self.enterOuterAlt(localctx, 2)
                self.state = 170
                self.qry_sym_other()
                pass
            else:
                raise NoViableAltException(self)

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


    class Qry_sym_hisContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def QRY_SHORT_HIS(self):
            return self.getToken(eoq3Parser.QRY_SHORT_HIS, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_qry_sym_his

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

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




    def qry_sym_his(self):

        localctx = eoq3Parser.Qry_sym_hisContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_qry_sym_his)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 173
            self.match(eoq3Parser.QRY_SHORT_HIS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qry_sym_otherContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def QRY_SHORT_OTH(self):
            return self.getToken(eoq3Parser.QRY_SHORT_OTH, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_qry_sym_other

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

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




    def qry_sym_other(self):

        localctx = eoq3Parser.Qry_sym_otherContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_qry_sym_other)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 175
            self.match(eoq3Parser.QRY_SHORT_OTH)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qry_sym_fullContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def QRY_FULL(self):
            return self.getToken(eoq3Parser.QRY_FULL, 0)

        def getRuleIndex(self):
            return eoq3Parser.RULE_qry_sym_full

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

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




    def qry_sym_full(self):

        localctx = eoq3Parser.Qry_sym_fullContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_qry_sym_full)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 177
            self.match(eoq3Parser.QRY_FULL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qry_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def val(self):
            return self.getTypedRuleContext(eoq3Parser.ValContext,0)


        def getRuleIndex(self):
            return eoq3Parser.RULE_qry_arg

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

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




    def qry_arg(self):

        localctx = eoq3Parser.Qry_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_qry_arg)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 179
            self.val()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





