# Generated from eva/parser/evaql/evaql_parser.g4 by ANTLR 4.8
# 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():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00a6")
        buf.write("\u0429\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\3\2\5\2\u00c6\n\2\3\2\5\2\u00c9")
        buf.write("\n\2\3\2\3\2\3\3\3\3\5\3\u00cf\n\3\3\3\3\3\3\3\7\3\u00d4")
        buf.write("\n\3\f\3\16\3\u00d7\13\3\3\3\3\3\5\3\u00db\n\3\3\3\5\3")
        buf.write("\u00de\n\3\3\3\5\3\u00e1\n\3\3\4\3\4\3\4\5\4\u00e6\n\4")
        buf.write("\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00f1\n\6\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\5\7\u00f9\n\7\3\b\3\b\5\b\u00fd\n")
        buf.write("\b\3\t\3\t\3\t\5\t\u0102\n\t\3\t\3\t\3\n\3\n\3\n\3\n\5")
        buf.write("\n\u010a\n\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\5\13\u0113")
        buf.write("\n\13\3\13\3\13\3\13\3\f\3\f\3\f\5\f\u011b\n\f\3\f\3\f")
        buf.write("\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17")
        buf.write("\3\17\3\20\3\20\3\20\3\21\3\21\3\21\3\21\7\21\u0134\n")
        buf.write("\21\f\21\16\21\u0137\13\21\3\21\3\21\3\22\3\22\3\22\3")
        buf.write("\22\5\22\u013f\n\22\3\23\3\23\7\23\u0143\n\23\f\23\16")
        buf.write("\23\u0146\13\23\3\24\3\24\3\24\3\24\5\24\u014c\n\24\3")
        buf.write("\24\3\24\3\24\5\24\u0151\n\24\5\24\u0153\n\24\3\25\3\25")
        buf.write("\5\25\u0157\n\25\3\25\5\25\u015a\n\25\3\25\3\25\3\26\3")
        buf.write("\26\3\26\5\26\u0161\n\26\3\26\3\26\3\27\3\27\3\27\3\27")
        buf.write("\3\27\3\27\3\30\3\30\3\30\5\30\u016e\n\30\3\30\3\30\3")
        buf.write("\31\3\31\3\32\3\32\5\32\u0176\n\32\3\32\3\32\3\32\3\32")
        buf.write("\3\32\5\32\u017d\n\32\3\32\3\32\3\33\3\33\3\33\3\33\3")
        buf.write("\33\3\33\5\33\u0187\n\33\3\33\7\33\u018a\n\33\f\33\16")
        buf.write("\33\u018d\13\33\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35")
        buf.write("\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3 \3 \3")
        buf.write("!\3!\3!\3!\3!\3!\3!\3!\3!\3!\7!\u01ac\n!\f!\16!\u01af")
        buf.write("\13!\5!\u01b1\n!\3\"\3\"\3\"\3\"\5\"\u01b7\n\"\3#\3#\3")
        buf.write("#\3#\3#\5#\u01be\n#\3#\5#\u01c1\n#\3#\3#\5#\u01c5\n#\3")
        buf.write("$\3$\3$\5$\u01ca\n$\3$\5$\u01cd\n$\3$\3$\3$\3$\7$\u01d3")
        buf.write("\n$\f$\16$\u01d6\13$\3$\3$\5$\u01da\n$\3$\5$\u01dd\n$")
        buf.write("\3$\5$\u01e0\n$\3%\3%\3%\3%\3%\7%\u01e7\n%\f%\16%\u01ea")
        buf.write("\13%\3&\3&\5&\u01ee\n&\3\'\3\'\3\'\7\'\u01f3\n\'\f\'\16")
        buf.write("\'\u01f6\13\'\3(\3(\7(\u01fa\n(\f(\16(\u01fd\13(\3)\3")
        buf.write(")\5)\u0201\n)\3*\3*\3*\3*\3*\3*\5*\u0209\n*\5*\u020b\n")
        buf.write("*\3+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3,\5,\u0219\n,\3-\3")
        buf.write("-\3-\3-\3-\3-\3-\3-\5-\u0223\n-\3.\3.\3.\3.\5.\u0229\n")
        buf.write(".\3.\5.\u022c\n.\3.\5.\u022f\n.\3.\5.\u0232\n.\3/\3/\5")
        buf.write("/\u0236\n/\3/\3/\7/\u023a\n/\f/\16/\u023d\13/\3\60\3\60")
        buf.write("\3\60\3\60\3\60\3\60\5\60\u0245\n\60\3\60\5\60\u0248\n")
        buf.write("\60\3\60\3\60\5\60\u024c\n\60\3\60\5\60\u024f\n\60\3\60")
        buf.write("\3\60\5\60\u0253\n\60\3\60\3\60\5\60\u0257\n\60\3\60\5")
        buf.write("\60\u025a\n\60\5\60\u025c\n\60\3\61\3\61\3\61\3\61\5\61")
        buf.write("\u0262\n\61\3\61\3\61\3\61\3\61\3\61\7\61\u0269\n\61\f")
        buf.write("\61\16\61\u026c\13\61\5\61\u026e\n\61\3\61\3\61\5\61\u0272")
        buf.write("\n\61\3\62\3\62\5\62\u0276\n\62\3\63\3\63\3\63\3\63\5")
        buf.write("\63\u027c\n\63\3\63\3\63\3\63\3\63\3\63\5\63\u0283\n\63")
        buf.write("\3\64\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\67\3\67\3\67")
        buf.write("\38\38\38\39\39\39\39\59\u0297\n9\3:\3:\3;\3;\3;\5;\u029e")
        buf.write("\n;\5;\u02a0\n;\3<\3<\3<\3<\3<\5<\u02a7\n<\3<\5<\u02aa")
        buf.write("\n<\3=\3=\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\6")
        buf.write(">\u02bc\n>\r>\16>\u02bd\3?\3?\5?\u02c2\n?\3@\3@\3A\3A")
        buf.write("\3A\5A\u02c9\nA\3B\3B\3C\3C\3D\3D\3E\5E\u02d2\nE\3E\3")
        buf.write("E\3F\3F\3F\3F\7F\u02da\nF\fF\16F\u02dd\13F\3F\3F\3F\3")
        buf.write("F\5F\u02e3\nF\3G\3G\3G\3G\3G\3G\3G\5G\u02ec\nG\3G\3G\5")
        buf.write("G\u02f0\nG\3H\3H\3I\3I\3I\5I\u02f7\nI\3I\3I\5I\u02fb\n")
        buf.write("I\3I\3I\5I\u02ff\nI\3I\5I\u0302\nI\3I\3I\5I\u0306\nI\3")
        buf.write("I\5I\u0309\nI\3I\5I\u030c\nI\3J\3J\3J\3J\3K\3K\3K\3K\3")
        buf.write("K\3K\3L\3L\3L\3L\7L\u031c\nL\fL\16L\u031f\13L\3L\3L\3")
        buf.write("L\3M\3M\3M\7M\u0327\nM\fM\16M\u032a\13M\3N\3N\3N\7N\u032f")
        buf.write("\nN\fN\16N\u0332\13N\3O\3O\3O\3O\7O\u0338\nO\fO\16O\u033b")
        buf.write("\13O\3O\3O\3P\3P\3P\7P\u0342\nP\fP\16P\u0345\13P\3Q\3")
        buf.write("Q\3Q\7Q\u034a\nQ\fQ\16Q\u034d\13Q\3R\3R\5R\u0351\nR\3")
        buf.write("S\3S\5S\u0355\nS\3T\3T\3T\3U\3U\3U\3U\3V\3V\5V\u0360\n")
        buf.write("V\3W\3W\3W\3W\3W\5W\u0367\nW\3X\3X\3X\5X\u036c\nX\3X\3")
        buf.write("X\3X\3X\3X\3X\3X\5X\u0375\nX\3X\5X\u0378\nX\3X\5X\u037b")
        buf.write("\nX\3Y\3Y\3Y\3Y\5Y\u0381\nY\3Y\3Y\3Y\3Y\3Y\5Y\u0388\n")
        buf.write("Y\7Y\u038a\nY\fY\16Y\u038d\13Y\3Z\3Z\3Z\3Z\5Z\u0393\n")
        buf.write("Z\3[\3[\3[\3[\3[\3[\5[\u039b\n[\3[\3[\3[\5[\u03a0\n[\3")
        buf.write("[\3[\3[\3[\7[\u03a6\n[\f[\16[\u03a9\13[\3\\\3\\\3\\\5")
        buf.write("\\\u03ae\n\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\\u03b8")
        buf.write("\n\\\3\\\3\\\3\\\3\\\5\\\u03be\n\\\3\\\3\\\3\\\3\\\3\\")
        buf.write("\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\\u03ce\n\\\3\\")
        buf.write("\3\\\3\\\5\\\u03d3\n\\\7\\\u03d5\n\\\f\\\16\\\u03d8\13")
        buf.write("\\\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\7]\u03e5\n]\f]\16")
        buf.write("]\u03e8\13]\3]\3]\3]\3]\3]\3]\5]\u03f0\n]\3]\3]\3]\3]")
        buf.write("\3]\3]\3]\3]\7]\u03fa\n]\f]\16]\u03fd\13]\3^\3^\3_\3_")
        buf.write("\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\5_\u0413")
        buf.write("\n_\3`\3`\3`\3`\3`\3`\3`\5`\u041c\n`\3a\3a\3a\3a\3a\3")
        buf.write("a\3a\5a\u0425\na\3b\3b\3b\2\6\64\u00b4\u00b6\u00b8c\2")
        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
        buf.write("\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084")
        buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096")
        buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8")
        buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba")
        buf.write("\u00bc\u00be\u00c0\u00c2\2\21\3\2LM\4\2GGmm\4\2\r\r\26")
        buf.write("\26\4\2\u00a1\u00a1\u00a3\u00a3\5\2\13\13\u0095\u0097")
        buf.write("\u009d\u009d\4\2\35\35>>\4\2\60\60\u009f\u009f\3\2Ua\5")
        buf.write("\2bbdegg\4\2\7\7\30\30\4\2//\u0088\u0088\5\2\35\35>>A")
        buf.write("A\5\2\7\7\n\n<<\6\2//\u0080\u0080\u0082\u0082\u0088\u0089")
        buf.write("\3\2}\u0084\2\u047b\2\u00c5\3\2\2\2\4\u00d5\3\2\2\2\6")
        buf.write("\u00e5\3\2\2\2\b\u00e7\3\2\2\2\n\u00f0\3\2\2\2\f\u00f8")
        buf.write("\3\2\2\2\16\u00fc\3\2\2\2\20\u00fe\3\2\2\2\22\u0105\3")
        buf.write("\2\2\2\24\u010f\3\2\2\2\26\u0117\3\2\2\2\30\u0126\3\2")
        buf.write("\2\2\32\u0128\3\2\2\2\34\u012a\3\2\2\2\36\u012c\3\2\2")
        buf.write("\2 \u012f\3\2\2\2\"\u013e\3\2\2\2$\u0140\3\2\2\2&\u0152")
        buf.write("\3\2\2\2(\u0154\3\2\2\2*\u015d\3\2\2\2,\u0164\3\2\2\2")
        buf.write(".\u016a\3\2\2\2\60\u0171\3\2\2\2\62\u0173\3\2\2\2\64\u0180")
        buf.write("\3\2\2\2\66\u018e\3\2\2\28\u0190\3\2\2\2:\u0197\3\2\2")
        buf.write("\2<\u019d\3\2\2\2>\u019f\3\2\2\2@\u01b0\3\2\2\2B\u01b2")
        buf.write("\3\2\2\2D\u01b8\3\2\2\2F\u01c6\3\2\2\2H\u01e1\3\2\2\2")
        buf.write("J\u01eb\3\2\2\2L\u01ef\3\2\2\2N\u01f7\3\2\2\2P\u01fe\3")
        buf.write("\2\2\2R\u020a\3\2\2\2T\u020c\3\2\2\2V\u020f\3\2\2\2X\u0222")
        buf.write("\3\2\2\2Z\u0224\3\2\2\2\\\u0235\3\2\2\2^\u025b\3\2\2\2")
        buf.write("`\u025d\3\2\2\2b\u0273\3\2\2\2d\u0277\3\2\2\2f\u0284\3")
        buf.write("\2\2\2h\u0287\3\2\2\2j\u028a\3\2\2\2l\u028c\3\2\2\2n\u028f")
        buf.write("\3\2\2\2p\u0292\3\2\2\2r\u0298\3\2\2\2t\u029a\3\2\2\2")
        buf.write("v\u02a1\3\2\2\2x\u02ab\3\2\2\2z\u02ad\3\2\2\2|\u02c1\3")
        buf.write("\2\2\2~\u02c3\3\2\2\2\u0080\u02c8\3\2\2\2\u0082\u02ca")
        buf.write("\3\2\2\2\u0084\u02cc\3\2\2\2\u0086\u02ce\3\2\2\2\u0088")
        buf.write("\u02d1\3\2\2\2\u008a\u02e2\3\2\2\2\u008c\u02ef\3\2\2\2")
        buf.write("\u008e\u02f1\3\2\2\2\u0090\u030b\3\2\2\2\u0092\u030d\3")
        buf.write("\2\2\2\u0094\u0311\3\2\2\2\u0096\u0317\3\2\2\2\u0098\u0323")
        buf.write("\3\2\2\2\u009a\u032b\3\2\2\2\u009c\u0333\3\2\2\2\u009e")
        buf.write("\u033e\3\2\2\2\u00a0\u0346\3\2\2\2\u00a2\u0350\3\2\2\2")
        buf.write("\u00a4\u0354\3\2\2\2\u00a6\u0356\3\2\2\2\u00a8\u0359\3")
        buf.write("\2\2\2\u00aa\u035f\3\2\2\2\u00ac\u0361\3\2\2\2\u00ae\u037a")
        buf.write("\3\2\2\2\u00b0\u0380\3\2\2\2\u00b2\u0392\3\2\2\2\u00b4")
        buf.write("\u039f\3\2\2\2\u00b6\u03aa\3\2\2\2\u00b8\u03ef\3\2\2\2")
        buf.write("\u00ba\u03fe\3\2\2\2\u00bc\u0412\3\2\2\2\u00be\u041b\3")
        buf.write("\2\2\2\u00c0\u0424\3\2\2\2\u00c2\u0426\3\2\2\2\u00c4\u00c6")
        buf.write("\5\4\3\2\u00c5\u00c4\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6")
        buf.write("\u00c8\3\2\2\2\u00c7\u00c9\7\u0081\2\2\u00c8\u00c7\3\2")
        buf.write("\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb")
        buf.write("\7\2\2\3\u00cb\3\3\2\2\2\u00cc\u00ce\5\6\4\2\u00cd\u00cf")
        buf.write("\7\u0081\2\2\u00ce\u00cd\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf")
        buf.write("\u00d0\3\2\2\2\u00d0\u00d1\7\u0093\2\2\u00d1\u00d4\3\2")
        buf.write("\2\2\u00d2\u00d4\5\b\5\2\u00d3\u00cc\3\2\2\2\u00d3\u00d2")
        buf.write("\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5")
        buf.write("\u00d6\3\2\2\2\u00d6\u00e0\3\2\2\2\u00d7\u00d5\3\2\2\2")
        buf.write("\u00d8\u00dd\5\6\4\2\u00d9\u00db\7\u0081\2\2\u00da\u00d9")
        buf.write("\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\3\2\2\2\u00dc")
        buf.write("\u00de\7\u0093\2\2\u00dd\u00da\3\2\2\2\u00dd\u00de\3\2")
        buf.write("\2\2\u00de\u00e1\3\2\2\2\u00df\u00e1\5\b\5\2\u00e0\u00d8")
        buf.write("\3\2\2\2\u00e0\u00df\3\2\2\2\u00e1\5\3\2\2\2\u00e2\u00e6")
        buf.write("\5\n\6\2\u00e3\u00e6\5\f\7\2\u00e4\u00e6\5\16\b\2\u00e5")
        buf.write("\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2")
        buf.write("\u00e6\7\3\2\2\2\u00e7\u00e8\7\u0093\2\2\u00e8\t\3\2\2")
        buf.write("\2\u00e9\u00f1\5\20\t\2\u00ea\u00f1\5\24\13\2\u00eb\u00f1")
        buf.write("\5\22\n\2\u00ec\u00f1\5\26\f\2\u00ed\u00f1\5*\26\2\u00ee")
        buf.write("\u00f1\5.\30\2\u00ef\u00f1\5,\27\2\u00f0\u00e9\3\2\2\2")
        buf.write("\u00f0\u00ea\3\2\2\2\u00f0\u00eb\3\2\2\2\u00f0\u00ec\3")
        buf.write("\2\2\2\u00f0\u00ed\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f0\u00ef")
        buf.write("\3\2\2\2\u00f1\13\3\2\2\2\u00f2\u00f9\5\64\33\2\u00f3")
        buf.write("\u00f9\5\62\32\2\u00f4\u00f9\5\66\34\2\u00f5\u00f9\5\60")
        buf.write("\31\2\u00f6\u00f9\58\35\2\u00f7\u00f9\5:\36\2\u00f8\u00f2")
        buf.write("\3\2\2\2\u00f8\u00f3\3\2\2\2\u00f8\u00f4\3\2\2\2\u00f8")
        buf.write("\u00f5\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8\u00f7\3\2\2\2")
        buf.write("\u00f9\r\3\2\2\2\u00fa\u00fd\5l\67\2\u00fb\u00fd\5n8\2")
        buf.write("\u00fc\u00fa\3\2\2\2\u00fc\u00fb\3\2\2\2\u00fd\17\3\2")
        buf.write("\2\2\u00fe\u00ff\7\21\2\2\u00ff\u0101\7\23\2\2\u0100\u0102")
        buf.write("\5\u00a8U\2\u0101\u0100\3\2\2\2\u0101\u0102\3\2\2\2\u0102")
        buf.write("\u0103\3\2\2\2\u0103\u0104\5|?\2\u0104\21\3\2\2\2\u0105")
        buf.write("\u0106\7\21\2\2\u0106\u0107\7&\2\2\u0107\u0109\5|?\2\u0108")
        buf.write("\u010a\5\36\20\2\u0109\u0108\3\2\2\2\u0109\u010a\3\2\2")
        buf.write("\2\u010a\u010b\3\2\2\2\u010b\u010c\7\62\2\2\u010c\u010d")
        buf.write("\5r:\2\u010d\u010e\5\u009cO\2\u010e\23\3\2\2\2\u010f\u0110")
        buf.write("\7\21\2\2\u0110\u0112\7=\2\2\u0111\u0113\5\u00a8U\2\u0112")
        buf.write("\u0111\3\2\2\2\u0112\u0113\3\2\2\2\u0113\u0114\3\2\2\2")
        buf.write("\u0114\u0115\5r:\2\u0115\u0116\5 \21\2\u0116\25\3\2\2")
        buf.write("\2\u0117\u0118\7\21\2\2\u0118\u011a\7n\2\2\u0119\u011b")
        buf.write("\5\u00a8U\2\u011a\u0119\3\2\2\2\u011a\u011b\3\2\2\2\u011b")
        buf.write("\u011c\3\2\2\2\u011c\u011d\5\30\r\2\u011d\u011e\7o\2\2")
        buf.write("\u011e\u011f\5 \21\2\u011f\u0120\7p\2\2\u0120\u0121\5")
        buf.write(" \21\2\u0121\u0122\7q\2\2\u0122\u0123\5\32\16\2\u0123")
        buf.write("\u0124\7r\2\2\u0124\u0125\5\34\17\2\u0125\27\3\2\2\2\u0126")
        buf.write("\u0127\5|?\2\u0127\31\3\2\2\2\u0128\u0129\5|?\2\u0129")
        buf.write("\33\3\2\2\2\u012a\u012b\5\u0084C\2\u012b\35\3\2\2\2\u012c")
        buf.write("\u012d\7F\2\2\u012d\u012e\t\2\2\2\u012e\37\3\2\2\2\u012f")
        buf.write("\u0130\7\u008e\2\2\u0130\u0135\5\"\22\2\u0131\u0132\7")
        buf.write("\u0092\2\2\u0132\u0134\5\"\22\2\u0133\u0131\3\2\2\2\u0134")
        buf.write("\u0137\3\2\2\2\u0135\u0133\3\2\2\2\u0135\u0136\3\2\2\2")
        buf.write("\u0136\u0138\3\2\2\2\u0137\u0135\3\2\2\2\u0138\u0139\7")
        buf.write("\u008f\2\2\u0139!\3\2\2\2\u013a\u013b\5|?\2\u013b\u013c")
        buf.write("\5$\23\2\u013c\u013f\3\2\2\2\u013d\u013f\5(\25\2\u013e")
        buf.write("\u013a\3\2\2\2\u013e\u013d\3\2\2\2\u013f#\3\2\2\2\u0140")
        buf.write("\u0144\5\u0090I\2\u0141\u0143\5&\24\2\u0142\u0141\3\2")
        buf.write("\2\2\u0143\u0146\3\2\2\2\u0144\u0142\3\2\2\2\u0144\u0145")
        buf.write("\3\2\2\2\u0145%\3\2\2\2\u0146\u0144\3\2\2\2\u0147\u0153")
        buf.write("\5\u0088E\2\u0148\u0149\7\24\2\2\u0149\u0153\5\u00a2R")
        buf.write("\2\u014a\u014c\7\66\2\2\u014b\u014a\3\2\2\2\u014b\u014c")
        buf.write("\3\2\2\2\u014c\u014d\3\2\2\2\u014d\u0153\7*\2\2\u014e")
        buf.write("\u0150\7@\2\2\u014f\u0151\7*\2\2\u0150\u014f\3\2\2\2\u0150")
        buf.write("\u0151\3\2\2\2\u0151\u0153\3\2\2\2\u0152\u0147\3\2\2\2")
        buf.write("\u0152\u0148\3\2\2\2\u0152\u014b\3\2\2\2\u0152\u014e\3")
        buf.write("\2\2\2\u0153\'\3\2\2\2\u0154\u0156\7&\2\2\u0155\u0157")
        buf.write("\5|?\2\u0156\u0155\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u0159")
        buf.write("\3\2\2\2\u0158\u015a\5\36\20\2\u0159\u0158\3\2\2\2\u0159")
        buf.write("\u015a\3\2\2\2\u015a\u015b\3\2\2\2\u015b\u015c\5\u009c")
        buf.write("O\2\u015c)\3\2\2\2\u015d\u015e\7\31\2\2\u015e\u0160\7")
        buf.write("\23\2\2\u015f\u0161\5\u00a6T\2\u0160\u015f\3\2\2\2\u0160")
        buf.write("\u0161\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163\5|?\2\u0163")
        buf.write("+\3\2\2\2\u0164\u0165\7\31\2\2\u0165\u0166\7&\2\2\u0166")
        buf.write("\u0167\5|?\2\u0167\u0168\7\62\2\2\u0168\u0169\5r:\2\u0169")
        buf.write("-\3\2\2\2\u016a\u016b\7\31\2\2\u016b\u016d\7=\2\2\u016c")
        buf.write("\u016e\5\u00a6T\2\u016d\u016c\3\2\2\2\u016d\u016e\3\2")
        buf.write("\2\2\u016e\u016f\3\2\2\2\u016f\u0170\5\u009aN\2\u0170")
        buf.write("/\3\2\2\2\u0171\u0172\5D#\2\u0172\61\3\2\2\2\u0173\u0175")
        buf.write("\7\'\2\2\u0174\u0176\7%\2\2\u0175\u0174\3\2\2\2\u0175")
        buf.write("\u0176\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u017c\5r:\2\u0178")
        buf.write("\u0179\7\u008e\2\2\u0179\u017a\5\u0098M\2\u017a\u017b")
        buf.write("\7\u008f\2\2\u017b\u017d\3\2\2\2\u017c\u0178\3\2\2\2\u017c")
        buf.write("\u017d\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u017f\5@!\2\u017f")
        buf.write("\63\3\2\2\2\u0180\u0181\b\33\1\2\u0181\u0182\5Z.\2\u0182")
        buf.write("\u018b\3\2\2\2\u0183\u0184\f\3\2\2\u0184\u0186\7?\2\2")
        buf.write("\u0185\u0187\7\7\2\2\u0186\u0185\3\2\2\2\u0186\u0187\3")
        buf.write("\2\2\2\u0187\u0188\3\2\2\2\u0188\u018a\5\64\33\4\u0189")
        buf.write("\u0183\3\2\2\2\u018a\u018d\3\2\2\2\u018b\u0189\3\2\2\2")
        buf.write("\u018b\u018c\3\2\2\2\u018c\65\3\2\2\2\u018d\u018b\3\2")
        buf.write("\2\2\u018e\u018f\5F$\2\u018f\67\3\2\2\2\u0190\u0191\7")
        buf.write("-\2\2\u0191\u0192\7\22\2\2\u0192\u0193\7#\2\2\u0193\u0194")
        buf.write("\5<\37\2\u0194\u0195\7%\2\2\u0195\u0196\5r:\2\u01969\3")
        buf.write("\2\2\2\u0197\u0198\7E\2\2\u0198\u0199\7\65\2\2\u0199\u019a")
        buf.write("\5<\37\2\u019a\u019b\7\16\2\2\u019b\u019c\5> \2\u019c")
        buf.write(";\3\2\2\2\u019d\u019e\5\u0084C\2\u019e=\3\2\2\2\u019f")
        buf.write("\u01a0\5\u0084C\2\u01a0?\3\2\2\2\u01a1\u01b1\5\64\33\2")
        buf.write("\u01a2\u01a3\t\3\2\2\u01a3\u01a4\7\u008e\2\2\u01a4\u01a5")
        buf.write("\5\u00a0Q\2\u01a5\u01ad\7\u008f\2\2\u01a6\u01a7\7\u0092")
        buf.write("\2\2\u01a7\u01a8\7\u008e\2\2\u01a8\u01a9\5\u00a0Q\2\u01a9")
        buf.write("\u01aa\7\u008f\2\2\u01aa\u01ac\3\2\2\2\u01ab\u01a6\3\2")
        buf.write("\2\2\u01ac\u01af\3\2\2\2\u01ad\u01ab\3\2\2\2\u01ad\u01ae")
        buf.write("\3\2\2\2\u01ae\u01b1\3\2\2\2\u01af\u01ad\3\2\2\2\u01b0")
        buf.write("\u01a1\3\2\2\2\u01b0\u01a2\3\2\2\2\u01b1A\3\2\2\2\u01b2")
        buf.write("\u01b3\5t;\2\u01b3\u01b6\7\u0085\2\2\u01b4\u01b7\5\u00b4")
        buf.write("[\2\u01b5\u01b7\7\24\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b5")
        buf.write("\3\2\2\2\u01b7C\3\2\2\2\u01b8\u01b9\7\25\2\2\u01b9\u01ba")
        buf.write("\7\36\2\2\u01ba\u01bd\5r:\2\u01bb\u01bc\7H\2\2\u01bc\u01be")
        buf.write("\5\u00b4[\2\u01bd\u01bb\3\2\2\2\u01bd\u01be\3\2\2\2\u01be")
        buf.write("\u01c0\3\2\2\2\u01bf\u01c1\5H%\2\u01c0\u01bf\3\2\2\2\u01c0")
        buf.write("\u01c1\3\2\2\2\u01c1\u01c4\3\2\2\2\u01c2\u01c3\7,\2\2")
        buf.write("\u01c3\u01c5\5\u0082B\2\u01c4\u01c2\3\2\2\2\u01c4\u01c5")
        buf.write("\3\2\2\2\u01c5E\3\2\2\2\u01c6\u01c7\7D\2\2\u01c7\u01cc")
        buf.write("\5r:\2\u01c8\u01ca\7\f\2\2\u01c9\u01c8\3\2\2\2\u01c9\u01ca")
        buf.write("\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cd\5|?\2\u01cc\u01c9")
        buf.write("\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce")
        buf.write("\u01cf\7:\2\2\u01cf\u01d4\5B\"\2\u01d0\u01d1\7\u0092\2")
        buf.write("\2\u01d1\u01d3\5B\"\2\u01d2\u01d0\3\2\2\2\u01d3\u01d6")
        buf.write("\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5")
        buf.write("\u01d9\3\2\2\2\u01d6\u01d4\3\2\2\2\u01d7\u01d8\7H\2\2")
        buf.write("\u01d8\u01da\5\u00b4[\2\u01d9\u01d7\3\2\2\2\u01d9\u01da")
        buf.write("\3\2\2\2\u01da\u01dc\3\2\2\2\u01db\u01dd\5H%\2\u01dc\u01db")
        buf.write("\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01df\3\2\2\2\u01de")
        buf.write("\u01e0\5d\63\2\u01df\u01de\3\2\2\2\u01df\u01e0\3\2\2\2")
        buf.write("\u01e0G\3\2\2\2\u01e1\u01e2\7\64\2\2\u01e2\u01e3\7\17")
        buf.write("\2\2\u01e3\u01e8\5J&\2\u01e4\u01e5\7\u0092\2\2\u01e5\u01e7")
        buf.write("\5J&\2\u01e6\u01e4\3\2\2\2\u01e7\u01ea\3\2\2\2\u01e8\u01e6")
        buf.write("\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9I\3\2\2\2\u01ea\u01e8")
        buf.write("\3\2\2\2\u01eb\u01ed\5\u00b4[\2\u01ec\u01ee\t\4\2\2\u01ed")
        buf.write("\u01ec\3\2\2\2\u01ed\u01ee\3\2\2\2\u01eeK\3\2\2\2\u01ef")
        buf.write("\u01f4\5N(\2\u01f0\u01f1\7\u0092\2\2\u01f1\u01f3\5N(\2")
        buf.write("\u01f2\u01f0\3\2\2\2\u01f3\u01f6\3\2\2\2\u01f4\u01f2\3")
        buf.write("\2\2\2\u01f4\u01f5\3\2\2\2\u01f5M\3\2\2\2\u01f6\u01f4")
        buf.write("\3\2\2\2\u01f7\u01fb\5P)\2\u01f8\u01fa\5V,\2\u01f9\u01f8")
        buf.write("\3\2\2\2\u01fa\u01fd\3\2\2\2\u01fb\u01f9\3\2\2\2\u01fb")
        buf.write("\u01fc\3\2\2\2\u01fcO\3\2\2\2\u01fd\u01fb\3\2\2\2\u01fe")
        buf.write("\u0200\5R*\2\u01ff\u0201\5T+\2\u0200\u01ff\3\2\2\2\u0200")
        buf.write("\u0201\3\2\2\2\u0201Q\3\2\2\2\u0202\u020b\5r:\2\u0203")
        buf.write("\u0209\5\64\33\2\u0204\u0205\7\u008e\2\2\u0205\u0206\5")
        buf.write("\64\33\2\u0206\u0207\7\u008f\2\2\u0207\u0209\3\2\2\2\u0208")
        buf.write("\u0203\3\2\2\2\u0208\u0204\3\2\2\2\u0209\u020b\3\2\2\2")
        buf.write("\u020a\u0202\3\2\2\2\u020a\u0208\3\2\2\2\u020bS\3\2\2")
        buf.write("\2\u020c\u020d\78\2\2\u020d\u020e\5\u0082B\2\u020eU\3")
        buf.write("\2\2\2\u020f\u0210\7)\2\2\u0210\u0218\5P)\2\u0211\u0212")
        buf.write("\7\62\2\2\u0212\u0219\5\u00b4[\2\u0213\u0214\7F\2\2\u0214")
        buf.write("\u0215\7\u008e\2\2\u0215\u0216\5\u0098M\2\u0216\u0217")
        buf.write("\7\u008f\2\2\u0217\u0219\3\2\2\2\u0218\u0211\3\2\2\2\u0218")
        buf.write("\u0213\3\2\2\2\u0218\u0219\3\2\2\2\u0219W\3\2\2\2\u021a")
        buf.write("\u021b\7\u008e\2\2\u021b\u021c\5Z.\2\u021c\u021d\7\u008f")
        buf.write("\2\2\u021d\u0223\3\2\2\2\u021e\u021f\7\u008e\2\2\u021f")
        buf.write("\u0220\5X-\2\u0220\u0221\7\u008f\2\2\u0221\u0223\3\2\2")
        buf.write("\2\u0222\u021a\3\2\2\2\u0222\u021e\3\2\2\2\u0223Y\3\2")
        buf.write("\2\2\u0224\u0225\79\2\2\u0225\u0226\5\\/\2\u0226\u0228")
        buf.write("\5`\61\2\u0227\u0229\5H%\2\u0228\u0227\3\2\2\2\u0228\u0229")
        buf.write("\3\2\2\2\u0229\u022b\3\2\2\2\u022a\u022c\5d\63\2\u022b")
        buf.write("\u022a\3\2\2\2\u022b\u022c\3\2\2\2\u022c\u022e\3\2\2\2")
        buf.write("\u022d\u022f\5f\64\2\u022e\u022d\3\2\2\2\u022e\u022f\3")
        buf.write("\2\2\2\u022f\u0231\3\2\2\2\u0230\u0232\5h\65\2\u0231\u0230")
        buf.write("\3\2\2\2\u0231\u0232\3\2\2\2\u0232[\3\2\2\2\u0233\u0236")
        buf.write("\7}\2\2\u0234\u0236\5^\60\2\u0235\u0233\3\2\2\2\u0235")
        buf.write("\u0234\3\2\2\2\u0236\u023b\3\2\2\2\u0237\u0238\7\u0092")
        buf.write("\2\2\u0238\u023a\5^\60\2\u0239\u0237\3\2\2\2\u023a\u023d")
        buf.write("\3\2\2\2\u023b\u0239\3\2\2\2\u023b\u023c\3\2\2\2\u023c")
        buf.write("]\3\2\2\2\u023d\u023b\3\2\2\2\u023e\u023f\5p9\2\u023f")
        buf.write("\u0240\7\u008d\2\2\u0240\u0241\7}\2\2\u0241\u025c\3\2")
        buf.write("\2\2\u0242\u0247\5t;\2\u0243\u0245\7\f\2\2\u0244\u0243")
        buf.write("\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0246\3\2\2\2\u0246")
        buf.write("\u0248\5|?\2\u0247\u0244\3\2\2\2\u0247\u0248\3\2\2\2\u0248")
        buf.write("\u025c\3\2\2\2\u0249\u024e\5\u00aaV\2\u024a\u024c\7\f")
        buf.write("\2\2\u024b\u024a\3\2\2\2\u024b\u024c\3\2\2\2\u024c\u024d")
        buf.write("\3\2\2\2\u024d\u024f\5|?\2\u024e\u024b\3\2\2\2\u024e\u024f")
        buf.write("\3\2\2\2\u024f\u025c\3\2\2\2\u0250\u0251\7\u00a4\2\2\u0251")
        buf.write("\u0253\7t\2\2\u0252\u0250\3\2\2\2\u0252\u0253\3\2\2\2")
        buf.write("\u0253\u0254\3\2\2\2\u0254\u0259\5\u00b4[\2\u0255\u0257")
        buf.write("\7\f\2\2\u0256\u0255\3\2\2\2\u0256\u0257\3\2\2\2\u0257")
        buf.write("\u0258\3\2\2\2\u0258\u025a\5|?\2\u0259\u0256\3\2\2\2\u0259")
        buf.write("\u025a\3\2\2\2\u025a\u025c\3\2\2\2\u025b\u023e\3\2\2\2")
        buf.write("\u025b\u0242\3\2\2\2\u025b\u0249\3\2\2\2\u025b\u0252\3")
        buf.write("\2\2\2\u025c_\3\2\2\2\u025d\u025e\7\36\2\2\u025e\u0261")
        buf.write("\5L\'\2\u025f\u0260\7H\2\2\u0260\u0262\5\u00b4[\2\u0261")
        buf.write("\u025f\3\2\2\2\u0261\u0262\3\2\2\2\u0262\u026d\3\2\2\2")
        buf.write("\u0263\u0264\7\37\2\2\u0264\u0265\7\17\2\2\u0265\u026a")
        buf.write("\5b\62\2\u0266\u0267\7\u0092\2\2\u0267\u0269\5b\62\2\u0268")
        buf.write("\u0266\3\2\2\2\u0269\u026c\3\2\2\2\u026a\u0268\3\2\2\2")
        buf.write("\u026a\u026b\3\2\2\2\u026b\u026e\3\2\2\2\u026c\u026a\3")
        buf.write("\2\2\2\u026d\u0263\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u0271")
        buf.write("\3\2\2\2\u026f\u0270\7 \2\2\u0270\u0272\5\u00b4[\2\u0271")
        buf.write("\u026f\3\2\2\2\u0271\u0272\3\2\2\2\u0272a\3\2\2\2\u0273")
        buf.write("\u0275\5\u00b4[\2\u0274\u0276\t\4\2\2\u0275\u0274\3\2")
        buf.write("\2\2\u0275\u0276\3\2\2\2\u0276c\3\2\2\2\u0277\u0282\7")
        buf.write(",\2\2\u0278\u0279\5\u0082B\2\u0279\u027a\7\u0092\2\2\u027a")
        buf.write("\u027c\3\2\2\2\u027b\u0278\3\2\2\2\u027b\u027c\3\2\2\2")
        buf.write("\u027c\u027d\3\2\2\2\u027d\u0283\5\u0082B\2\u027e\u027f")
        buf.write("\5\u0082B\2\u027f\u0280\7\61\2\2\u0280\u0281\5\u0082B")
        buf.write("\2\u0281\u0283\3\2\2\2\u0282\u027b\3\2\2\2\u0282\u027e")
        buf.write("\3\2\2\2\u0283e\3\2\2\2\u0284\u0285\7J\2\2\u0285\u0286")
        buf.write("\7\u009e\2\2\u0286g\3\2\2\2\u0287\u0288\7K\2\2\u0288\u0289")
        buf.write("\7\u009e\2\2\u0289i\3\2\2\2\u028a\u028b\7;\2\2\u028bk")
        buf.write("\3\2\2\2\u028c\u028d\7\27\2\2\u028d\u028e\5r:\2\u028e")
        buf.write("m\3\2\2\2\u028f\u0290\7k\2\2\u0290\u0291\7\u009c\2\2\u0291")
        buf.write("o\3\2\2\2\u0292\u0296\5|?\2\u0293\u0297\7\u00a0\2\2\u0294")
        buf.write("\u0295\7\u008d\2\2\u0295\u0297\5|?\2\u0296\u0293\3\2\2")
        buf.write("\2\u0296\u0294\3\2\2\2\u0296\u0297\3\2\2\2\u0297q\3\2")
        buf.write("\2\2\u0298\u0299\5p9\2\u0299s\3\2\2\2\u029a\u029f\5|?")
        buf.write("\2\u029b\u029d\5\u0080A\2\u029c\u029e\5\u0080A\2\u029d")
        buf.write("\u029c\3\2\2\2\u029d\u029e\3\2\2\2\u029e\u02a0\3\2\2\2")
        buf.write("\u029f\u029b\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0u\3\2\2")
        buf.write("\2\u02a1\u02a6\5|?\2\u02a2\u02a3\7\u008e\2\2\u02a3\u02a4")
        buf.write("\5\u0082B\2\u02a4\u02a5\7\u008f\2\2\u02a5\u02a7\3\2\2")
        buf.write("\2\u02a6\u02a2\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02a9")
        buf.write("\3\2\2\2\u02a8\u02aa\t\4\2\2\u02a9\u02a8\3\2\2\2\u02a9")
        buf.write("\u02aa\3\2\2\2\u02aaw\3\2\2\2\u02ab\u02ac\t\5\2\2\u02ac")
        buf.write("y\3\2\2\2\u02ad\u02ae\5\u0082B\2\u02ae\u02af\7\u0082\2")
        buf.write("\2\u02af\u02b0\5\u0082B\2\u02b0\u02b1\7\u0082\2\2\u02b1")
        buf.write("\u02b2\5\u0082B\2\u02b2\u02b3\7\u0082\2\2\u02b3\u02b4")
        buf.write("\5\u0082B\2\u02b4\u02b5\7\u0082\2\2\u02b5\u02bb\5\u0082")
        buf.write("B\2\u02b6\u02b7\7\u009b\2\2\u02b7\u02b8\5\u0082B\2\u02b8")
        buf.write("\u02b9\7\u0082\2\2\u02b9\u02ba\5\u0082B\2\u02ba\u02bc")
        buf.write("\3\2\2\2\u02bb\u02b6\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd")
        buf.write("\u02bb\3\2\2\2\u02bd\u02be\3\2\2\2\u02be{\3\2\2\2\u02bf")
        buf.write("\u02c2\5~@\2\u02c0\u02c2\7\u00a2\2\2\u02c1\u02bf\3\2\2")
        buf.write("\2\u02c1\u02c0\3\2\2\2\u02c2}\3\2\2\2\u02c3\u02c4\7\u00a1")
        buf.write("\2\2\u02c4\177\3\2\2\2\u02c5\u02c9\7\u00a0\2\2\u02c6\u02c7")
        buf.write("\7\u008d\2\2\u02c7\u02c9\5|?\2\u02c8\u02c5\3\2\2\2\u02c8")
        buf.write("\u02c6\3\2\2\2\u02c9\u0081\3\2\2\2\u02ca\u02cb\t\6\2\2")
        buf.write("\u02cb\u0083\3\2\2\2\u02cc\u02cd\7\u009c\2\2\u02cd\u0085")
        buf.write("\3\2\2\2\u02ce\u02cf\t\7\2\2\u02cf\u0087\3\2\2\2\u02d0")
        buf.write("\u02d2\7/\2\2\u02d1\u02d0\3\2\2\2\u02d1\u02d2\3\2\2\2")
        buf.write("\u02d2\u02d3\3\2\2\2\u02d3\u02d4\t\b\2\2\u02d4\u0089\3")
        buf.write("\2\2\2\u02d5\u02d6\7\u0090\2\2\u02d6\u02db\5\u008cG\2")
        buf.write("\u02d7\u02d8\7\u0092\2\2\u02d8\u02da\5\u008cG\2\u02d9")
        buf.write("\u02d7\3\2\2\2\u02da\u02dd\3\2\2\2\u02db\u02d9\3\2\2\2")
        buf.write("\u02db\u02dc\3\2\2\2\u02dc\u02de\3\2\2\2\u02dd\u02db\3")
        buf.write("\2\2\2\u02de\u02df\7\u0091\2\2\u02df\u02e3\3\2\2\2\u02e0")
        buf.write("\u02e1\7\u0090\2\2\u02e1\u02e3\7\u0091\2\2\u02e2\u02d5")
        buf.write("\3\2\2\2\u02e2\u02e0\3\2\2\2\u02e3\u008b\3\2\2\2\u02e4")
        buf.write("\u02f0\5\u0084C\2\u02e5\u02f0\5\u0082B\2\u02e6\u02e7\7")
        buf.write("\u0082\2\2\u02e7\u02f0\5\u0082B\2\u02e8\u02f0\5\u0086")
        buf.write("D\2\u02e9\u02f0\7\u009e\2\2\u02ea\u02ec\7/\2\2\u02eb\u02ea")
        buf.write("\3\2\2\2\u02eb\u02ec\3\2\2\2\u02ec\u02ed\3\2\2\2\u02ed")
        buf.write("\u02f0\t\b\2\2\u02ee\u02f0\5\u008aF\2\u02ef\u02e4\3\2")
        buf.write("\2\2\u02ef\u02e5\3\2\2\2\u02ef\u02e6\3\2\2\2\u02ef\u02e8")
        buf.write("\3\2\2\2\u02ef\u02e9\3\2\2\2\u02ef\u02eb\3\2\2\2\u02ef")
        buf.write("\u02ee\3\2\2\2\u02f0\u008d\3\2\2\2\u02f1\u02f2\t\t\2\2")
        buf.write("\u02f2\u008f\3\2\2\2\u02f3\u030c\7P\2\2\u02f4\u02f6\7")
        buf.write("S\2\2\u02f5\u02f7\5\u0092J\2\u02f6\u02f5\3\2\2\2\u02f6")
        buf.write("\u02f7\3\2\2\2\u02f7\u030c\3\2\2\2\u02f8\u02fa\7Q\2\2")
        buf.write("\u02f9\u02fb\7C\2\2\u02fa\u02f9\3\2\2\2\u02fa\u02fb\3")
        buf.write("\2\2\2\u02fb\u030c\3\2\2\2\u02fc\u02fe\7R\2\2\u02fd\u02ff")
        buf.write("\5\u0094K\2\u02fe\u02fd\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff")
        buf.write("\u0301\3\2\2\2\u0300\u0302\7C\2\2\u0301\u0300\3\2\2\2")
        buf.write("\u0301\u0302\3\2\2\2\u0302\u030c\3\2\2\2\u0303\u0305\7")
        buf.write("T\2\2\u0304\u0306\5\u008eH\2\u0305\u0304\3\2\2\2\u0305")
        buf.write("\u0306\3\2\2\2\u0306\u0308\3\2\2\2\u0307\u0309\5\u0096")
        buf.write("L\2\u0308\u0307\3\2\2\2\u0308\u0309\3\2\2\2\u0309\u030c")
        buf.write("\3\2\2\2\u030a\u030c\7a\2\2\u030b\u02f3\3\2\2\2\u030b")
        buf.write("\u02f4\3\2\2\2\u030b\u02f8\3\2\2\2\u030b\u02fc\3\2\2\2")
        buf.write("\u030b\u0303\3\2\2\2\u030b\u030a\3\2\2\2\u030c\u0091\3")
        buf.write("\2\2\2\u030d\u030e\7\u008e\2\2\u030e\u030f\5\u0082B\2")
        buf.write("\u030f\u0310\7\u008f\2\2\u0310\u0093\3\2\2\2\u0311\u0312")
        buf.write("\7\u008e\2\2\u0312\u0313\5\u0082B\2\u0313\u0314\7\u0092")
        buf.write("\2\2\u0314\u0315\5\u0082B\2\u0315\u0316\7\u008f\2\2\u0316")
        buf.write("\u0095\3\2\2\2\u0317\u031d\7\u008e\2\2\u0318\u0319\5\u0082")
        buf.write("B\2\u0319\u031a\7\u0092\2\2\u031a\u031c\3\2\2\2\u031b")
        buf.write("\u0318\3\2\2\2\u031c\u031f\3\2\2\2\u031d\u031b\3\2\2\2")
        buf.write("\u031d\u031e\3\2\2\2\u031e\u0320\3\2\2\2\u031f\u031d\3")
        buf.write("\2\2\2\u0320\u0321\5\u0082B\2\u0321\u0322\7\u008f\2\2")
        buf.write("\u0322\u0097\3\2\2\2\u0323\u0328\5|?\2\u0324\u0325\7\u0092")
        buf.write("\2\2\u0325\u0327\5|?\2\u0326\u0324\3\2\2\2\u0327\u032a")
        buf.write("\3\2\2\2\u0328\u0326\3\2\2\2\u0328\u0329\3\2\2\2\u0329")
        buf.write("\u0099\3\2\2\2\u032a\u0328\3\2\2\2\u032b\u0330\5r:\2\u032c")
        buf.write("\u032d\7\u0092\2\2\u032d\u032f\5r:\2\u032e\u032c\3\2\2")
        buf.write("\2\u032f\u0332\3\2\2\2\u0330\u032e\3\2\2\2\u0330\u0331")
        buf.write("\3\2\2\2\u0331\u009b\3\2\2\2\u0332\u0330\3\2\2\2\u0333")
        buf.write("\u0334\7\u008e\2\2\u0334\u0339\5v<\2\u0335\u0336\7\u0092")
        buf.write("\2\2\u0336\u0338\5v<\2\u0337\u0335\3\2\2\2\u0338\u033b")
        buf.write("\3\2\2\2\u0339\u0337\3\2\2\2\u0339\u033a\3\2\2\2\u033a")
        buf.write("\u033c\3\2\2\2\u033b\u0339\3\2\2\2\u033c\u033d\7\u008f")
        buf.write("\2\2\u033d\u009d\3\2\2\2\u033e\u0343\5\u00b4[\2\u033f")
        buf.write("\u0340\7\u0092\2\2\u0340\u0342\5\u00b4[\2\u0341\u033f")
        buf.write("\3\2\2\2\u0342\u0345\3\2\2\2\u0343\u0341\3\2\2\2\u0343")
        buf.write("\u0344\3\2\2\2\u0344\u009f\3\2\2\2\u0345\u0343\3\2\2\2")
        buf.write("\u0346\u034b\5\u00a4S\2\u0347\u0348\7\u0092\2\2\u0348")
        buf.write("\u034a\5\u00a4S\2\u0349\u0347\3\2\2\2\u034a\u034d\3\2")
        buf.write("\2\2\u034b\u0349\3\2\2\2\u034b\u034c\3\2\2\2\u034c\u00a1")
        buf.write("\3\2\2\2\u034d\u034b\3\2\2\2\u034e\u0351\7\60\2\2\u034f")
        buf.write("\u0351\5\u008cG\2\u0350\u034e\3\2\2\2\u0350\u034f\3\2")
        buf.write("\2\2\u0351\u00a3\3\2\2\2\u0352\u0355\5\u00b4[\2\u0353")
        buf.write("\u0355\7\24\2\2\u0354\u0352\3\2\2\2\u0354\u0353\3\2\2")
        buf.write("\2\u0355\u00a5\3\2\2\2\u0356\u0357\7!\2\2\u0357\u0358")
        buf.write("\7\33\2\2\u0358\u00a7\3\2\2\2\u0359\u035a\7!\2\2\u035a")
        buf.write("\u035b\7/\2\2\u035b\u035c\7\33\2\2\u035c\u00a9\3\2\2\2")
        buf.write("\u035d\u0360\5\u00acW\2\u035e\u0360\5\u00aeX\2\u035f\u035d")
        buf.write("\3\2\2\2\u035f\u035e\3\2\2\2\u0360\u00ab\3\2\2\2\u0361")
        buf.write("\u0362\5~@\2\u0362\u0363\7\u008e\2\2\u0363\u0364\5\u00b0")
        buf.write("Y\2\u0364\u0366\7\u008f\2\2\u0365\u0367\5\u0080A\2\u0366")
        buf.write("\u0365\3\2\2\2\u0366\u0367\3\2\2\2\u0367\u00ad\3\2\2\2")
        buf.write("\u0368\u0369\t\n\2\2\u0369\u036b\7\u008e\2\2\u036a\u036c")
        buf.write("\t\13\2\2\u036b\u036a\3\2\2\2\u036b\u036c\3\2\2\2\u036c")
        buf.write("\u036d\3\2\2\2\u036d\u036e\5\u00b2Z\2\u036e\u036f\7\u008f")
        buf.write("\2\2\u036f\u037b\3\2\2\2\u0370\u0371\7c\2\2\u0371\u0377")
        buf.write("\7\u008e\2\2\u0372\u0378\7}\2\2\u0373\u0375\7\7\2\2\u0374")
        buf.write("\u0373\3\2\2\2\u0374\u0375\3\2\2\2\u0375\u0376\3\2\2\2")
        buf.write("\u0376\u0378\5\u00b2Z\2\u0377\u0372\3\2\2\2\u0377\u0374")
        buf.write("\3\2\2\2\u0378\u0379\3\2\2\2\u0379\u037b\7\u008f\2\2\u037a")
        buf.write("\u0368\3\2\2\2\u037a\u0370\3\2\2\2\u037b\u00af\3\2\2\2")
        buf.write("\u037c\u0381\5\u008cG\2\u037d\u0381\5t;\2\u037e\u0381")
        buf.write("\5\u00aaV\2\u037f\u0381\5\u00b4[\2\u0380\u037c\3\2\2\2")
        buf.write("\u0380\u037d\3\2\2\2\u0380\u037e\3\2\2\2\u0380\u037f\3")
        buf.write("\2\2\2\u0381\u038b\3\2\2\2\u0382\u0387\7\u0092\2\2\u0383")
        buf.write("\u0388\5\u008cG\2\u0384\u0388\5t;\2\u0385\u0388\5\u00aa")
        buf.write("V\2\u0386\u0388\5\u00b4[\2\u0387\u0383\3\2\2\2\u0387\u0384")
        buf.write("\3\2\2\2\u0387\u0385\3\2\2\2\u0387\u0386\3\2\2\2\u0388")
        buf.write("\u038a\3\2\2\2\u0389\u0382\3\2\2\2\u038a\u038d\3\2\2\2")
        buf.write("\u038b\u0389\3\2\2\2\u038b\u038c\3\2\2\2\u038c\u00b1\3")
        buf.write("\2\2\2\u038d\u038b\3\2\2\2\u038e\u0393\5\u008cG\2\u038f")
        buf.write("\u0393\5t;\2\u0390\u0393\5\u00aaV\2\u0391\u0393\5\u00b4")
        buf.write("[\2\u0392\u038e\3\2\2\2\u0392\u038f\3\2\2\2\u0392\u0390")
        buf.write("\3\2\2\2\u0392\u0391\3\2\2\2\u0393\u00b3\3\2\2\2\u0394")
        buf.write("\u0395\b[\1\2\u0395\u0396\t\f\2\2\u0396\u03a0\5\u00b4")
        buf.write("[\6\u0397\u0398\5\u00b6\\\2\u0398\u039a\7(\2\2\u0399\u039b")
        buf.write("\7/\2\2\u039a\u0399\3\2\2\2\u039a\u039b\3\2\2\2\u039b")
        buf.write("\u039c\3\2\2\2\u039c\u039d\t\r\2\2\u039d\u03a0\3\2\2\2")
        buf.write("\u039e\u03a0\5\u00b6\\\2\u039f\u0394\3\2\2\2\u039f\u0397")
        buf.write("\3\2\2\2\u039f\u039e\3\2\2\2\u03a0\u03a7\3\2\2\2\u03a1")
        buf.write("\u03a2\f\5\2\2\u03a2\u03a3\5\u00be`\2\u03a3\u03a4\5\u00b4")
        buf.write("[\6\u03a4\u03a6\3\2\2\2\u03a5\u03a1\3\2\2\2\u03a6\u03a9")
        buf.write("\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8")
        buf.write("\u00b5\3\2\2\2\u03a9\u03a7\3\2\2\2\u03aa\u03ad\b\\\1\2")
        buf.write("\u03ab\u03ac\7\u00a4\2\2\u03ac\u03ae\7t\2\2\u03ad\u03ab")
        buf.write("\3\2\2\2\u03ad\u03ae\3\2\2\2\u03ae\u03af\3\2\2\2\u03af")
        buf.write("\u03b0\5\u00b8]\2\u03b0\u03d6\3\2\2\2\u03b1\u03b2\f\6")
        buf.write("\2\2\u03b2\u03b3\5\u00bc_\2\u03b3\u03b4\5\u00b6\\\7\u03b4")
        buf.write("\u03d5\3\2\2\2\u03b5\u03b7\f\b\2\2\u03b6\u03b8\7/\2\2")
        buf.write("\u03b7\u03b6\3\2\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3")
        buf.write("\2\2\2\u03b9\u03ba\7\"\2\2\u03ba\u03bd\7\u008e\2\2\u03bb")
        buf.write("\u03be\5\64\33\2\u03bc\u03be\5\u009eP\2\u03bd\u03bb\3")
        buf.write("\2\2\2\u03bd\u03bc\3\2\2\2\u03be\u03bf\3\2\2\2\u03bf\u03c0")
        buf.write("\7\u008f\2\2\u03c0\u03d5\3\2\2\2\u03c1\u03c2\f\7\2\2\u03c2")
        buf.write("\u03c3\7(\2\2\u03c3\u03d5\5\u0088E\2\u03c4\u03c5\f\5\2")
        buf.write("\2\u03c5\u03c6\5\u00bc_\2\u03c6\u03c7\t\16\2\2\u03c7\u03c8")
        buf.write("\7\u008e\2\2\u03c8\u03c9\5\64\33\2\u03c9\u03ca\7\u008f")
        buf.write("\2\2\u03ca\u03d5\3\2\2\2\u03cb\u03cd\f\4\2\2\u03cc\u03ce")
        buf.write("\7/\2\2\u03cd\u03cc\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce")
        buf.write("\u03cf\3\2\2\2\u03cf\u03d0\7+\2\2\u03d0\u03d2\5\u00b6")
        buf.write("\\\2\u03d1\u03d3\7\u009c\2\2\u03d2\u03d1\3\2\2\2\u03d2")
        buf.write("\u03d3\3\2\2\2\u03d3\u03d5\3\2\2\2\u03d4\u03b1\3\2\2\2")
        buf.write("\u03d4\u03b5\3\2\2\2\u03d4\u03c1\3\2\2\2\u03d4\u03c4\3")
        buf.write("\2\2\2\u03d4\u03cb\3\2\2\2\u03d5\u03d8\3\2\2\2\u03d6\u03d4")
        buf.write("\3\2\2\2\u03d6\u03d7\3\2\2\2\u03d7\u00b7\3\2\2\2\u03d8")
        buf.write("\u03d6\3\2\2\2\u03d9\u03da\b]\1\2\u03da\u03f0\5\u008c")
        buf.write("G\2\u03db\u03f0\5t;\2\u03dc\u03f0\5\u00aaV\2\u03dd\u03de")
        buf.write("\5\u00ba^\2\u03de\u03df\5\u00b8]\7\u03df\u03f0\3\2\2\2")
        buf.write("\u03e0\u03e1\7\u008e\2\2\u03e1\u03e6\5\u00b4[\2\u03e2")
        buf.write("\u03e3\7\u0092\2\2\u03e3\u03e5\5\u00b4[\2\u03e4\u03e2")
        buf.write("\3\2\2\2\u03e5\u03e8\3\2\2\2\u03e6\u03e4\3\2\2\2\u03e6")
        buf.write("\u03e7\3\2\2\2\u03e7\u03e9\3\2\2\2\u03e8\u03e6\3\2\2\2")
        buf.write("\u03e9\u03ea\7\u008f\2\2\u03ea\u03f0\3\2\2\2\u03eb\u03ec")
        buf.write("\7\u008e\2\2\u03ec\u03ed\5\64\33\2\u03ed\u03ee\7\u008f")
        buf.write("\2\2\u03ee\u03f0\3\2\2\2\u03ef\u03d9\3\2\2\2\u03ef\u03db")
        buf.write("\3\2\2\2\u03ef\u03dc\3\2\2\2\u03ef\u03dd\3\2\2\2\u03ef")
        buf.write("\u03e0\3\2\2\2\u03ef\u03eb\3\2\2\2\u03f0\u03fb\3\2\2\2")
        buf.write("\u03f1\u03f2\f\4\2\2\u03f2\u03f3\5\u00c0a\2\u03f3\u03f4")
        buf.write("\5\u00b8]\5\u03f4\u03fa\3\2\2\2\u03f5\u03f6\f\3\2\2\u03f6")
        buf.write("\u03f7\5\u00c2b\2\u03f7\u03f8\5\u00b8]\4\u03f8\u03fa\3")
        buf.write("\2\2\2\u03f9\u03f1\3\2\2\2\u03f9\u03f5\3\2\2\2\u03fa\u03fd")
        buf.write("\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fb\u03fc\3\2\2\2\u03fc")
        buf.write("\u00b9\3\2\2\2\u03fd\u03fb\3\2\2\2\u03fe\u03ff\t\17\2")
        buf.write("\2\u03ff\u00bb\3\2\2\2\u0400\u0413\7\u0085\2\2\u0401\u0413")
        buf.write("\7\u0086\2\2\u0402\u0413\7\u0087\2\2\u0403\u0404\7\u0087")
        buf.write("\2\2\u0404\u0413\7\u0085\2\2\u0405\u0406\7\u0086\2\2\u0406")
        buf.write("\u0413\7\u0085\2\2\u0407\u0408\7\u0087\2\2\u0408\u0413")
        buf.write("\7\u0086\2\2\u0409\u040a\7\u0088\2\2\u040a\u0413\7\u0085")
        buf.write("\2\2\u040b\u040c\7\u0087\2\2\u040c\u040d\7\u0085\2\2\u040d")
        buf.write("\u0413\7\u0086\2\2\u040e\u040f\7\u0094\2\2\u040f\u0413")
        buf.write("\7\u0086\2\2\u0410\u0411\7\u0087\2\2\u0411\u0413\7\u0094")
        buf.write("\2\2\u0412\u0400\3\2\2\2\u0412\u0401\3\2\2\2\u0412\u0402")
        buf.write("\3\2\2\2\u0412\u0403\3\2\2\2\u0412\u0405\3\2\2\2\u0412")
        buf.write("\u0407\3\2\2\2\u0412\u0409\3\2\2\2\u0412\u040b\3\2\2\2")
        buf.write("\u0412\u040e\3\2\2\2\u0412\u0410\3\2\2\2\u0413\u00bd\3")
        buf.write("\2\2\2\u0414\u041c\7\t\2\2\u0415\u0416\7\u008b\2\2\u0416")
        buf.write("\u041c\7\u008b\2\2\u0417\u041c\7I\2\2\u0418\u041c\7\63")
        buf.write("\2\2\u0419\u041a\7\u008a\2\2\u041a\u041c\7\u008a\2\2\u041b")
        buf.write("\u0414\3\2\2\2\u041b\u0415\3\2\2\2\u041b\u0417\3\2\2\2")
        buf.write("\u041b\u0418\3\2\2\2\u041b\u0419\3\2\2\2\u041c\u00bf\3")
        buf.write("\2\2\2\u041d\u041e\7\u0087\2\2\u041e\u0425\7\u0087\2\2")
        buf.write("\u041f\u0420\7\u0086\2\2\u0420\u0425\7\u0086\2\2\u0421")
        buf.write("\u0425\7\u008b\2\2\u0422\u0425\7\u008c\2\2\u0423\u0425")
        buf.write("\7\u008a\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2\2\2\u0424")
        buf.write("\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424\u0423\3\2\2\2")
        buf.write("\u0425\u00c1\3\2\2\2\u0426\u0427\t\20\2\2\u0427\u00c3")
        buf.write("\3\2\2\2\u0081\u00c5\u00c8\u00ce\u00d3\u00d5\u00da\u00dd")
        buf.write("\u00e0\u00e5\u00f0\u00f8\u00fc\u0101\u0109\u0112\u011a")
        buf.write("\u0135\u013e\u0144\u014b\u0150\u0152\u0156\u0159\u0160")
        buf.write("\u016d\u0175\u017c\u0186\u018b\u01ad\u01b0\u01b6\u01bd")
        buf.write("\u01c0\u01c4\u01c9\u01cc\u01d4\u01d9\u01dc\u01df\u01e8")
        buf.write("\u01ed\u01f4\u01fb\u0200\u0208\u020a\u0218\u0222\u0228")
        buf.write("\u022b\u022e\u0231\u0235\u023b\u0244\u0247\u024b\u024e")
        buf.write("\u0252\u0256\u0259\u025b\u0261\u026a\u026d\u0271\u0275")
        buf.write("\u027b\u0282\u0296\u029d\u029f\u02a6\u02a9\u02bd\u02c1")
        buf.write("\u02c8\u02d1\u02db\u02e2\u02eb\u02ef\u02f6\u02fa\u02fe")
        buf.write("\u0301\u0305\u0308\u030b\u031d\u0328\u0330\u0339\u0343")
        buf.write("\u034b\u0350\u0354\u035f\u0366\u036b\u0374\u0377\u037a")
        buf.write("\u0380\u0387\u038b\u0392\u039a\u039f\u03a7\u03ad\u03b7")
        buf.write("\u03bd\u03cd\u03d2\u03d4\u03d6\u03e6\u03ef\u03f9\u03fb")
        buf.write("\u0412\u041b\u0424")
        return buf.getvalue()


class evaql_parser ( Parser ):

    grammarFileName = "evaql_parser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'ALL'", "'ALTER'", "'AND'", "'ANY'", 
                     "'ANYDIM'", "'AS'", "'ASC'", "'BLOB'", "'BY'", "'COLUMN'", 
                     "'CREATE'", "'DATA'", "'DATABASE'", "'DEFAULT'", "'DELETE'", 
                     "'DESC'", "'DESCRIBE'", "'DISTINCT'", "'DROP'", "'EXIT'", 
                     "'EXISTS'", "'EXPLAIN'", "'FALSE'", "'FROM'", "'GROUP'", 
                     "'HAVING'", "'IF'", "'IN'", "'INFILE'", "'INDIR'", 
                     "'INTO'", "'INDEX'", "'INSERT'", "'IS'", "'JOIN'", 
                     "'KEY'", "'LIKE'", "'LIMIT'", "'LOAD'", "'NO'", "'NOT'", 
                     "'NULL'", "'OFFSET'", "'ON'", "'OR'", "'ORDER'", "'PATH'", 
                     "'PRIMARY'", "'REFERENCES'", "'SAMPLE'", "'SELECT'", 
                     "'SET'", "'SHUTDOWN'", "'SOME'", "'TABLE'", "'TRUE'", 
                     "'UNION'", "'UNIQUE'", "'UNKNOWN'", "'UNLOCK'", "'UNSIGNED'", 
                     "'UPDATE'", "'UPLOAD'", "'USING'", "'VALUES'", "'WHERE'", 
                     "'XOR'", "'ERROR_WITHIN'", "'AT_CONFIDENCE'", "'BTREE'", 
                     "'HASH'", "'OBJECT_DETECTION'", "'ACTION_CLASSICATION'", 
                     "'BOOLEAN'", "'INTEGER'", "'FLOAT'", "'TEXT'", "'NDARRAY'", 
                     "'INT8'", "'UINT8'", "'INT16'", "'INT32'", "'INT64'", 
                     "'UNICODE'", "'BOOL'", "'FLOAT32'", "'FLOAT64'", "'DECIMAL'", 
                     "'STR'", "'DATETIME'", "'ANYTYPE'", "'AVG'", "'COUNT'", 
                     "'MAX'", "'MIN'", "'STD'", "'SUM'", "'FCOUNT'", "'AUTO_INCREMENT'", 
                     "'COLUMNS'", "'HELP'", "'TEMPTABLE'", "'VALUE'", "'UDF'", 
                     "'INPUT'", "'OUTPUT'", "'TYPE'", "'IMPL'", "'ABS'", 
                     "':='", "'+='", "'-='", "'*='", "'/='", "'%='", "'&='", 
                     "'^='", "'|='", "'*'", "'/'", "'%'", "'+'", "'--'", 
                     "'-'", "'DIV'", "'MOD'", "'='", "'>'", "'<'", "'!'", 
                     "'~'", "'|'", "'&'", "'^'", "'.'", "'('", "')'", "'['", 
                     "']'", "','", "';'", "'@'", "'0'", "'1'", "'2'", "'''", 
                     "'\"'", "'`'", "':'" ]

    symbolicNames = [ "<INVALID>", "SPACE", "SPEC_EVAQL_COMMENT", "COMMENT_INPUT", 
                      "LINE_COMMENT", "ALL", "ALTER", "AND", "ANY", "ANYDIM", 
                      "AS", "ASC", "BLOB", "BY", "COLUMN", "CREATE", "DATA", 
                      "DATABASE", "DEFAULT", "DELETE", "DESC", "DESCRIBE", 
                      "DISTINCT", "DROP", "EXIT", "EXISTS", "EXPLAIN", "FALSE", 
                      "FROM", "GROUP", "HAVING", "IF", "IN", "INFILE", "INDIR", 
                      "INTO", "INDEX", "INSERT", "IS", "JOIN", "KEY", "LIKE", 
                      "LIMIT", "LOAD", "NO", "NOT", "NULL_LITERAL", "OFFSET", 
                      "ON", "OR", "ORDER", "PATH", "PRIMARY", "REFERENCES", 
                      "SAMPLE", "SELECT", "SET", "SHUTDOWN", "SOME", "TABLE", 
                      "TRUE", "UNION", "UNIQUE", "UNKNOWN", "UNLOCK", "UNSIGNED", 
                      "UPDATE", "UPLOAD", "USING", "VALUES", "WHERE", "XOR", 
                      "ERROR_BOUNDS", "CONFIDENCE_LEVEL", "BTREE", "HASH", 
                      "OBJECT_DETECTION", "ACTION_CLASSICATION", "BOOLEAN", 
                      "INTEGER", "FLOAT", "TEXT", "NDARRAY", "INT8", "UINT8", 
                      "INT16", "INT32", "INT64", "UNICODE", "BOOL", "FLOAT32", 
                      "FLOAT64", "DECIMAL", "STR", "DATETIME", "ANYTYPE", 
                      "AVG", "COUNT", "MAX", "MIN", "STD", "SUM", "FCOUNT", 
                      "AUTO_INCREMENT", "COLUMNS", "HELP", "TEMPTABLE", 
                      "VALUE", "UDF", "INPUT", "OUTPUT", "TYPE", "IMPL", 
                      "ABS", "VAR_ASSIGN", "PLUS_ASSIGN", "MINUS_ASSIGN", 
                      "MULT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", 
                      "XOR_ASSIGN", "OR_ASSIGN", "STAR", "DIVIDE", "MODULE", 
                      "PLUS", "MINUSMINUS", "MINUS", "DIV", "MOD", "EQUAL_SYMBOL", 
                      "GREATER_SYMBOL", "LESS_SYMBOL", "EXCLAMATION_SYMBOL", 
                      "BIT_NOT_OP", "BIT_OR_OP", "BIT_AND_OP", "BIT_XOR_OP", 
                      "DOT", "LR_BRACKET", "RR_BRACKET", "LR_SQ_BRACKET", 
                      "RR_SQ_BRACKET", "COMMA", "SEMI", "AT_SIGN", "ZERO_DECIMAL", 
                      "ONE_DECIMAL", "TWO_DECIMAL", "SINGLE_QUOTE_SYMB", 
                      "DOUBLE_QUOTE_SYMB", "REVERSE_QUOTE_SYMB", "COLON_SYMB", 
                      "STRING_LITERAL", "DECIMAL_LITERAL", "REAL_LITERAL", 
                      "NULL_SPEC_LITERAL", "DOT_ID", "ID", "REVERSE_QUOTE_ID", 
                      "STRING_USER_NAME", "LOCAL_ID", "GLOBAL_ID", "ERROR_RECONGNIGION" ]

    RULE_root = 0
    RULE_sqlStatements = 1
    RULE_sqlStatement = 2
    RULE_emptyStatement = 3
    RULE_ddlStatement = 4
    RULE_dmlStatement = 5
    RULE_utilityStatement = 6
    RULE_createDatabase = 7
    RULE_createIndex = 8
    RULE_createTable = 9
    RULE_createUdf = 10
    RULE_udfName = 11
    RULE_udfType = 12
    RULE_udfImpl = 13
    RULE_indexType = 14
    RULE_createDefinitions = 15
    RULE_createDefinition = 16
    RULE_columnDefinition = 17
    RULE_columnConstraint = 18
    RULE_indexColumnDefinition = 19
    RULE_dropDatabase = 20
    RULE_dropIndex = 21
    RULE_dropTable = 22
    RULE_deleteStatement = 23
    RULE_insertStatement = 24
    RULE_selectStatement = 25
    RULE_updateStatement = 26
    RULE_loadStatement = 27
    RULE_uploadStatement = 28
    RULE_fileName = 29
    RULE_videoBlob = 30
    RULE_insertStatementValue = 31
    RULE_updatedElement = 32
    RULE_singleDeleteStatement = 33
    RULE_singleUpdateStatement = 34
    RULE_orderByClause = 35
    RULE_orderByExpression = 36
    RULE_tableSources = 37
    RULE_tableSource = 38
    RULE_tableSourceItemWithSample = 39
    RULE_tableSourceItem = 40
    RULE_sampleClause = 41
    RULE_joinPart = 42
    RULE_queryExpression = 43
    RULE_querySpecification = 44
    RULE_selectElements = 45
    RULE_selectElement = 46
    RULE_fromClause = 47
    RULE_groupByItem = 48
    RULE_limitClause = 49
    RULE_errorBoundsExpression = 50
    RULE_confidenceLevelExpression = 51
    RULE_shutdownStatement = 52
    RULE_simpleDescribeStatement = 53
    RULE_helpStatement = 54
    RULE_fullId = 55
    RULE_tableName = 56
    RULE_fullColumnName = 57
    RULE_indexColumnName = 58
    RULE_userName = 59
    RULE_uuidSet = 60
    RULE_uid = 61
    RULE_simpleId = 62
    RULE_dottedId = 63
    RULE_decimalLiteral = 64
    RULE_stringLiteral = 65
    RULE_booleanLiteral = 66
    RULE_nullNotnull = 67
    RULE_arrayLiteral = 68
    RULE_constant = 69
    RULE_arrayType = 70
    RULE_dataType = 71
    RULE_lengthOneDimension = 72
    RULE_lengthTwoDimension = 73
    RULE_lengthDimensionList = 74
    RULE_uidList = 75
    RULE_tables = 76
    RULE_indexColumnNames = 77
    RULE_expressions = 78
    RULE_expressionsWithDefaults = 79
    RULE_defaultValue = 80
    RULE_expressionOrDefault = 81
    RULE_ifExists = 82
    RULE_ifNotExists = 83
    RULE_functionCall = 84
    RULE_udfFunction = 85
    RULE_aggregateWindowedFunction = 86
    RULE_functionArgs = 87
    RULE_functionArg = 88
    RULE_expression = 89
    RULE_predicate = 90
    RULE_expressionAtom = 91
    RULE_unaryOperator = 92
    RULE_comparisonOperator = 93
    RULE_logicalOperator = 94
    RULE_bitOperator = 95
    RULE_mathOperator = 96

    ruleNames =  [ "root", "sqlStatements", "sqlStatement", "emptyStatement", 
                   "ddlStatement", "dmlStatement", "utilityStatement", "createDatabase", 
                   "createIndex", "createTable", "createUdf", "udfName", 
                   "udfType", "udfImpl", "indexType", "createDefinitions", 
                   "createDefinition", "columnDefinition", "columnConstraint", 
                   "indexColumnDefinition", "dropDatabase", "dropIndex", 
                   "dropTable", "deleteStatement", "insertStatement", "selectStatement", 
                   "updateStatement", "loadStatement", "uploadStatement", 
                   "fileName", "videoBlob", "insertStatementValue", "updatedElement", 
                   "singleDeleteStatement", "singleUpdateStatement", "orderByClause", 
                   "orderByExpression", "tableSources", "tableSource", "tableSourceItemWithSample", 
                   "tableSourceItem", "sampleClause", "joinPart", "queryExpression", 
                   "querySpecification", "selectElements", "selectElement", 
                   "fromClause", "groupByItem", "limitClause", "errorBoundsExpression", 
                   "confidenceLevelExpression", "shutdownStatement", "simpleDescribeStatement", 
                   "helpStatement", "fullId", "tableName", "fullColumnName", 
                   "indexColumnName", "userName", "uuidSet", "uid", "simpleId", 
                   "dottedId", "decimalLiteral", "stringLiteral", "booleanLiteral", 
                   "nullNotnull", "arrayLiteral", "constant", "arrayType", 
                   "dataType", "lengthOneDimension", "lengthTwoDimension", 
                   "lengthDimensionList", "uidList", "tables", "indexColumnNames", 
                   "expressions", "expressionsWithDefaults", "defaultValue", 
                   "expressionOrDefault", "ifExists", "ifNotExists", "functionCall", 
                   "udfFunction", "aggregateWindowedFunction", "functionArgs", 
                   "functionArg", "expression", "predicate", "expressionAtom", 
                   "unaryOperator", "comparisonOperator", "logicalOperator", 
                   "bitOperator", "mathOperator" ]

    EOF = Token.EOF
    SPACE=1
    SPEC_EVAQL_COMMENT=2
    COMMENT_INPUT=3
    LINE_COMMENT=4
    ALL=5
    ALTER=6
    AND=7
    ANY=8
    ANYDIM=9
    AS=10
    ASC=11
    BLOB=12
    BY=13
    COLUMN=14
    CREATE=15
    DATA=16
    DATABASE=17
    DEFAULT=18
    DELETE=19
    DESC=20
    DESCRIBE=21
    DISTINCT=22
    DROP=23
    EXIT=24
    EXISTS=25
    EXPLAIN=26
    FALSE=27
    FROM=28
    GROUP=29
    HAVING=30
    IF=31
    IN=32
    INFILE=33
    INDIR=34
    INTO=35
    INDEX=36
    INSERT=37
    IS=38
    JOIN=39
    KEY=40
    LIKE=41
    LIMIT=42
    LOAD=43
    NO=44
    NOT=45
    NULL_LITERAL=46
    OFFSET=47
    ON=48
    OR=49
    ORDER=50
    PATH=51
    PRIMARY=52
    REFERENCES=53
    SAMPLE=54
    SELECT=55
    SET=56
    SHUTDOWN=57
    SOME=58
    TABLE=59
    TRUE=60
    UNION=61
    UNIQUE=62
    UNKNOWN=63
    UNLOCK=64
    UNSIGNED=65
    UPDATE=66
    UPLOAD=67
    USING=68
    VALUES=69
    WHERE=70
    XOR=71
    ERROR_BOUNDS=72
    CONFIDENCE_LEVEL=73
    BTREE=74
    HASH=75
    OBJECT_DETECTION=76
    ACTION_CLASSICATION=77
    BOOLEAN=78
    INTEGER=79
    FLOAT=80
    TEXT=81
    NDARRAY=82
    INT8=83
    UINT8=84
    INT16=85
    INT32=86
    INT64=87
    UNICODE=88
    BOOL=89
    FLOAT32=90
    FLOAT64=91
    DECIMAL=92
    STR=93
    DATETIME=94
    ANYTYPE=95
    AVG=96
    COUNT=97
    MAX=98
    MIN=99
    STD=100
    SUM=101
    FCOUNT=102
    AUTO_INCREMENT=103
    COLUMNS=104
    HELP=105
    TEMPTABLE=106
    VALUE=107
    UDF=108
    INPUT=109
    OUTPUT=110
    TYPE=111
    IMPL=112
    ABS=113
    VAR_ASSIGN=114
    PLUS_ASSIGN=115
    MINUS_ASSIGN=116
    MULT_ASSIGN=117
    DIV_ASSIGN=118
    MOD_ASSIGN=119
    AND_ASSIGN=120
    XOR_ASSIGN=121
    OR_ASSIGN=122
    STAR=123
    DIVIDE=124
    MODULE=125
    PLUS=126
    MINUSMINUS=127
    MINUS=128
    DIV=129
    MOD=130
    EQUAL_SYMBOL=131
    GREATER_SYMBOL=132
    LESS_SYMBOL=133
    EXCLAMATION_SYMBOL=134
    BIT_NOT_OP=135
    BIT_OR_OP=136
    BIT_AND_OP=137
    BIT_XOR_OP=138
    DOT=139
    LR_BRACKET=140
    RR_BRACKET=141
    LR_SQ_BRACKET=142
    RR_SQ_BRACKET=143
    COMMA=144
    SEMI=145
    AT_SIGN=146
    ZERO_DECIMAL=147
    ONE_DECIMAL=148
    TWO_DECIMAL=149
    SINGLE_QUOTE_SYMB=150
    DOUBLE_QUOTE_SYMB=151
    REVERSE_QUOTE_SYMB=152
    COLON_SYMB=153
    STRING_LITERAL=154
    DECIMAL_LITERAL=155
    REAL_LITERAL=156
    NULL_SPEC_LITERAL=157
    DOT_ID=158
    ID=159
    REVERSE_QUOTE_ID=160
    STRING_USER_NAME=161
    LOCAL_ID=162
    GLOBAL_ID=163
    ERROR_RECONGNIGION=164

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




    class RootContext(ParserRuleContext):

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

        def EOF(self):
            return self.getToken(evaql_parser.EOF, 0)

        def sqlStatements(self):
            return self.getTypedRuleContext(evaql_parser.SqlStatementsContext,0)


        def MINUSMINUS(self):
            return self.getToken(evaql_parser.MINUSMINUS, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_root

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

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

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




    def root(self):

        localctx = evaql_parser.RootContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_root)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 195
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 15)) & ~0x3f) == 0 and ((1 << (_la - 15)) & ((1 << (evaql_parser.CREATE - 15)) | (1 << (evaql_parser.DELETE - 15)) | (1 << (evaql_parser.DESCRIBE - 15)) | (1 << (evaql_parser.DROP - 15)) | (1 << (evaql_parser.INSERT - 15)) | (1 << (evaql_parser.LOAD - 15)) | (1 << (evaql_parser.SELECT - 15)) | (1 << (evaql_parser.UPDATE - 15)) | (1 << (evaql_parser.UPLOAD - 15)))) != 0) or _la==evaql_parser.HELP or _la==evaql_parser.SEMI:
                self.state = 194
                self.sqlStatements()


            self.state = 198
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.MINUSMINUS:
                self.state = 197
                self.match(evaql_parser.MINUSMINUS)


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


    class SqlStatementsContext(ParserRuleContext):

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

        def sqlStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.SqlStatementContext)
            else:
                return self.getTypedRuleContext(evaql_parser.SqlStatementContext,i)


        def emptyStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.EmptyStatementContext)
            else:
                return self.getTypedRuleContext(evaql_parser.EmptyStatementContext,i)


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

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

        def getRuleIndex(self):
            return evaql_parser.RULE_sqlStatements

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

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

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




    def sqlStatements(self):

        localctx = evaql_parser.SqlStatementsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_sqlStatements)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,4,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 209
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [evaql_parser.CREATE, evaql_parser.DELETE, evaql_parser.DESCRIBE, evaql_parser.DROP, evaql_parser.INSERT, evaql_parser.LOAD, evaql_parser.SELECT, evaql_parser.UPDATE, evaql_parser.UPLOAD, evaql_parser.HELP]:
                        self.state = 202
                        self.sqlStatement()
                        self.state = 204
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==evaql_parser.MINUSMINUS:
                            self.state = 203
                            self.match(evaql_parser.MINUSMINUS)


                        self.state = 206
                        self.match(evaql_parser.SEMI)
                        pass
                    elif token in [evaql_parser.SEMI]:
                        self.state = 208
                        self.emptyStatement()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 213
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,4,self._ctx)

            self.state = 222
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.CREATE, evaql_parser.DELETE, evaql_parser.DESCRIBE, evaql_parser.DROP, evaql_parser.INSERT, evaql_parser.LOAD, evaql_parser.SELECT, evaql_parser.UPDATE, evaql_parser.UPLOAD, evaql_parser.HELP]:
                self.state = 214
                self.sqlStatement()
                self.state = 219
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
                if la_ == 1:
                    self.state = 216
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==evaql_parser.MINUSMINUS:
                        self.state = 215
                        self.match(evaql_parser.MINUSMINUS)


                    self.state = 218
                    self.match(evaql_parser.SEMI)


                pass
            elif token in [evaql_parser.SEMI]:
                self.state = 221
                self.emptyStatement()
                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 SqlStatementContext(ParserRuleContext):

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

        def ddlStatement(self):
            return self.getTypedRuleContext(evaql_parser.DdlStatementContext,0)


        def dmlStatement(self):
            return self.getTypedRuleContext(evaql_parser.DmlStatementContext,0)


        def utilityStatement(self):
            return self.getTypedRuleContext(evaql_parser.UtilityStatementContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_sqlStatement

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

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

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




    def sqlStatement(self):

        localctx = evaql_parser.SqlStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_sqlStatement)
        try:
            self.state = 227
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.CREATE, evaql_parser.DROP]:
                self.enterOuterAlt(localctx, 1)
                self.state = 224
                self.ddlStatement()
                pass
            elif token in [evaql_parser.DELETE, evaql_parser.INSERT, evaql_parser.LOAD, evaql_parser.SELECT, evaql_parser.UPDATE, evaql_parser.UPLOAD]:
                self.enterOuterAlt(localctx, 2)
                self.state = 225
                self.dmlStatement()
                pass
            elif token in [evaql_parser.DESCRIBE, evaql_parser.HELP]:
                self.enterOuterAlt(localctx, 3)
                self.state = 226
                self.utilityStatement()
                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 EmptyStatementContext(ParserRuleContext):

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

        def SEMI(self):
            return self.getToken(evaql_parser.SEMI, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_emptyStatement

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

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

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




    def emptyStatement(self):

        localctx = evaql_parser.EmptyStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_emptyStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 229
            self.match(evaql_parser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DdlStatementContext(ParserRuleContext):

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

        def createDatabase(self):
            return self.getTypedRuleContext(evaql_parser.CreateDatabaseContext,0)


        def createTable(self):
            return self.getTypedRuleContext(evaql_parser.CreateTableContext,0)


        def createIndex(self):
            return self.getTypedRuleContext(evaql_parser.CreateIndexContext,0)


        def createUdf(self):
            return self.getTypedRuleContext(evaql_parser.CreateUdfContext,0)


        def dropDatabase(self):
            return self.getTypedRuleContext(evaql_parser.DropDatabaseContext,0)


        def dropTable(self):
            return self.getTypedRuleContext(evaql_parser.DropTableContext,0)


        def dropIndex(self):
            return self.getTypedRuleContext(evaql_parser.DropIndexContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_ddlStatement

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

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

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




    def ddlStatement(self):

        localctx = evaql_parser.DdlStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_ddlStatement)
        try:
            self.state = 238
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 231
                self.createDatabase()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 232
                self.createTable()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 233
                self.createIndex()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 234
                self.createUdf()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 235
                self.dropDatabase()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 236
                self.dropTable()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 237
                self.dropIndex()
                pass


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


    class DmlStatementContext(ParserRuleContext):

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

        def selectStatement(self):
            return self.getTypedRuleContext(evaql_parser.SelectStatementContext,0)


        def insertStatement(self):
            return self.getTypedRuleContext(evaql_parser.InsertStatementContext,0)


        def updateStatement(self):
            return self.getTypedRuleContext(evaql_parser.UpdateStatementContext,0)


        def deleteStatement(self):
            return self.getTypedRuleContext(evaql_parser.DeleteStatementContext,0)


        def loadStatement(self):
            return self.getTypedRuleContext(evaql_parser.LoadStatementContext,0)


        def uploadStatement(self):
            return self.getTypedRuleContext(evaql_parser.UploadStatementContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_dmlStatement

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

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

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




    def dmlStatement(self):

        localctx = evaql_parser.DmlStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_dmlStatement)
        try:
            self.state = 246
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.SELECT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 240
                self.selectStatement(0)
                pass
            elif token in [evaql_parser.INSERT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 241
                self.insertStatement()
                pass
            elif token in [evaql_parser.UPDATE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 242
                self.updateStatement()
                pass
            elif token in [evaql_parser.DELETE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 243
                self.deleteStatement()
                pass
            elif token in [evaql_parser.LOAD]:
                self.enterOuterAlt(localctx, 5)
                self.state = 244
                self.loadStatement()
                pass
            elif token in [evaql_parser.UPLOAD]:
                self.enterOuterAlt(localctx, 6)
                self.state = 245
                self.uploadStatement()
                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 UtilityStatementContext(ParserRuleContext):

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

        def simpleDescribeStatement(self):
            return self.getTypedRuleContext(evaql_parser.SimpleDescribeStatementContext,0)


        def helpStatement(self):
            return self.getTypedRuleContext(evaql_parser.HelpStatementContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_utilityStatement

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

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

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




    def utilityStatement(self):

        localctx = evaql_parser.UtilityStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_utilityStatement)
        try:
            self.state = 250
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.DESCRIBE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 248
                self.simpleDescribeStatement()
                pass
            elif token in [evaql_parser.HELP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 249
                self.helpStatement()
                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 CreateDatabaseContext(ParserRuleContext):

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

        def CREATE(self):
            return self.getToken(evaql_parser.CREATE, 0)

        def DATABASE(self):
            return self.getToken(evaql_parser.DATABASE, 0)

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def ifNotExists(self):
            return self.getTypedRuleContext(evaql_parser.IfNotExistsContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_createDatabase

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

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

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




    def createDatabase(self):

        localctx = evaql_parser.CreateDatabaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_createDatabase)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 252
            self.match(evaql_parser.CREATE)
            self.state = 253
            self.match(evaql_parser.DATABASE)
            self.state = 255
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.IF:
                self.state = 254
                self.ifNotExists()


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


    class CreateIndexContext(ParserRuleContext):

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

        def CREATE(self):
            return self.getToken(evaql_parser.CREATE, 0)

        def INDEX(self):
            return self.getToken(evaql_parser.INDEX, 0)

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def ON(self):
            return self.getToken(evaql_parser.ON, 0)

        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)


        def indexColumnNames(self):
            return self.getTypedRuleContext(evaql_parser.IndexColumnNamesContext,0)


        def indexType(self):
            return self.getTypedRuleContext(evaql_parser.IndexTypeContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_createIndex

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

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

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




    def createIndex(self):

        localctx = evaql_parser.CreateIndexContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_createIndex)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 259
            self.match(evaql_parser.CREATE)
            self.state = 260
            self.match(evaql_parser.INDEX)
            self.state = 261
            self.uid()
            self.state = 263
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.USING:
                self.state = 262
                self.indexType()


            self.state = 265
            self.match(evaql_parser.ON)
            self.state = 266
            self.tableName()
            self.state = 267
            self.indexColumnNames()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateTableContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_createTable

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



    class ColumnCreateTableContext(CreateTableContext):

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

        def CREATE(self):
            return self.getToken(evaql_parser.CREATE, 0)
        def TABLE(self):
            return self.getToken(evaql_parser.TABLE, 0)
        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)

        def createDefinitions(self):
            return self.getTypedRuleContext(evaql_parser.CreateDefinitionsContext,0)

        def ifNotExists(self):
            return self.getTypedRuleContext(evaql_parser.IfNotExistsContext,0)


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

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

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



    def createTable(self):

        localctx = evaql_parser.CreateTableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_createTable)
        self._la = 0 # Token type
        try:
            localctx = evaql_parser.ColumnCreateTableContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 269
            self.match(evaql_parser.CREATE)
            self.state = 270
            self.match(evaql_parser.TABLE)
            self.state = 272
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.IF:
                self.state = 271
                self.ifNotExists()


            self.state = 274
            self.tableName()
            self.state = 275
            self.createDefinitions()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateUdfContext(ParserRuleContext):

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

        def CREATE(self):
            return self.getToken(evaql_parser.CREATE, 0)

        def UDF(self):
            return self.getToken(evaql_parser.UDF, 0)

        def udfName(self):
            return self.getTypedRuleContext(evaql_parser.UdfNameContext,0)


        def INPUT(self):
            return self.getToken(evaql_parser.INPUT, 0)

        def createDefinitions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.CreateDefinitionsContext)
            else:
                return self.getTypedRuleContext(evaql_parser.CreateDefinitionsContext,i)


        def OUTPUT(self):
            return self.getToken(evaql_parser.OUTPUT, 0)

        def TYPE(self):
            return self.getToken(evaql_parser.TYPE, 0)

        def udfType(self):
            return self.getTypedRuleContext(evaql_parser.UdfTypeContext,0)


        def IMPL(self):
            return self.getToken(evaql_parser.IMPL, 0)

        def udfImpl(self):
            return self.getTypedRuleContext(evaql_parser.UdfImplContext,0)


        def ifNotExists(self):
            return self.getTypedRuleContext(evaql_parser.IfNotExistsContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_createUdf

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

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

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




    def createUdf(self):

        localctx = evaql_parser.CreateUdfContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_createUdf)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 277
            self.match(evaql_parser.CREATE)
            self.state = 278
            self.match(evaql_parser.UDF)
            self.state = 280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.IF:
                self.state = 279
                self.ifNotExists()


            self.state = 282
            self.udfName()
            self.state = 283
            self.match(evaql_parser.INPUT)
            self.state = 284
            self.createDefinitions()
            self.state = 285
            self.match(evaql_parser.OUTPUT)
            self.state = 286
            self.createDefinitions()
            self.state = 287
            self.match(evaql_parser.TYPE)
            self.state = 288
            self.udfType()
            self.state = 289
            self.match(evaql_parser.IMPL)
            self.state = 290
            self.udfImpl()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UdfNameContext(ParserRuleContext):

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

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_udfName

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

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

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




    def udfName(self):

        localctx = evaql_parser.UdfNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_udfName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 292
            self.uid()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UdfTypeContext(ParserRuleContext):

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

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_udfType

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

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

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




    def udfType(self):

        localctx = evaql_parser.UdfTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_udfType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 294
            self.uid()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UdfImplContext(ParserRuleContext):

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

        def stringLiteral(self):
            return self.getTypedRuleContext(evaql_parser.StringLiteralContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_udfImpl

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

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

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




    def udfImpl(self):

        localctx = evaql_parser.UdfImplContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_udfImpl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 296
            self.stringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IndexTypeContext(ParserRuleContext):

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

        def USING(self):
            return self.getToken(evaql_parser.USING, 0)

        def BTREE(self):
            return self.getToken(evaql_parser.BTREE, 0)

        def HASH(self):
            return self.getToken(evaql_parser.HASH, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_indexType

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

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

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




    def indexType(self):

        localctx = evaql_parser.IndexTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_indexType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self.match(evaql_parser.USING)
            self.state = 299
            _la = self._input.LA(1)
            if not(_la==evaql_parser.BTREE or _la==evaql_parser.HASH):
                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 CreateDefinitionsContext(ParserRuleContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def createDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.CreateDefinitionContext)
            else:
                return self.getTypedRuleContext(evaql_parser.CreateDefinitionContext,i)


        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

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

        def getRuleIndex(self):
            return evaql_parser.RULE_createDefinitions

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

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

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




    def createDefinitions(self):

        localctx = evaql_parser.CreateDefinitionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_createDefinitions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 301
            self.match(evaql_parser.LR_BRACKET)
            self.state = 302
            self.createDefinition()
            self.state = 307
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 303
                self.match(evaql_parser.COMMA)
                self.state = 304
                self.createDefinition()
                self.state = 309
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 310
            self.match(evaql_parser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateDefinitionContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_createDefinition

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



    class ColumnDeclarationContext(CreateDefinitionContext):

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

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)

        def columnDefinition(self):
            return self.getTypedRuleContext(evaql_parser.ColumnDefinitionContext,0)


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

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

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


    class IndexDeclarationContext(CreateDefinitionContext):

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

        def indexColumnDefinition(self):
            return self.getTypedRuleContext(evaql_parser.IndexColumnDefinitionContext,0)


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

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

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



    def createDefinition(self):

        localctx = evaql_parser.CreateDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_createDefinition)
        try:
            self.state = 316
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.ID, evaql_parser.REVERSE_QUOTE_ID]:
                localctx = evaql_parser.ColumnDeclarationContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 312
                self.uid()
                self.state = 313
                self.columnDefinition()
                pass
            elif token in [evaql_parser.INDEX]:
                localctx = evaql_parser.IndexDeclarationContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 315
                self.indexColumnDefinition()
                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 ColumnDefinitionContext(ParserRuleContext):

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

        def dataType(self):
            return self.getTypedRuleContext(evaql_parser.DataTypeContext,0)


        def columnConstraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ColumnConstraintContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ColumnConstraintContext,i)


        def getRuleIndex(self):
            return evaql_parser.RULE_columnDefinition

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

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

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




    def columnDefinition(self):

        localctx = evaql_parser.ColumnDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_columnDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 318
            self.dataType()
            self.state = 322
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << evaql_parser.DEFAULT) | (1 << evaql_parser.KEY) | (1 << evaql_parser.NOT) | (1 << evaql_parser.NULL_LITERAL) | (1 << evaql_parser.PRIMARY) | (1 << evaql_parser.UNIQUE))) != 0) or _la==evaql_parser.NULL_SPEC_LITERAL:
                self.state = 319
                self.columnConstraint()
                self.state = 324
                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 ColumnConstraintContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_columnConstraint

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



    class PrimaryKeyColumnConstraintContext(ColumnConstraintContext):

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

        def KEY(self):
            return self.getToken(evaql_parser.KEY, 0)
        def PRIMARY(self):
            return self.getToken(evaql_parser.PRIMARY, 0)

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

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

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


    class UniqueKeyColumnConstraintContext(ColumnConstraintContext):

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

        def UNIQUE(self):
            return self.getToken(evaql_parser.UNIQUE, 0)
        def KEY(self):
            return self.getToken(evaql_parser.KEY, 0)

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

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

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


    class NullColumnConstraintContext(ColumnConstraintContext):

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

        def nullNotnull(self):
            return self.getTypedRuleContext(evaql_parser.NullNotnullContext,0)


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

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

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


    class DefaultColumnConstraintContext(ColumnConstraintContext):

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

        def DEFAULT(self):
            return self.getToken(evaql_parser.DEFAULT, 0)
        def defaultValue(self):
            return self.getTypedRuleContext(evaql_parser.DefaultValueContext,0)


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

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

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



    def columnConstraint(self):

        localctx = evaql_parser.ColumnConstraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_columnConstraint)
        self._la = 0 # Token type
        try:
            self.state = 336
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.NOT, evaql_parser.NULL_LITERAL, evaql_parser.NULL_SPEC_LITERAL]:
                localctx = evaql_parser.NullColumnConstraintContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 325
                self.nullNotnull()
                pass
            elif token in [evaql_parser.DEFAULT]:
                localctx = evaql_parser.DefaultColumnConstraintContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 326
                self.match(evaql_parser.DEFAULT)
                self.state = 327
                self.defaultValue()
                pass
            elif token in [evaql_parser.KEY, evaql_parser.PRIMARY]:
                localctx = evaql_parser.PrimaryKeyColumnConstraintContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 329
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.PRIMARY:
                    self.state = 328
                    self.match(evaql_parser.PRIMARY)


                self.state = 331
                self.match(evaql_parser.KEY)
                pass
            elif token in [evaql_parser.UNIQUE]:
                localctx = evaql_parser.UniqueKeyColumnConstraintContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 332
                self.match(evaql_parser.UNIQUE)
                self.state = 334
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
                if la_ == 1:
                    self.state = 333
                    self.match(evaql_parser.KEY)


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

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


        def getRuleIndex(self):
            return evaql_parser.RULE_indexColumnDefinition

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



    class SimpleIndexDeclarationContext(IndexColumnDefinitionContext):

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

        def INDEX(self):
            return self.getToken(evaql_parser.INDEX, 0)
        def indexColumnNames(self):
            return self.getTypedRuleContext(evaql_parser.IndexColumnNamesContext,0)

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)

        def indexType(self):
            return self.getTypedRuleContext(evaql_parser.IndexTypeContext,0)


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

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

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



    def indexColumnDefinition(self):

        localctx = evaql_parser.IndexColumnDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_indexColumnDefinition)
        self._la = 0 # Token type
        try:
            localctx = evaql_parser.SimpleIndexDeclarationContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 338
            self.match(evaql_parser.INDEX)
            self.state = 340
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.ID or _la==evaql_parser.REVERSE_QUOTE_ID:
                self.state = 339
                self.uid()


            self.state = 343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.USING:
                self.state = 342
                self.indexType()


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


    class DropDatabaseContext(ParserRuleContext):

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

        def DROP(self):
            return self.getToken(evaql_parser.DROP, 0)

        def DATABASE(self):
            return self.getToken(evaql_parser.DATABASE, 0)

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def ifExists(self):
            return self.getTypedRuleContext(evaql_parser.IfExistsContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_dropDatabase

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

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

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




    def dropDatabase(self):

        localctx = evaql_parser.DropDatabaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_dropDatabase)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 347
            self.match(evaql_parser.DROP)
            self.state = 348
            self.match(evaql_parser.DATABASE)
            self.state = 350
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.IF:
                self.state = 349
                self.ifExists()


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


    class DropIndexContext(ParserRuleContext):

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

        def DROP(self):
            return self.getToken(evaql_parser.DROP, 0)

        def INDEX(self):
            return self.getToken(evaql_parser.INDEX, 0)

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def ON(self):
            return self.getToken(evaql_parser.ON, 0)

        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_dropIndex

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

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

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




    def dropIndex(self):

        localctx = evaql_parser.DropIndexContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_dropIndex)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 354
            self.match(evaql_parser.DROP)
            self.state = 355
            self.match(evaql_parser.INDEX)
            self.state = 356
            self.uid()
            self.state = 357
            self.match(evaql_parser.ON)
            self.state = 358
            self.tableName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DropTableContext(ParserRuleContext):

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

        def DROP(self):
            return self.getToken(evaql_parser.DROP, 0)

        def TABLE(self):
            return self.getToken(evaql_parser.TABLE, 0)

        def tables(self):
            return self.getTypedRuleContext(evaql_parser.TablesContext,0)


        def ifExists(self):
            return self.getTypedRuleContext(evaql_parser.IfExistsContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_dropTable

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

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

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




    def dropTable(self):

        localctx = evaql_parser.DropTableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_dropTable)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 360
            self.match(evaql_parser.DROP)
            self.state = 361
            self.match(evaql_parser.TABLE)
            self.state = 363
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.IF:
                self.state = 362
                self.ifExists()


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


    class DeleteStatementContext(ParserRuleContext):

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

        def singleDeleteStatement(self):
            return self.getTypedRuleContext(evaql_parser.SingleDeleteStatementContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_deleteStatement

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

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

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




    def deleteStatement(self):

        localctx = evaql_parser.DeleteStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_deleteStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 367
            self.singleDeleteStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InsertStatementContext(ParserRuleContext):

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

        def INSERT(self):
            return self.getToken(evaql_parser.INSERT, 0)

        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)


        def insertStatementValue(self):
            return self.getTypedRuleContext(evaql_parser.InsertStatementValueContext,0)


        def INTO(self):
            return self.getToken(evaql_parser.INTO, 0)

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

        def uidList(self):
            return self.getTypedRuleContext(evaql_parser.UidListContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_insertStatement

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

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

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




    def insertStatement(self):

        localctx = evaql_parser.InsertStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_insertStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 369
            self.match(evaql_parser.INSERT)
            self.state = 371
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.INTO:
                self.state = 370
                self.match(evaql_parser.INTO)


            self.state = 373
            self.tableName()

            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.LR_BRACKET:
                self.state = 374
                self.match(evaql_parser.LR_BRACKET)
                self.state = 375
                localctx.columns = self.uidList()
                self.state = 376
                self.match(evaql_parser.RR_BRACKET)


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


    class SelectStatementContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_selectStatement

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


    class UnionSelectContext(SelectStatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a evaql_parser.SelectStatementContext
            super().__init__(parser)
            self.left = None # SelectStatementContext
            self.unionAll = None # Token
            self.right = None # SelectStatementContext
            self.copyFrom(ctx)

        def UNION(self):
            return self.getToken(evaql_parser.UNION, 0)
        def selectStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.SelectStatementContext)
            else:
                return self.getTypedRuleContext(evaql_parser.SelectStatementContext,i)

        def ALL(self):
            return self.getToken(evaql_parser.ALL, 0)

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

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

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


    class SimpleSelectContext(SelectStatementContext):

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

        def querySpecification(self):
            return self.getTypedRuleContext(evaql_parser.QuerySpecificationContext,0)


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

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

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



    def selectStatement(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = evaql_parser.SelectStatementContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 50
        self.enterRecursionRule(localctx, 50, self.RULE_selectStatement, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = evaql_parser.SimpleSelectContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 383
            self.querySpecification()
            self._ctx.stop = self._input.LT(-1)
            self.state = 393
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = evaql_parser.UnionSelectContext(self, evaql_parser.SelectStatementContext(self, _parentctx, _parentState))
                    localctx.left = _prevctx
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_selectStatement)
                    self.state = 385
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 386
                    self.match(evaql_parser.UNION)
                    self.state = 388
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==evaql_parser.ALL:
                        self.state = 387
                        localctx.unionAll = self.match(evaql_parser.ALL)


                    self.state = 390
                    localctx.right = self.selectStatement(2) 
                self.state = 395
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,29,self._ctx)

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


    class UpdateStatementContext(ParserRuleContext):

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

        def singleUpdateStatement(self):
            return self.getTypedRuleContext(evaql_parser.SingleUpdateStatementContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_updateStatement

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

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

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




    def updateStatement(self):

        localctx = evaql_parser.UpdateStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_updateStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 396
            self.singleUpdateStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LoadStatementContext(ParserRuleContext):

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

        def LOAD(self):
            return self.getToken(evaql_parser.LOAD, 0)

        def DATA(self):
            return self.getToken(evaql_parser.DATA, 0)

        def INFILE(self):
            return self.getToken(evaql_parser.INFILE, 0)

        def fileName(self):
            return self.getTypedRuleContext(evaql_parser.FileNameContext,0)


        def INTO(self):
            return self.getToken(evaql_parser.INTO, 0)

        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_loadStatement

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

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

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




    def loadStatement(self):

        localctx = evaql_parser.LoadStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_loadStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 398
            self.match(evaql_parser.LOAD)
            self.state = 399
            self.match(evaql_parser.DATA)
            self.state = 400
            self.match(evaql_parser.INFILE)
            self.state = 401
            self.fileName()
            self.state = 402
            self.match(evaql_parser.INTO)
            self.state = 403
            self.tableName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UploadStatementContext(ParserRuleContext):

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

        def UPLOAD(self):
            return self.getToken(evaql_parser.UPLOAD, 0)

        def PATH(self):
            return self.getToken(evaql_parser.PATH, 0)

        def fileName(self):
            return self.getTypedRuleContext(evaql_parser.FileNameContext,0)


        def BLOB(self):
            return self.getToken(evaql_parser.BLOB, 0)

        def videoBlob(self):
            return self.getTypedRuleContext(evaql_parser.VideoBlobContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_uploadStatement

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

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

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




    def uploadStatement(self):

        localctx = evaql_parser.UploadStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_uploadStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 405
            self.match(evaql_parser.UPLOAD)
            self.state = 406
            self.match(evaql_parser.PATH)
            self.state = 407
            self.fileName()
            self.state = 408
            self.match(evaql_parser.BLOB)
            self.state = 409
            self.videoBlob()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FileNameContext(ParserRuleContext):

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

        def stringLiteral(self):
            return self.getTypedRuleContext(evaql_parser.StringLiteralContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_fileName

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

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

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




    def fileName(self):

        localctx = evaql_parser.FileNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_fileName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 411
            self.stringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VideoBlobContext(ParserRuleContext):

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

        def stringLiteral(self):
            return self.getTypedRuleContext(evaql_parser.StringLiteralContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_videoBlob

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

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

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




    def videoBlob(self):

        localctx = evaql_parser.VideoBlobContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_videoBlob)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 413
            self.stringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InsertStatementValueContext(ParserRuleContext):

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

        def selectStatement(self):
            return self.getTypedRuleContext(evaql_parser.SelectStatementContext,0)


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

        def expressionsWithDefaults(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionsWithDefaultsContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionsWithDefaultsContext,i)


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

        def VALUES(self):
            return self.getToken(evaql_parser.VALUES, 0)

        def VALUE(self):
            return self.getToken(evaql_parser.VALUE, 0)

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

        def getRuleIndex(self):
            return evaql_parser.RULE_insertStatementValue

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

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

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




    def insertStatementValue(self):

        localctx = evaql_parser.InsertStatementValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_insertStatementValue)
        self._la = 0 # Token type
        try:
            self.state = 430
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.SELECT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 415
                self.selectStatement(0)
                pass
            elif token in [evaql_parser.VALUES, evaql_parser.VALUE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 416
                localctx.insertFormat = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==evaql_parser.VALUES or _la==evaql_parser.VALUE):
                    localctx.insertFormat = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 417
                self.match(evaql_parser.LR_BRACKET)
                self.state = 418
                self.expressionsWithDefaults()
                self.state = 419
                self.match(evaql_parser.RR_BRACKET)
                self.state = 427
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==evaql_parser.COMMA:
                    self.state = 420
                    self.match(evaql_parser.COMMA)
                    self.state = 421
                    self.match(evaql_parser.LR_BRACKET)
                    self.state = 422
                    self.expressionsWithDefaults()
                    self.state = 423
                    self.match(evaql_parser.RR_BRACKET)
                    self.state = 429
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

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

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

        def fullColumnName(self):
            return self.getTypedRuleContext(evaql_parser.FullColumnNameContext,0)


        def EQUAL_SYMBOL(self):
            return self.getToken(evaql_parser.EQUAL_SYMBOL, 0)

        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)


        def DEFAULT(self):
            return self.getToken(evaql_parser.DEFAULT, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_updatedElement

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

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

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




    def updatedElement(self):

        localctx = evaql_parser.UpdatedElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_updatedElement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 432
            self.fullColumnName()
            self.state = 433
            self.match(evaql_parser.EQUAL_SYMBOL)
            self.state = 436
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.ANYDIM, evaql_parser.FALSE, evaql_parser.NOT, evaql_parser.NULL_LITERAL, evaql_parser.TRUE, evaql_parser.AVG, evaql_parser.COUNT, evaql_parser.MAX, evaql_parser.MIN, evaql_parser.SUM, evaql_parser.PLUS, evaql_parser.MINUS, evaql_parser.EXCLAMATION_SYMBOL, evaql_parser.BIT_NOT_OP, evaql_parser.LR_BRACKET, evaql_parser.LR_SQ_BRACKET, evaql_parser.ZERO_DECIMAL, evaql_parser.ONE_DECIMAL, evaql_parser.TWO_DECIMAL, evaql_parser.STRING_LITERAL, evaql_parser.DECIMAL_LITERAL, evaql_parser.REAL_LITERAL, evaql_parser.NULL_SPEC_LITERAL, evaql_parser.ID, evaql_parser.REVERSE_QUOTE_ID, evaql_parser.LOCAL_ID]:
                self.state = 434
                self.expression(0)
                pass
            elif token in [evaql_parser.DEFAULT]:
                self.state = 435
                self.match(evaql_parser.DEFAULT)
                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 SingleDeleteStatementContext(ParserRuleContext):

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

        def DELETE(self):
            return self.getToken(evaql_parser.DELETE, 0)

        def FROM(self):
            return self.getToken(evaql_parser.FROM, 0)

        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)


        def WHERE(self):
            return self.getToken(evaql_parser.WHERE, 0)

        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)


        def orderByClause(self):
            return self.getTypedRuleContext(evaql_parser.OrderByClauseContext,0)


        def LIMIT(self):
            return self.getToken(evaql_parser.LIMIT, 0)

        def decimalLiteral(self):
            return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_singleDeleteStatement

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

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

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




    def singleDeleteStatement(self):

        localctx = evaql_parser.SingleDeleteStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_singleDeleteStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 438
            self.match(evaql_parser.DELETE)
            self.state = 439
            self.match(evaql_parser.FROM)
            self.state = 440
            self.tableName()
            self.state = 443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.WHERE:
                self.state = 441
                self.match(evaql_parser.WHERE)
                self.state = 442
                self.expression(0)


            self.state = 446
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.ORDER:
                self.state = 445
                self.orderByClause()


            self.state = 450
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.LIMIT:
                self.state = 448
                self.match(evaql_parser.LIMIT)
                self.state = 449
                self.decimalLiteral()


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


    class SingleUpdateStatementContext(ParserRuleContext):

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

        def UPDATE(self):
            return self.getToken(evaql_parser.UPDATE, 0)

        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)


        def SET(self):
            return self.getToken(evaql_parser.SET, 0)

        def updatedElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.UpdatedElementContext)
            else:
                return self.getTypedRuleContext(evaql_parser.UpdatedElementContext,i)


        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


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

        def WHERE(self):
            return self.getToken(evaql_parser.WHERE, 0)

        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)


        def orderByClause(self):
            return self.getTypedRuleContext(evaql_parser.OrderByClauseContext,0)


        def limitClause(self):
            return self.getTypedRuleContext(evaql_parser.LimitClauseContext,0)


        def AS(self):
            return self.getToken(evaql_parser.AS, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_singleUpdateStatement

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

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

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




    def singleUpdateStatement(self):

        localctx = evaql_parser.SingleUpdateStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_singleUpdateStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 452
            self.match(evaql_parser.UPDATE)
            self.state = 453
            self.tableName()
            self.state = 458
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.AS or _la==evaql_parser.ID or _la==evaql_parser.REVERSE_QUOTE_ID:
                self.state = 455
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.AS:
                    self.state = 454
                    self.match(evaql_parser.AS)


                self.state = 457
                self.uid()


            self.state = 460
            self.match(evaql_parser.SET)
            self.state = 461
            self.updatedElement()
            self.state = 466
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 462
                self.match(evaql_parser.COMMA)
                self.state = 463
                self.updatedElement()
                self.state = 468
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 471
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.WHERE:
                self.state = 469
                self.match(evaql_parser.WHERE)
                self.state = 470
                self.expression(0)


            self.state = 474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.ORDER:
                self.state = 473
                self.orderByClause()


            self.state = 477
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.LIMIT:
                self.state = 476
                self.limitClause()


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


    class OrderByClauseContext(ParserRuleContext):

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

        def ORDER(self):
            return self.getToken(evaql_parser.ORDER, 0)

        def BY(self):
            return self.getToken(evaql_parser.BY, 0)

        def orderByExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.OrderByExpressionContext)
            else:
                return self.getTypedRuleContext(evaql_parser.OrderByExpressionContext,i)


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

        def getRuleIndex(self):
            return evaql_parser.RULE_orderByClause

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

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

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




    def orderByClause(self):

        localctx = evaql_parser.OrderByClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_orderByClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 479
            self.match(evaql_parser.ORDER)
            self.state = 480
            self.match(evaql_parser.BY)
            self.state = 481
            self.orderByExpression()
            self.state = 486
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,42,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 482
                    self.match(evaql_parser.COMMA)
                    self.state = 483
                    self.orderByExpression() 
                self.state = 488
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,42,self._ctx)

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


    class OrderByExpressionContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)


        def ASC(self):
            return self.getToken(evaql_parser.ASC, 0)

        def DESC(self):
            return self.getToken(evaql_parser.DESC, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_orderByExpression

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

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

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




    def orderByExpression(self):

        localctx = evaql_parser.OrderByExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_orderByExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 489
            self.expression(0)
            self.state = 491
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.state = 490
                localctx.order = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==evaql_parser.ASC or _la==evaql_parser.DESC):
                    localctx.order = 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 TableSourcesContext(ParserRuleContext):

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

        def tableSource(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.TableSourceContext)
            else:
                return self.getTypedRuleContext(evaql_parser.TableSourceContext,i)


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

        def getRuleIndex(self):
            return evaql_parser.RULE_tableSources

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

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

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




    def tableSources(self):

        localctx = evaql_parser.TableSourcesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_tableSources)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 493
            self.tableSource()
            self.state = 498
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,44,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 494
                    self.match(evaql_parser.COMMA)
                    self.state = 495
                    self.tableSource() 
                self.state = 500
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,44,self._ctx)

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


    class TableSourceContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_tableSource

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



    class TableSourceBaseContext(TableSourceContext):

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

        def tableSourceItemWithSample(self):
            return self.getTypedRuleContext(evaql_parser.TableSourceItemWithSampleContext,0)

        def joinPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.JoinPartContext)
            else:
                return self.getTypedRuleContext(evaql_parser.JoinPartContext,i)


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

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

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



    def tableSource(self):

        localctx = evaql_parser.TableSourceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_tableSource)
        try:
            localctx = evaql_parser.TableSourceBaseContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 501
            self.tableSourceItemWithSample()
            self.state = 505
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 502
                    self.joinPart() 
                self.state = 507
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,45,self._ctx)

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


    class TableSourceItemWithSampleContext(ParserRuleContext):

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

        def tableSourceItem(self):
            return self.getTypedRuleContext(evaql_parser.TableSourceItemContext,0)


        def sampleClause(self):
            return self.getTypedRuleContext(evaql_parser.SampleClauseContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_tableSourceItemWithSample

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

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

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




    def tableSourceItemWithSample(self):

        localctx = evaql_parser.TableSourceItemWithSampleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_tableSourceItemWithSample)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 508
            self.tableSourceItem()
            self.state = 510
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
            if la_ == 1:
                self.state = 509
                self.sampleClause()


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


    class TableSourceItemContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_tableSourceItem

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



    class SubqueryTableItemContext(TableSourceItemContext):

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

        def selectStatement(self):
            return self.getTypedRuleContext(evaql_parser.SelectStatementContext,0)

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)
        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

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

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

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


    class AtomTableItemContext(TableSourceItemContext):

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

        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)


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

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

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



    def tableSourceItem(self):

        localctx = evaql_parser.TableSourceItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_tableSourceItem)
        try:
            self.state = 520
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.ID, evaql_parser.REVERSE_QUOTE_ID]:
                localctx = evaql_parser.AtomTableItemContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 512
                self.tableName()
                pass
            elif token in [evaql_parser.SELECT, evaql_parser.LR_BRACKET]:
                localctx = evaql_parser.SubqueryTableItemContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 518
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [evaql_parser.SELECT]:
                    self.state = 513
                    self.selectStatement(0)
                    pass
                elif token in [evaql_parser.LR_BRACKET]:
                    self.state = 514
                    self.match(evaql_parser.LR_BRACKET)
                    self.state = 515
                    self.selectStatement(0)
                    self.state = 516
                    self.match(evaql_parser.RR_BRACKET)
                    pass
                else:
                    raise NoViableAltException(self)

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

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

        def SAMPLE(self):
            return self.getToken(evaql_parser.SAMPLE, 0)

        def decimalLiteral(self):
            return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_sampleClause

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

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

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




    def sampleClause(self):

        localctx = evaql_parser.SampleClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_sampleClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 522
            self.match(evaql_parser.SAMPLE)
            self.state = 523
            self.decimalLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JoinPartContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_joinPart

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



    class InnerJoinContext(JoinPartContext):

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

        def JOIN(self):
            return self.getToken(evaql_parser.JOIN, 0)
        def tableSourceItemWithSample(self):
            return self.getTypedRuleContext(evaql_parser.TableSourceItemWithSampleContext,0)

        def ON(self):
            return self.getToken(evaql_parser.ON, 0)
        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)

        def USING(self):
            return self.getToken(evaql_parser.USING, 0)
        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)
        def uidList(self):
            return self.getTypedRuleContext(evaql_parser.UidListContext,0)

        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

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

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

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



    def joinPart(self):

        localctx = evaql_parser.JoinPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_joinPart)
        try:
            localctx = evaql_parser.InnerJoinContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 525
            self.match(evaql_parser.JOIN)
            self.state = 526
            self.tableSourceItemWithSample()
            self.state = 534
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.state = 527
                self.match(evaql_parser.ON)
                self.state = 528
                self.expression(0)

            elif la_ == 2:
                self.state = 529
                self.match(evaql_parser.USING)
                self.state = 530
                self.match(evaql_parser.LR_BRACKET)
                self.state = 531
                self.uidList()
                self.state = 532
                self.match(evaql_parser.RR_BRACKET)


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


    class QueryExpressionContext(ParserRuleContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def querySpecification(self):
            return self.getTypedRuleContext(evaql_parser.QuerySpecificationContext,0)


        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

        def queryExpression(self):
            return self.getTypedRuleContext(evaql_parser.QueryExpressionContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_queryExpression

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

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

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




    def queryExpression(self):

        localctx = evaql_parser.QueryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_queryExpression)
        try:
            self.state = 544
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 536
                self.match(evaql_parser.LR_BRACKET)
                self.state = 537
                self.querySpecification()
                self.state = 538
                self.match(evaql_parser.RR_BRACKET)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 540
                self.match(evaql_parser.LR_BRACKET)
                self.state = 541
                self.queryExpression()
                self.state = 542
                self.match(evaql_parser.RR_BRACKET)
                pass


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


    class QuerySpecificationContext(ParserRuleContext):

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

        def SELECT(self):
            return self.getToken(evaql_parser.SELECT, 0)

        def selectElements(self):
            return self.getTypedRuleContext(evaql_parser.SelectElementsContext,0)


        def fromClause(self):
            return self.getTypedRuleContext(evaql_parser.FromClauseContext,0)


        def orderByClause(self):
            return self.getTypedRuleContext(evaql_parser.OrderByClauseContext,0)


        def limitClause(self):
            return self.getTypedRuleContext(evaql_parser.LimitClauseContext,0)


        def errorBoundsExpression(self):
            return self.getTypedRuleContext(evaql_parser.ErrorBoundsExpressionContext,0)


        def confidenceLevelExpression(self):
            return self.getTypedRuleContext(evaql_parser.ConfidenceLevelExpressionContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_querySpecification

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

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

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




    def querySpecification(self):

        localctx = evaql_parser.QuerySpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_querySpecification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            self.match(evaql_parser.SELECT)
            self.state = 547
            self.selectElements()
            self.state = 548
            self.fromClause()
            self.state = 550
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
            if la_ == 1:
                self.state = 549
                self.orderByClause()


            self.state = 553
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.state = 552
                self.limitClause()


            self.state = 556
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
            if la_ == 1:
                self.state = 555
                self.errorBoundsExpression()


            self.state = 559
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.state = 558
                self.confidenceLevelExpression()


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


    class SelectElementsContext(ParserRuleContext):

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

        def selectElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.SelectElementContext)
            else:
                return self.getTypedRuleContext(evaql_parser.SelectElementContext,i)


        def STAR(self):
            return self.getToken(evaql_parser.STAR, 0)

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

        def getRuleIndex(self):
            return evaql_parser.RULE_selectElements

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

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

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




    def selectElements(self):

        localctx = evaql_parser.SelectElementsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_selectElements)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 563
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.STAR]:
                self.state = 561
                localctx.star = self.match(evaql_parser.STAR)
                pass
            elif token in [evaql_parser.ANYDIM, evaql_parser.FALSE, evaql_parser.NOT, evaql_parser.NULL_LITERAL, evaql_parser.TRUE, evaql_parser.AVG, evaql_parser.COUNT, evaql_parser.MAX, evaql_parser.MIN, evaql_parser.SUM, evaql_parser.PLUS, evaql_parser.MINUS, evaql_parser.EXCLAMATION_SYMBOL, evaql_parser.BIT_NOT_OP, evaql_parser.LR_BRACKET, evaql_parser.LR_SQ_BRACKET, evaql_parser.ZERO_DECIMAL, evaql_parser.ONE_DECIMAL, evaql_parser.TWO_DECIMAL, evaql_parser.STRING_LITERAL, evaql_parser.DECIMAL_LITERAL, evaql_parser.REAL_LITERAL, evaql_parser.NULL_SPEC_LITERAL, evaql_parser.ID, evaql_parser.REVERSE_QUOTE_ID, evaql_parser.LOCAL_ID]:
                self.state = 562
                self.selectElement()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 569
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 565
                self.match(evaql_parser.COMMA)
                self.state = 566
                self.selectElement()
                self.state = 571
                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 SelectElementContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_selectElement

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



    class SelectExpressionElementContext(SelectElementContext):

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

        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)

        def LOCAL_ID(self):
            return self.getToken(evaql_parser.LOCAL_ID, 0)
        def VAR_ASSIGN(self):
            return self.getToken(evaql_parser.VAR_ASSIGN, 0)
        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)

        def AS(self):
            return self.getToken(evaql_parser.AS, 0)

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

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

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


    class SelectFunctionElementContext(SelectElementContext):

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

        def functionCall(self):
            return self.getTypedRuleContext(evaql_parser.FunctionCallContext,0)

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)

        def AS(self):
            return self.getToken(evaql_parser.AS, 0)

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

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

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


    class SelectStarElementContext(SelectElementContext):

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

        def fullId(self):
            return self.getTypedRuleContext(evaql_parser.FullIdContext,0)

        def DOT(self):
            return self.getToken(evaql_parser.DOT, 0)
        def STAR(self):
            return self.getToken(evaql_parser.STAR, 0)

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

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

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


    class SelectColumnElementContext(SelectElementContext):

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

        def fullColumnName(self):
            return self.getTypedRuleContext(evaql_parser.FullColumnNameContext,0)

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)

        def AS(self):
            return self.getToken(evaql_parser.AS, 0)

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

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

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



    def selectElement(self):

        localctx = evaql_parser.SelectElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_selectElement)
        self._la = 0 # Token type
        try:
            self.state = 601
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
            if la_ == 1:
                localctx = evaql_parser.SelectStarElementContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 572
                self.fullId()
                self.state = 573
                self.match(evaql_parser.DOT)
                self.state = 574
                self.match(evaql_parser.STAR)
                pass

            elif la_ == 2:
                localctx = evaql_parser.SelectColumnElementContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 576
                self.fullColumnName()
                self.state = 581
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.AS or _la==evaql_parser.ID or _la==evaql_parser.REVERSE_QUOTE_ID:
                    self.state = 578
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==evaql_parser.AS:
                        self.state = 577
                        self.match(evaql_parser.AS)


                    self.state = 580
                    self.uid()


                pass

            elif la_ == 3:
                localctx = evaql_parser.SelectFunctionElementContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 583
                self.functionCall()
                self.state = 588
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.AS or _la==evaql_parser.ID or _la==evaql_parser.REVERSE_QUOTE_ID:
                    self.state = 585
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==evaql_parser.AS:
                        self.state = 584
                        self.match(evaql_parser.AS)


                    self.state = 587
                    self.uid()


                pass

            elif la_ == 4:
                localctx = evaql_parser.SelectExpressionElementContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 592
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
                if la_ == 1:
                    self.state = 590
                    self.match(evaql_parser.LOCAL_ID)
                    self.state = 591
                    self.match(evaql_parser.VAR_ASSIGN)


                self.state = 594
                self.expression(0)
                self.state = 599
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.AS or _la==evaql_parser.ID or _la==evaql_parser.REVERSE_QUOTE_ID:
                    self.state = 596
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==evaql_parser.AS:
                        self.state = 595
                        self.match(evaql_parser.AS)


                    self.state = 598
                    self.uid()


                pass


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


    class FromClauseContext(ParserRuleContext):

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

        def FROM(self):
            return self.getToken(evaql_parser.FROM, 0)

        def tableSources(self):
            return self.getTypedRuleContext(evaql_parser.TableSourcesContext,0)


        def WHERE(self):
            return self.getToken(evaql_parser.WHERE, 0)

        def GROUP(self):
            return self.getToken(evaql_parser.GROUP, 0)

        def BY(self):
            return self.getToken(evaql_parser.BY, 0)

        def groupByItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.GroupByItemContext)
            else:
                return self.getTypedRuleContext(evaql_parser.GroupByItemContext,i)


        def HAVING(self):
            return self.getToken(evaql_parser.HAVING, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return evaql_parser.RULE_fromClause

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

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

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




    def fromClause(self):

        localctx = evaql_parser.FromClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_fromClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 603
            self.match(evaql_parser.FROM)
            self.state = 604
            self.tableSources()
            self.state = 607
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
            if la_ == 1:
                self.state = 605
                self.match(evaql_parser.WHERE)
                self.state = 606
                localctx.whereExpr = self.expression(0)


            self.state = 619
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
            if la_ == 1:
                self.state = 609
                self.match(evaql_parser.GROUP)
                self.state = 610
                self.match(evaql_parser.BY)
                self.state = 611
                self.groupByItem()
                self.state = 616
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 612
                        self.match(evaql_parser.COMMA)
                        self.state = 613
                        self.groupByItem() 
                    self.state = 618
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,66,self._ctx)



            self.state = 623
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
            if la_ == 1:
                self.state = 621
                self.match(evaql_parser.HAVING)
                self.state = 622
                localctx.havingExpr = self.expression(0)


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


    class GroupByItemContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)


        def ASC(self):
            return self.getToken(evaql_parser.ASC, 0)

        def DESC(self):
            return self.getToken(evaql_parser.DESC, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_groupByItem

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

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

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




    def groupByItem(self):

        localctx = evaql_parser.GroupByItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_groupByItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 625
            self.expression(0)
            self.state = 627
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.state = 626
                localctx.order = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==evaql_parser.ASC or _la==evaql_parser.DESC):
                    localctx.order = 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 LimitClauseContext(ParserRuleContext):

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

        def LIMIT(self):
            return self.getToken(evaql_parser.LIMIT, 0)

        def OFFSET(self):
            return self.getToken(evaql_parser.OFFSET, 0)

        def decimalLiteral(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.DecimalLiteralContext)
            else:
                return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,i)


        def COMMA(self):
            return self.getToken(evaql_parser.COMMA, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_limitClause

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

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

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




    def limitClause(self):

        localctx = evaql_parser.LimitClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_limitClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 629
            self.match(evaql_parser.LIMIT)
            self.state = 640
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 633
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
                if la_ == 1:
                    self.state = 630
                    localctx.offset = self.decimalLiteral()
                    self.state = 631
                    self.match(evaql_parser.COMMA)


                self.state = 635
                localctx.limit = self.decimalLiteral()
                pass

            elif la_ == 2:
                self.state = 636
                localctx.limit = self.decimalLiteral()
                self.state = 637
                self.match(evaql_parser.OFFSET)
                self.state = 638
                localctx.offset = self.decimalLiteral()
                pass


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


    class ErrorBoundsExpressionContext(ParserRuleContext):

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

        def ERROR_BOUNDS(self):
            return self.getToken(evaql_parser.ERROR_BOUNDS, 0)

        def REAL_LITERAL(self):
            return self.getToken(evaql_parser.REAL_LITERAL, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_errorBoundsExpression

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

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

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




    def errorBoundsExpression(self):

        localctx = evaql_parser.ErrorBoundsExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_errorBoundsExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 642
            self.match(evaql_parser.ERROR_BOUNDS)
            self.state = 643
            self.match(evaql_parser.REAL_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConfidenceLevelExpressionContext(ParserRuleContext):

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

        def CONFIDENCE_LEVEL(self):
            return self.getToken(evaql_parser.CONFIDENCE_LEVEL, 0)

        def REAL_LITERAL(self):
            return self.getToken(evaql_parser.REAL_LITERAL, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_confidenceLevelExpression

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

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

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




    def confidenceLevelExpression(self):

        localctx = evaql_parser.ConfidenceLevelExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_confidenceLevelExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 645
            self.match(evaql_parser.CONFIDENCE_LEVEL)
            self.state = 646
            self.match(evaql_parser.REAL_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShutdownStatementContext(ParserRuleContext):

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

        def SHUTDOWN(self):
            return self.getToken(evaql_parser.SHUTDOWN, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_shutdownStatement

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

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

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




    def shutdownStatement(self):

        localctx = evaql_parser.ShutdownStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_shutdownStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 648
            self.match(evaql_parser.SHUTDOWN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleDescribeStatementContext(ParserRuleContext):

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

        def DESCRIBE(self):
            return self.getToken(evaql_parser.DESCRIBE, 0)

        def tableName(self):
            return self.getTypedRuleContext(evaql_parser.TableNameContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_simpleDescribeStatement

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

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

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




    def simpleDescribeStatement(self):

        localctx = evaql_parser.SimpleDescribeStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_simpleDescribeStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 650
            self.match(evaql_parser.DESCRIBE)
            self.state = 651
            self.tableName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HelpStatementContext(ParserRuleContext):

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

        def HELP(self):
            return self.getToken(evaql_parser.HELP, 0)

        def STRING_LITERAL(self):
            return self.getToken(evaql_parser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_helpStatement

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

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

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




    def helpStatement(self):

        localctx = evaql_parser.HelpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_helpStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 653
            self.match(evaql_parser.HELP)
            self.state = 654
            self.match(evaql_parser.STRING_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FullIdContext(ParserRuleContext):

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

        def uid(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.UidContext)
            else:
                return self.getTypedRuleContext(evaql_parser.UidContext,i)


        def DOT_ID(self):
            return self.getToken(evaql_parser.DOT_ID, 0)

        def DOT(self):
            return self.getToken(evaql_parser.DOT, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_fullId

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

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

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




    def fullId(self):

        localctx = evaql_parser.FullIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_fullId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 656
            self.uid()
            self.state = 660
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 657
                self.match(evaql_parser.DOT_ID)

            elif la_ == 2:
                self.state = 658
                self.match(evaql_parser.DOT)
                self.state = 659
                self.uid()


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


    class TableNameContext(ParserRuleContext):

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

        def fullId(self):
            return self.getTypedRuleContext(evaql_parser.FullIdContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_tableName

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

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

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




    def tableName(self):

        localctx = evaql_parser.TableNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_tableName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 662
            self.fullId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FullColumnNameContext(ParserRuleContext):

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

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def dottedId(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.DottedIdContext)
            else:
                return self.getTypedRuleContext(evaql_parser.DottedIdContext,i)


        def getRuleIndex(self):
            return evaql_parser.RULE_fullColumnName

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

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

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




    def fullColumnName(self):

        localctx = evaql_parser.FullColumnNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_fullColumnName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 664
            self.uid()
            self.state = 669
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.state = 665
                self.dottedId()
                self.state = 667
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
                if la_ == 1:
                    self.state = 666
                    self.dottedId()




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


    class IndexColumnNameContext(ParserRuleContext):

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

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def decimalLiteral(self):
            return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,0)


        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

        def ASC(self):
            return self.getToken(evaql_parser.ASC, 0)

        def DESC(self):
            return self.getToken(evaql_parser.DESC, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_indexColumnName

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

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

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




    def indexColumnName(self):

        localctx = evaql_parser.IndexColumnNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_indexColumnName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 671
            self.uid()
            self.state = 676
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.LR_BRACKET:
                self.state = 672
                self.match(evaql_parser.LR_BRACKET)
                self.state = 673
                self.decimalLiteral()
                self.state = 674
                self.match(evaql_parser.RR_BRACKET)


            self.state = 679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.ASC or _la==evaql_parser.DESC:
                self.state = 678
                localctx.sortType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==evaql_parser.ASC or _la==evaql_parser.DESC):
                    localctx.sortType = 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 UserNameContext(ParserRuleContext):

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

        def STRING_USER_NAME(self):
            return self.getToken(evaql_parser.STRING_USER_NAME, 0)

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

        def getRuleIndex(self):
            return evaql_parser.RULE_userName

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

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

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




    def userName(self):

        localctx = evaql_parser.UserNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_userName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 681
            _la = self._input.LA(1)
            if not(_la==evaql_parser.ID or _la==evaql_parser.STRING_USER_NAME):
                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 UuidSetContext(ParserRuleContext):

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

        def decimalLiteral(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.DecimalLiteralContext)
            else:
                return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,i)


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

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

        def getRuleIndex(self):
            return evaql_parser.RULE_uuidSet

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

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

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




    def uuidSet(self):

        localctx = evaql_parser.UuidSetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_uuidSet)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 683
            self.decimalLiteral()
            self.state = 684
            self.match(evaql_parser.MINUS)
            self.state = 685
            self.decimalLiteral()
            self.state = 686
            self.match(evaql_parser.MINUS)
            self.state = 687
            self.decimalLiteral()
            self.state = 688
            self.match(evaql_parser.MINUS)
            self.state = 689
            self.decimalLiteral()
            self.state = 690
            self.match(evaql_parser.MINUS)
            self.state = 691
            self.decimalLiteral()
            self.state = 697 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 692
                self.match(evaql_parser.COLON_SYMB)
                self.state = 693
                self.decimalLiteral()
                self.state = 694
                self.match(evaql_parser.MINUS)
                self.state = 695
                self.decimalLiteral()
                self.state = 699 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==evaql_parser.COLON_SYMB):
                    break

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


    class UidContext(ParserRuleContext):

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

        def simpleId(self):
            return self.getTypedRuleContext(evaql_parser.SimpleIdContext,0)


        def REVERSE_QUOTE_ID(self):
            return self.getToken(evaql_parser.REVERSE_QUOTE_ID, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_uid

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

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

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




    def uid(self):

        localctx = evaql_parser.UidContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_uid)
        try:
            self.state = 703
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 701
                self.simpleId()
                pass
            elif token in [evaql_parser.REVERSE_QUOTE_ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 702
                self.match(evaql_parser.REVERSE_QUOTE_ID)
                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 SimpleIdContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return evaql_parser.RULE_simpleId

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

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

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




    def simpleId(self):

        localctx = evaql_parser.SimpleIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_simpleId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 705
            self.match(evaql_parser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DottedIdContext(ParserRuleContext):

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

        def DOT_ID(self):
            return self.getToken(evaql_parser.DOT_ID, 0)

        def DOT(self):
            return self.getToken(evaql_parser.DOT, 0)

        def uid(self):
            return self.getTypedRuleContext(evaql_parser.UidContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_dottedId

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

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

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




    def dottedId(self):

        localctx = evaql_parser.DottedIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_dottedId)
        try:
            self.state = 710
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.DOT_ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 707
                self.match(evaql_parser.DOT_ID)
                pass
            elif token in [evaql_parser.DOT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 708
                self.match(evaql_parser.DOT)
                self.state = 709
                self.uid()
                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 DecimalLiteralContext(ParserRuleContext):

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

        def DECIMAL_LITERAL(self):
            return self.getToken(evaql_parser.DECIMAL_LITERAL, 0)

        def ZERO_DECIMAL(self):
            return self.getToken(evaql_parser.ZERO_DECIMAL, 0)

        def ONE_DECIMAL(self):
            return self.getToken(evaql_parser.ONE_DECIMAL, 0)

        def TWO_DECIMAL(self):
            return self.getToken(evaql_parser.TWO_DECIMAL, 0)

        def ANYDIM(self):
            return self.getToken(evaql_parser.ANYDIM, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_decimalLiteral

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

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

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




    def decimalLiteral(self):

        localctx = evaql_parser.DecimalLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_decimalLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 712
            _la = self._input.LA(1)
            if not(_la==evaql_parser.ANYDIM or ((((_la - 147)) & ~0x3f) == 0 and ((1 << (_la - 147)) & ((1 << (evaql_parser.ZERO_DECIMAL - 147)) | (1 << (evaql_parser.ONE_DECIMAL - 147)) | (1 << (evaql_parser.TWO_DECIMAL - 147)) | (1 << (evaql_parser.DECIMAL_LITERAL - 147)))) != 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 StringLiteralContext(ParserRuleContext):

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

        def STRING_LITERAL(self):
            return self.getToken(evaql_parser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_stringLiteral

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

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

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




    def stringLiteral(self):

        localctx = evaql_parser.StringLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_stringLiteral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 714
            self.match(evaql_parser.STRING_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanLiteralContext(ParserRuleContext):

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

        def TRUE(self):
            return self.getToken(evaql_parser.TRUE, 0)

        def FALSE(self):
            return self.getToken(evaql_parser.FALSE, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_booleanLiteral

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

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

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




    def booleanLiteral(self):

        localctx = evaql_parser.BooleanLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_booleanLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 716
            _la = self._input.LA(1)
            if not(_la==evaql_parser.FALSE or _la==evaql_parser.TRUE):
                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 NullNotnullContext(ParserRuleContext):

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

        def NULL_LITERAL(self):
            return self.getToken(evaql_parser.NULL_LITERAL, 0)

        def NULL_SPEC_LITERAL(self):
            return self.getToken(evaql_parser.NULL_SPEC_LITERAL, 0)

        def NOT(self):
            return self.getToken(evaql_parser.NOT, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_nullNotnull

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

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

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




    def nullNotnull(self):

        localctx = evaql_parser.NullNotnullContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_nullNotnull)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 719
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.NOT:
                self.state = 718
                self.match(evaql_parser.NOT)


            self.state = 721
            _la = self._input.LA(1)
            if not(_la==evaql_parser.NULL_LITERAL or _la==evaql_parser.NULL_SPEC_LITERAL):
                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 ArrayLiteralContext(ParserRuleContext):

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

        def LR_SQ_BRACKET(self):
            return self.getToken(evaql_parser.LR_SQ_BRACKET, 0)

        def constant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ConstantContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ConstantContext,i)


        def RR_SQ_BRACKET(self):
            return self.getToken(evaql_parser.RR_SQ_BRACKET, 0)

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

        def getRuleIndex(self):
            return evaql_parser.RULE_arrayLiteral

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

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

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




    def arrayLiteral(self):

        localctx = evaql_parser.ArrayLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_arrayLiteral)
        self._la = 0 # Token type
        try:
            self.state = 736
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 723
                self.match(evaql_parser.LR_SQ_BRACKET)
                self.state = 724
                self.constant()
                self.state = 729
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==evaql_parser.COMMA:
                    self.state = 725
                    self.match(evaql_parser.COMMA)
                    self.state = 726
                    self.constant()
                    self.state = 731
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 732
                self.match(evaql_parser.RR_SQ_BRACKET)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 734
                self.match(evaql_parser.LR_SQ_BRACKET)
                self.state = 735
                self.match(evaql_parser.RR_SQ_BRACKET)
                pass


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


    class ConstantContext(ParserRuleContext):

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

        def stringLiteral(self):
            return self.getTypedRuleContext(evaql_parser.StringLiteralContext,0)


        def decimalLiteral(self):
            return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,0)


        def MINUS(self):
            return self.getToken(evaql_parser.MINUS, 0)

        def booleanLiteral(self):
            return self.getTypedRuleContext(evaql_parser.BooleanLiteralContext,0)


        def REAL_LITERAL(self):
            return self.getToken(evaql_parser.REAL_LITERAL, 0)

        def NULL_LITERAL(self):
            return self.getToken(evaql_parser.NULL_LITERAL, 0)

        def NULL_SPEC_LITERAL(self):
            return self.getToken(evaql_parser.NULL_SPEC_LITERAL, 0)

        def NOT(self):
            return self.getToken(evaql_parser.NOT, 0)

        def arrayLiteral(self):
            return self.getTypedRuleContext(evaql_parser.ArrayLiteralContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_constant

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

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

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




    def constant(self):

        localctx = evaql_parser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_constant)
        self._la = 0 # Token type
        try:
            self.state = 749
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 738
                self.stringLiteral()
                pass
            elif token in [evaql_parser.ANYDIM, evaql_parser.ZERO_DECIMAL, evaql_parser.ONE_DECIMAL, evaql_parser.TWO_DECIMAL, evaql_parser.DECIMAL_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 739
                self.decimalLiteral()
                pass
            elif token in [evaql_parser.MINUS]:
                self.enterOuterAlt(localctx, 3)
                self.state = 740
                self.match(evaql_parser.MINUS)
                self.state = 741
                self.decimalLiteral()
                pass
            elif token in [evaql_parser.FALSE, evaql_parser.TRUE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 742
                self.booleanLiteral()
                pass
            elif token in [evaql_parser.REAL_LITERAL]:
                self.enterOuterAlt(localctx, 5)
                self.state = 743
                self.match(evaql_parser.REAL_LITERAL)
                pass
            elif token in [evaql_parser.NOT, evaql_parser.NULL_LITERAL, evaql_parser.NULL_SPEC_LITERAL]:
                self.enterOuterAlt(localctx, 6)
                self.state = 745
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.NOT:
                    self.state = 744
                    self.match(evaql_parser.NOT)


                self.state = 747
                localctx.nullLiteral = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==evaql_parser.NULL_LITERAL or _la==evaql_parser.NULL_SPEC_LITERAL):
                    localctx.nullLiteral = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [evaql_parser.LR_SQ_BRACKET]:
                self.enterOuterAlt(localctx, 7)
                self.state = 748
                self.arrayLiteral()
                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 ArrayTypeContext(ParserRuleContext):

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

        def INT8(self):
            return self.getToken(evaql_parser.INT8, 0)

        def UINT8(self):
            return self.getToken(evaql_parser.UINT8, 0)

        def INT16(self):
            return self.getToken(evaql_parser.INT16, 0)

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

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

        def UNICODE(self):
            return self.getToken(evaql_parser.UNICODE, 0)

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

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

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

        def DECIMAL(self):
            return self.getToken(evaql_parser.DECIMAL, 0)

        def STR(self):
            return self.getToken(evaql_parser.STR, 0)

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

        def ANYTYPE(self):
            return self.getToken(evaql_parser.ANYTYPE, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_arrayType

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

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

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




    def arrayType(self):

        localctx = evaql_parser.ArrayTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_arrayType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 751
            _la = self._input.LA(1)
            if not(((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (evaql_parser.INT8 - 83)) | (1 << (evaql_parser.UINT8 - 83)) | (1 << (evaql_parser.INT16 - 83)) | (1 << (evaql_parser.INT32 - 83)) | (1 << (evaql_parser.INT64 - 83)) | (1 << (evaql_parser.UNICODE - 83)) | (1 << (evaql_parser.BOOL - 83)) | (1 << (evaql_parser.FLOAT32 - 83)) | (1 << (evaql_parser.FLOAT64 - 83)) | (1 << (evaql_parser.DECIMAL - 83)) | (1 << (evaql_parser.STR - 83)) | (1 << (evaql_parser.DATETIME - 83)) | (1 << (evaql_parser.ANYTYPE - 83)))) != 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 DataTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_dataType

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



    class IntegerDataTypeContext(DataTypeContext):

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

        def INTEGER(self):
            return self.getToken(evaql_parser.INTEGER, 0)
        def UNSIGNED(self):
            return self.getToken(evaql_parser.UNSIGNED, 0)

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

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

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


    class DimensionDataTypeContext(DataTypeContext):

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

        def TEXT(self):
            return self.getToken(evaql_parser.TEXT, 0)
        def lengthOneDimension(self):
            return self.getTypedRuleContext(evaql_parser.LengthOneDimensionContext,0)

        def FLOAT(self):
            return self.getToken(evaql_parser.FLOAT, 0)
        def lengthTwoDimension(self):
            return self.getTypedRuleContext(evaql_parser.LengthTwoDimensionContext,0)

        def UNSIGNED(self):
            return self.getToken(evaql_parser.UNSIGNED, 0)

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

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

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


    class AnyDataTypeContext(DataTypeContext):

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

        def ANYTYPE(self):
            return self.getToken(evaql_parser.ANYTYPE, 0)

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

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

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


    class SimpleDataTypeContext(DataTypeContext):

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

        def BOOLEAN(self):
            return self.getToken(evaql_parser.BOOLEAN, 0)

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

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

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


    class ArrayDataTypeContext(DataTypeContext):

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

        def NDARRAY(self):
            return self.getToken(evaql_parser.NDARRAY, 0)
        def arrayType(self):
            return self.getTypedRuleContext(evaql_parser.ArrayTypeContext,0)

        def lengthDimensionList(self):
            return self.getTypedRuleContext(evaql_parser.LengthDimensionListContext,0)


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

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

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



    def dataType(self):

        localctx = evaql_parser.DataTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_dataType)
        self._la = 0 # Token type
        try:
            self.state = 777
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.BOOLEAN]:
                localctx = evaql_parser.SimpleDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 753
                self.match(evaql_parser.BOOLEAN)
                pass
            elif token in [evaql_parser.TEXT]:
                localctx = evaql_parser.DimensionDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 754
                self.match(evaql_parser.TEXT)
                self.state = 756
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.LR_BRACKET:
                    self.state = 755
                    self.lengthOneDimension()


                pass
            elif token in [evaql_parser.INTEGER]:
                localctx = evaql_parser.IntegerDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 758
                self.match(evaql_parser.INTEGER)
                self.state = 760
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.UNSIGNED:
                    self.state = 759
                    self.match(evaql_parser.UNSIGNED)


                pass
            elif token in [evaql_parser.FLOAT]:
                localctx = evaql_parser.DimensionDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 762
                self.match(evaql_parser.FLOAT)
                self.state = 764
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.LR_BRACKET:
                    self.state = 763
                    self.lengthTwoDimension()


                self.state = 767
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.UNSIGNED:
                    self.state = 766
                    self.match(evaql_parser.UNSIGNED)


                pass
            elif token in [evaql_parser.NDARRAY]:
                localctx = evaql_parser.ArrayDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 769
                self.match(evaql_parser.NDARRAY)
                self.state = 771
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (evaql_parser.INT8 - 83)) | (1 << (evaql_parser.UINT8 - 83)) | (1 << (evaql_parser.INT16 - 83)) | (1 << (evaql_parser.INT32 - 83)) | (1 << (evaql_parser.INT64 - 83)) | (1 << (evaql_parser.UNICODE - 83)) | (1 << (evaql_parser.BOOL - 83)) | (1 << (evaql_parser.FLOAT32 - 83)) | (1 << (evaql_parser.FLOAT64 - 83)) | (1 << (evaql_parser.DECIMAL - 83)) | (1 << (evaql_parser.STR - 83)) | (1 << (evaql_parser.DATETIME - 83)) | (1 << (evaql_parser.ANYTYPE - 83)))) != 0):
                    self.state = 770
                    self.arrayType()


                self.state = 774
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.LR_BRACKET:
                    self.state = 773
                    self.lengthDimensionList()


                pass
            elif token in [evaql_parser.ANYTYPE]:
                localctx = evaql_parser.AnyDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 776
                self.match(evaql_parser.ANYTYPE)
                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 LengthOneDimensionContext(ParserRuleContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def decimalLiteral(self):
            return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,0)


        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_lengthOneDimension

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

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

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




    def lengthOneDimension(self):

        localctx = evaql_parser.LengthOneDimensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_lengthOneDimension)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 779
            self.match(evaql_parser.LR_BRACKET)
            self.state = 780
            self.decimalLiteral()
            self.state = 781
            self.match(evaql_parser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LengthTwoDimensionContext(ParserRuleContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def decimalLiteral(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.DecimalLiteralContext)
            else:
                return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,i)


        def COMMA(self):
            return self.getToken(evaql_parser.COMMA, 0)

        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_lengthTwoDimension

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

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

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




    def lengthTwoDimension(self):

        localctx = evaql_parser.LengthTwoDimensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_lengthTwoDimension)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 783
            self.match(evaql_parser.LR_BRACKET)
            self.state = 784
            self.decimalLiteral()
            self.state = 785
            self.match(evaql_parser.COMMA)
            self.state = 786
            self.decimalLiteral()
            self.state = 787
            self.match(evaql_parser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LengthDimensionListContext(ParserRuleContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def decimalLiteral(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.DecimalLiteralContext)
            else:
                return self.getTypedRuleContext(evaql_parser.DecimalLiteralContext,i)


        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

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

        def getRuleIndex(self):
            return evaql_parser.RULE_lengthDimensionList

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

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

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




    def lengthDimensionList(self):

        localctx = evaql_parser.LengthDimensionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_lengthDimensionList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 789
            self.match(evaql_parser.LR_BRACKET)
            self.state = 795
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,92,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 790
                    self.decimalLiteral()
                    self.state = 791
                    self.match(evaql_parser.COMMA) 
                self.state = 797
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,92,self._ctx)

            self.state = 798
            self.decimalLiteral()
            self.state = 799
            self.match(evaql_parser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UidListContext(ParserRuleContext):

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

        def uid(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.UidContext)
            else:
                return self.getTypedRuleContext(evaql_parser.UidContext,i)


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

        def getRuleIndex(self):
            return evaql_parser.RULE_uidList

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

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

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




    def uidList(self):

        localctx = evaql_parser.UidListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_uidList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 801
            self.uid()
            self.state = 806
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 802
                self.match(evaql_parser.COMMA)
                self.state = 803
                self.uid()
                self.state = 808
                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 TablesContext(ParserRuleContext):

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

        def tableName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.TableNameContext)
            else:
                return self.getTypedRuleContext(evaql_parser.TableNameContext,i)


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

        def getRuleIndex(self):
            return evaql_parser.RULE_tables

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

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

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




    def tables(self):

        localctx = evaql_parser.TablesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_tables)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 809
            self.tableName()
            self.state = 814
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 810
                self.match(evaql_parser.COMMA)
                self.state = 811
                self.tableName()
                self.state = 816
                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 IndexColumnNamesContext(ParserRuleContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def indexColumnName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.IndexColumnNameContext)
            else:
                return self.getTypedRuleContext(evaql_parser.IndexColumnNameContext,i)


        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

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

        def getRuleIndex(self):
            return evaql_parser.RULE_indexColumnNames

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

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

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




    def indexColumnNames(self):

        localctx = evaql_parser.IndexColumnNamesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_indexColumnNames)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 817
            self.match(evaql_parser.LR_BRACKET)
            self.state = 818
            self.indexColumnName()
            self.state = 823
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 819
                self.match(evaql_parser.COMMA)
                self.state = 820
                self.indexColumnName()
                self.state = 825
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 826
            self.match(evaql_parser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionsContext(ParserRuleContext):

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return evaql_parser.RULE_expressions

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

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

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




    def expressions(self):

        localctx = evaql_parser.ExpressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_expressions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 828
            self.expression(0)
            self.state = 833
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 829
                self.match(evaql_parser.COMMA)
                self.state = 830
                self.expression(0)
                self.state = 835
                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 ExpressionsWithDefaultsContext(ParserRuleContext):

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

        def expressionOrDefault(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionOrDefaultContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionOrDefaultContext,i)


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

        def getRuleIndex(self):
            return evaql_parser.RULE_expressionsWithDefaults

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

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

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




    def expressionsWithDefaults(self):

        localctx = evaql_parser.ExpressionsWithDefaultsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_expressionsWithDefaults)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 836
            self.expressionOrDefault()
            self.state = 841
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 837
                self.match(evaql_parser.COMMA)
                self.state = 838
                self.expressionOrDefault()
                self.state = 843
                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 DefaultValueContext(ParserRuleContext):

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

        def NULL_LITERAL(self):
            return self.getToken(evaql_parser.NULL_LITERAL, 0)

        def constant(self):
            return self.getTypedRuleContext(evaql_parser.ConstantContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_defaultValue

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

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

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




    def defaultValue(self):

        localctx = evaql_parser.DefaultValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_defaultValue)
        try:
            self.state = 846
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 844
                self.match(evaql_parser.NULL_LITERAL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 845
                self.constant()
                pass


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


    class ExpressionOrDefaultContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)


        def DEFAULT(self):
            return self.getToken(evaql_parser.DEFAULT, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_expressionOrDefault

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

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

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




    def expressionOrDefault(self):

        localctx = evaql_parser.ExpressionOrDefaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_expressionOrDefault)
        try:
            self.state = 850
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.ANYDIM, evaql_parser.FALSE, evaql_parser.NOT, evaql_parser.NULL_LITERAL, evaql_parser.TRUE, evaql_parser.AVG, evaql_parser.COUNT, evaql_parser.MAX, evaql_parser.MIN, evaql_parser.SUM, evaql_parser.PLUS, evaql_parser.MINUS, evaql_parser.EXCLAMATION_SYMBOL, evaql_parser.BIT_NOT_OP, evaql_parser.LR_BRACKET, evaql_parser.LR_SQ_BRACKET, evaql_parser.ZERO_DECIMAL, evaql_parser.ONE_DECIMAL, evaql_parser.TWO_DECIMAL, evaql_parser.STRING_LITERAL, evaql_parser.DECIMAL_LITERAL, evaql_parser.REAL_LITERAL, evaql_parser.NULL_SPEC_LITERAL, evaql_parser.ID, evaql_parser.REVERSE_QUOTE_ID, evaql_parser.LOCAL_ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 848
                self.expression(0)
                pass
            elif token in [evaql_parser.DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 849
                self.match(evaql_parser.DEFAULT)
                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 IfExistsContext(ParserRuleContext):

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

        def IF(self):
            return self.getToken(evaql_parser.IF, 0)

        def EXISTS(self):
            return self.getToken(evaql_parser.EXISTS, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_ifExists

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

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

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




    def ifExists(self):

        localctx = evaql_parser.IfExistsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_ifExists)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 852
            self.match(evaql_parser.IF)
            self.state = 853
            self.match(evaql_parser.EXISTS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfNotExistsContext(ParserRuleContext):

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

        def IF(self):
            return self.getToken(evaql_parser.IF, 0)

        def NOT(self):
            return self.getToken(evaql_parser.NOT, 0)

        def EXISTS(self):
            return self.getToken(evaql_parser.EXISTS, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_ifNotExists

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

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

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




    def ifNotExists(self):

        localctx = evaql_parser.IfNotExistsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_ifNotExists)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 855
            self.match(evaql_parser.IF)
            self.state = 856
            self.match(evaql_parser.NOT)
            self.state = 857
            self.match(evaql_parser.EXISTS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_functionCall

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



    class UdfFunctionCallContext(FunctionCallContext):

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

        def udfFunction(self):
            return self.getTypedRuleContext(evaql_parser.UdfFunctionContext,0)


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

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

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


    class AggregateFunctionCallContext(FunctionCallContext):

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

        def aggregateWindowedFunction(self):
            return self.getTypedRuleContext(evaql_parser.AggregateWindowedFunctionContext,0)


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

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

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



    def functionCall(self):

        localctx = evaql_parser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_functionCall)
        try:
            self.state = 861
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.ID]:
                localctx = evaql_parser.UdfFunctionCallContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 859
                self.udfFunction()
                pass
            elif token in [evaql_parser.AVG, evaql_parser.COUNT, evaql_parser.MAX, evaql_parser.MIN, evaql_parser.SUM]:
                localctx = evaql_parser.AggregateFunctionCallContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 860
                self.aggregateWindowedFunction()
                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 UdfFunctionContext(ParserRuleContext):

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

        def simpleId(self):
            return self.getTypedRuleContext(evaql_parser.SimpleIdContext,0)


        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def functionArgs(self):
            return self.getTypedRuleContext(evaql_parser.FunctionArgsContext,0)


        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

        def dottedId(self):
            return self.getTypedRuleContext(evaql_parser.DottedIdContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_udfFunction

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

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

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




    def udfFunction(self):

        localctx = evaql_parser.UdfFunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_udfFunction)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 863
            self.simpleId()
            self.state = 864
            self.match(evaql_parser.LR_BRACKET)
            self.state = 865
            self.functionArgs()
            self.state = 866
            self.match(evaql_parser.RR_BRACKET)
            self.state = 868
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
            if la_ == 1:
                self.state = 867
                self.dottedId()


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


    class AggregateWindowedFunctionContext(ParserRuleContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)

        def functionArg(self):
            return self.getTypedRuleContext(evaql_parser.FunctionArgContext,0)


        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

        def AVG(self):
            return self.getToken(evaql_parser.AVG, 0)

        def MAX(self):
            return self.getToken(evaql_parser.MAX, 0)

        def MIN(self):
            return self.getToken(evaql_parser.MIN, 0)

        def SUM(self):
            return self.getToken(evaql_parser.SUM, 0)

        def ALL(self):
            return self.getToken(evaql_parser.ALL, 0)

        def DISTINCT(self):
            return self.getToken(evaql_parser.DISTINCT, 0)

        def COUNT(self):
            return self.getToken(evaql_parser.COUNT, 0)

        def STAR(self):
            return self.getToken(evaql_parser.STAR, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_aggregateWindowedFunction

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

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

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




    def aggregateWindowedFunction(self):

        localctx = evaql_parser.AggregateWindowedFunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_aggregateWindowedFunction)
        self._la = 0 # Token type
        try:
            self.state = 888
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.AVG, evaql_parser.MAX, evaql_parser.MIN, evaql_parser.SUM]:
                self.enterOuterAlt(localctx, 1)
                self.state = 870
                _la = self._input.LA(1)
                if not(((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (evaql_parser.AVG - 96)) | (1 << (evaql_parser.MAX - 96)) | (1 << (evaql_parser.MIN - 96)) | (1 << (evaql_parser.SUM - 96)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 871
                self.match(evaql_parser.LR_BRACKET)
                self.state = 873
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.ALL or _la==evaql_parser.DISTINCT:
                    self.state = 872
                    localctx.aggregator = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==evaql_parser.ALL or _la==evaql_parser.DISTINCT):
                        localctx.aggregator = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 875
                self.functionArg()
                self.state = 876
                self.match(evaql_parser.RR_BRACKET)
                pass
            elif token in [evaql_parser.COUNT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 878
                self.match(evaql_parser.COUNT)
                self.state = 879
                self.match(evaql_parser.LR_BRACKET)
                self.state = 885
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [evaql_parser.STAR]:
                    self.state = 880
                    localctx.starArg = self.match(evaql_parser.STAR)
                    pass
                elif token in [evaql_parser.ALL, evaql_parser.ANYDIM, evaql_parser.FALSE, evaql_parser.NOT, evaql_parser.NULL_LITERAL, evaql_parser.TRUE, evaql_parser.AVG, evaql_parser.COUNT, evaql_parser.MAX, evaql_parser.MIN, evaql_parser.SUM, evaql_parser.PLUS, evaql_parser.MINUS, evaql_parser.EXCLAMATION_SYMBOL, evaql_parser.BIT_NOT_OP, evaql_parser.LR_BRACKET, evaql_parser.LR_SQ_BRACKET, evaql_parser.ZERO_DECIMAL, evaql_parser.ONE_DECIMAL, evaql_parser.TWO_DECIMAL, evaql_parser.STRING_LITERAL, evaql_parser.DECIMAL_LITERAL, evaql_parser.REAL_LITERAL, evaql_parser.NULL_SPEC_LITERAL, evaql_parser.ID, evaql_parser.REVERSE_QUOTE_ID, evaql_parser.LOCAL_ID]:
                    self.state = 882
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==evaql_parser.ALL:
                        self.state = 881
                        localctx.aggregator = self.match(evaql_parser.ALL)


                    self.state = 884
                    self.functionArg()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 887
                self.match(evaql_parser.RR_BRACKET)
                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 FunctionArgsContext(ParserRuleContext):

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

        def constant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ConstantContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ConstantContext,i)


        def fullColumnName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.FullColumnNameContext)
            else:
                return self.getTypedRuleContext(evaql_parser.FullColumnNameContext,i)


        def functionCall(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.FunctionCallContext)
            else:
                return self.getTypedRuleContext(evaql_parser.FunctionCallContext,i)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return evaql_parser.RULE_functionArgs

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

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

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




    def functionArgs(self):

        localctx = evaql_parser.FunctionArgsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_functionArgs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 894
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.state = 890
                self.constant()
                pass

            elif la_ == 2:
                self.state = 891
                self.fullColumnName()
                pass

            elif la_ == 3:
                self.state = 892
                self.functionCall()
                pass

            elif la_ == 4:
                self.state = 893
                self.expression(0)
                pass


            self.state = 905
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==evaql_parser.COMMA:
                self.state = 896
                self.match(evaql_parser.COMMA)
                self.state = 901
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
                if la_ == 1:
                    self.state = 897
                    self.constant()
                    pass

                elif la_ == 2:
                    self.state = 898
                    self.fullColumnName()
                    pass

                elif la_ == 3:
                    self.state = 899
                    self.functionCall()
                    pass

                elif la_ == 4:
                    self.state = 900
                    self.expression(0)
                    pass


                self.state = 907
                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 FunctionArgContext(ParserRuleContext):

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

        def constant(self):
            return self.getTypedRuleContext(evaql_parser.ConstantContext,0)


        def fullColumnName(self):
            return self.getTypedRuleContext(evaql_parser.FullColumnNameContext,0)


        def functionCall(self):
            return self.getTypedRuleContext(evaql_parser.FunctionCallContext,0)


        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)


        def getRuleIndex(self):
            return evaql_parser.RULE_functionArg

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

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

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




    def functionArg(self):

        localctx = evaql_parser.FunctionArgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_functionArg)
        try:
            self.state = 912
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 908
                self.constant()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 909
                self.fullColumnName()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 910
                self.functionCall()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 911
                self.expression(0)
                pass


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


    class ExpressionContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_expression

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


    class IsExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a evaql_parser.ExpressionContext
            super().__init__(parser)
            self.testValue = None # Token
            self.copyFrom(ctx)

        def predicate(self):
            return self.getTypedRuleContext(evaql_parser.PredicateContext,0)

        def IS(self):
            return self.getToken(evaql_parser.IS, 0)
        def TRUE(self):
            return self.getToken(evaql_parser.TRUE, 0)
        def FALSE(self):
            return self.getToken(evaql_parser.FALSE, 0)
        def UNKNOWN(self):
            return self.getToken(evaql_parser.UNKNOWN, 0)
        def NOT(self):
            return self.getToken(evaql_parser.NOT, 0)

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

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

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


    class NotExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a evaql_parser.ExpressionContext
            super().__init__(parser)
            self.notOperator = None # Token
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionContext,0)

        def NOT(self):
            return self.getToken(evaql_parser.NOT, 0)
        def EXCLAMATION_SYMBOL(self):
            return self.getToken(evaql_parser.EXCLAMATION_SYMBOL, 0)

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

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

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


    class LogicalExpressionContext(ExpressionContext):

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionContext,i)

        def logicalOperator(self):
            return self.getTypedRuleContext(evaql_parser.LogicalOperatorContext,0)


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

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

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


    class PredicateExpressionContext(ExpressionContext):

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

        def predicate(self):
            return self.getTypedRuleContext(evaql_parser.PredicateContext,0)


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

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

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



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = evaql_parser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 178
        self.enterRecursionRule(localctx, 178, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 925
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
            if la_ == 1:
                localctx = evaql_parser.NotExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 915
                localctx.notOperator = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==evaql_parser.NOT or _la==evaql_parser.EXCLAMATION_SYMBOL):
                    localctx.notOperator = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 916
                self.expression(4)
                pass

            elif la_ == 2:
                localctx = evaql_parser.IsExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 917
                self.predicate(0)
                self.state = 918
                self.match(evaql_parser.IS)
                self.state = 920
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==evaql_parser.NOT:
                    self.state = 919
                    self.match(evaql_parser.NOT)


                self.state = 922
                localctx.testValue = self._input.LT(1)
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << evaql_parser.FALSE) | (1 << evaql_parser.TRUE) | (1 << evaql_parser.UNKNOWN))) != 0)):
                    localctx.testValue = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 3:
                localctx = evaql_parser.PredicateExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 924
                self.predicate(0)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 933
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,112,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = evaql_parser.LogicalExpressionContext(self, evaql_parser.ExpressionContext(self, _parentctx, _parentState))
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                    self.state = 927
                    if not self.precpred(self._ctx, 3):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                    self.state = 928
                    self.logicalOperator()
                    self.state = 929
                    self.expression(4) 
                self.state = 935
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,112,self._ctx)

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


    class PredicateContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_predicate

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


    class ExpressionAtomPredicateContext(PredicateContext):

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

        def expressionAtom(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionAtomContext,0)

        def LOCAL_ID(self):
            return self.getToken(evaql_parser.LOCAL_ID, 0)
        def VAR_ASSIGN(self):
            return self.getToken(evaql_parser.VAR_ASSIGN, 0)

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

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

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


    class SubqueryComparisonPredicateContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a evaql_parser.PredicateContext
            super().__init__(parser)
            self.quantifier = None # Token
            self.copyFrom(ctx)

        def predicate(self):
            return self.getTypedRuleContext(evaql_parser.PredicateContext,0)

        def comparisonOperator(self):
            return self.getTypedRuleContext(evaql_parser.ComparisonOperatorContext,0)

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)
        def selectStatement(self):
            return self.getTypedRuleContext(evaql_parser.SelectStatementContext,0)

        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)
        def ALL(self):
            return self.getToken(evaql_parser.ALL, 0)
        def ANY(self):
            return self.getToken(evaql_parser.ANY, 0)
        def SOME(self):
            return self.getToken(evaql_parser.SOME, 0)

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

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

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


    class BinaryComparisonPredicateContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a evaql_parser.PredicateContext
            super().__init__(parser)
            self.left = None # PredicateContext
            self.right = None # PredicateContext
            self.copyFrom(ctx)

        def comparisonOperator(self):
            return self.getTypedRuleContext(evaql_parser.ComparisonOperatorContext,0)

        def predicate(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.PredicateContext)
            else:
                return self.getTypedRuleContext(evaql_parser.PredicateContext,i)


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

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

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


    class InPredicateContext(PredicateContext):

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

        def predicate(self):
            return self.getTypedRuleContext(evaql_parser.PredicateContext,0)

        def IN(self):
            return self.getToken(evaql_parser.IN, 0)
        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)
        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)
        def selectStatement(self):
            return self.getTypedRuleContext(evaql_parser.SelectStatementContext,0)

        def expressions(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionsContext,0)

        def NOT(self):
            return self.getToken(evaql_parser.NOT, 0)

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

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

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


    class IsNullPredicateContext(PredicateContext):

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

        def predicate(self):
            return self.getTypedRuleContext(evaql_parser.PredicateContext,0)

        def IS(self):
            return self.getToken(evaql_parser.IS, 0)
        def nullNotnull(self):
            return self.getTypedRuleContext(evaql_parser.NullNotnullContext,0)


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

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

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


    class LikePredicateContext(PredicateContext):

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

        def predicate(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.PredicateContext)
            else:
                return self.getTypedRuleContext(evaql_parser.PredicateContext,i)

        def LIKE(self):
            return self.getToken(evaql_parser.LIKE, 0)
        def NOT(self):
            return self.getToken(evaql_parser.NOT, 0)
        def STRING_LITERAL(self):
            return self.getToken(evaql_parser.STRING_LITERAL, 0)

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

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

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



    def predicate(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = evaql_parser.PredicateContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 180
        self.enterRecursionRule(localctx, 180, self.RULE_predicate, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = evaql_parser.ExpressionAtomPredicateContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 939
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==evaql_parser.LOCAL_ID:
                self.state = 937
                self.match(evaql_parser.LOCAL_ID)
                self.state = 938
                self.match(evaql_parser.VAR_ASSIGN)


            self.state = 941
            self.expressionAtom(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 980
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,119,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 978
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
                    if la_ == 1:
                        localctx = evaql_parser.BinaryComparisonPredicateContext(self, evaql_parser.PredicateContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_predicate)
                        self.state = 943
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 944
                        self.comparisonOperator()
                        self.state = 945
                        localctx.right = self.predicate(5)
                        pass

                    elif la_ == 2:
                        localctx = evaql_parser.InPredicateContext(self, evaql_parser.PredicateContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_predicate)
                        self.state = 947
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 949
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==evaql_parser.NOT:
                            self.state = 948
                            self.match(evaql_parser.NOT)


                        self.state = 951
                        self.match(evaql_parser.IN)
                        self.state = 952
                        self.match(evaql_parser.LR_BRACKET)
                        self.state = 955
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [evaql_parser.SELECT]:
                            self.state = 953
                            self.selectStatement(0)
                            pass
                        elif token in [evaql_parser.ANYDIM, evaql_parser.FALSE, evaql_parser.NOT, evaql_parser.NULL_LITERAL, evaql_parser.TRUE, evaql_parser.AVG, evaql_parser.COUNT, evaql_parser.MAX, evaql_parser.MIN, evaql_parser.SUM, evaql_parser.PLUS, evaql_parser.MINUS, evaql_parser.EXCLAMATION_SYMBOL, evaql_parser.BIT_NOT_OP, evaql_parser.LR_BRACKET, evaql_parser.LR_SQ_BRACKET, evaql_parser.ZERO_DECIMAL, evaql_parser.ONE_DECIMAL, evaql_parser.TWO_DECIMAL, evaql_parser.STRING_LITERAL, evaql_parser.DECIMAL_LITERAL, evaql_parser.REAL_LITERAL, evaql_parser.NULL_SPEC_LITERAL, evaql_parser.ID, evaql_parser.REVERSE_QUOTE_ID, evaql_parser.LOCAL_ID]:
                            self.state = 954
                            self.expressions()
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 957
                        self.match(evaql_parser.RR_BRACKET)
                        pass

                    elif la_ == 3:
                        localctx = evaql_parser.IsNullPredicateContext(self, evaql_parser.PredicateContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_predicate)
                        self.state = 959
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 960
                        self.match(evaql_parser.IS)
                        self.state = 961
                        self.nullNotnull()
                        pass

                    elif la_ == 4:
                        localctx = evaql_parser.SubqueryComparisonPredicateContext(self, evaql_parser.PredicateContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_predicate)
                        self.state = 962
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 963
                        self.comparisonOperator()
                        self.state = 964
                        localctx.quantifier = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << evaql_parser.ALL) | (1 << evaql_parser.ANY) | (1 << evaql_parser.SOME))) != 0)):
                            localctx.quantifier = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 965
                        self.match(evaql_parser.LR_BRACKET)
                        self.state = 966
                        self.selectStatement(0)
                        self.state = 967
                        self.match(evaql_parser.RR_BRACKET)
                        pass

                    elif la_ == 5:
                        localctx = evaql_parser.LikePredicateContext(self, evaql_parser.PredicateContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_predicate)
                        self.state = 969
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 971
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==evaql_parser.NOT:
                            self.state = 970
                            self.match(evaql_parser.NOT)


                        self.state = 973
                        self.match(evaql_parser.LIKE)
                        self.state = 974
                        self.predicate(0)
                        self.state = 976
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                        if la_ == 1:
                            self.state = 975
                            self.match(evaql_parser.STRING_LITERAL)


                        pass

             
                self.state = 982
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,119,self._ctx)

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


    class ExpressionAtomContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return evaql_parser.RULE_expressionAtom

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


    class UnaryExpressionAtomContext(ExpressionAtomContext):

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

        def unaryOperator(self):
            return self.getTypedRuleContext(evaql_parser.UnaryOperatorContext,0)

        def expressionAtom(self):
            return self.getTypedRuleContext(evaql_parser.ExpressionAtomContext,0)


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

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

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


    class SubqueryExpessionAtomContext(ExpressionAtomContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)
        def selectStatement(self):
            return self.getTypedRuleContext(evaql_parser.SelectStatementContext,0)

        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)

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

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

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


    class ConstantExpressionAtomContext(ExpressionAtomContext):

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

        def constant(self):
            return self.getTypedRuleContext(evaql_parser.ConstantContext,0)


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

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

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


    class FunctionCallExpressionAtomContext(ExpressionAtomContext):

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

        def functionCall(self):
            return self.getTypedRuleContext(evaql_parser.FunctionCallContext,0)


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

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

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


    class FullColumnNameExpressionAtomContext(ExpressionAtomContext):

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

        def fullColumnName(self):
            return self.getTypedRuleContext(evaql_parser.FullColumnNameContext,0)


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

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

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


    class BitExpressionAtomContext(ExpressionAtomContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a evaql_parser.ExpressionAtomContext
            super().__init__(parser)
            self.left = None # ExpressionAtomContext
            self.right = None # ExpressionAtomContext
            self.copyFrom(ctx)

        def bitOperator(self):
            return self.getTypedRuleContext(evaql_parser.BitOperatorContext,0)

        def expressionAtom(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionAtomContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionAtomContext,i)


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

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

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


    class NestedExpressionAtomContext(ExpressionAtomContext):

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

        def LR_BRACKET(self):
            return self.getToken(evaql_parser.LR_BRACKET, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionContext,i)

        def RR_BRACKET(self):
            return self.getToken(evaql_parser.RR_BRACKET, 0)
        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(evaql_parser.COMMA)
            else:
                return self.getToken(evaql_parser.COMMA, i)

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

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

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


    class MathExpressionAtomContext(ExpressionAtomContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a evaql_parser.ExpressionAtomContext
            super().__init__(parser)
            self.left = None # ExpressionAtomContext
            self.right = None # ExpressionAtomContext
            self.copyFrom(ctx)

        def mathOperator(self):
            return self.getTypedRuleContext(evaql_parser.MathOperatorContext,0)

        def expressionAtom(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(evaql_parser.ExpressionAtomContext)
            else:
                return self.getTypedRuleContext(evaql_parser.ExpressionAtomContext,i)


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

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

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



    def expressionAtom(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = evaql_parser.ExpressionAtomContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 182
        self.enterRecursionRule(localctx, 182, self.RULE_expressionAtom, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1005
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                localctx = evaql_parser.ConstantExpressionAtomContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 984
                self.constant()
                pass

            elif la_ == 2:
                localctx = evaql_parser.FullColumnNameExpressionAtomContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 985
                self.fullColumnName()
                pass

            elif la_ == 3:
                localctx = evaql_parser.FunctionCallExpressionAtomContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 986
                self.functionCall()
                pass

            elif la_ == 4:
                localctx = evaql_parser.UnaryExpressionAtomContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 987
                self.unaryOperator()
                self.state = 988
                self.expressionAtom(5)
                pass

            elif la_ == 5:
                localctx = evaql_parser.NestedExpressionAtomContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 990
                self.match(evaql_parser.LR_BRACKET)
                self.state = 991
                self.expression(0)
                self.state = 996
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==evaql_parser.COMMA:
                    self.state = 992
                    self.match(evaql_parser.COMMA)
                    self.state = 993
                    self.expression(0)
                    self.state = 998
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 999
                self.match(evaql_parser.RR_BRACKET)
                pass

            elif la_ == 6:
                localctx = evaql_parser.SubqueryExpessionAtomContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1001
                self.match(evaql_parser.LR_BRACKET)
                self.state = 1002
                self.selectStatement(0)
                self.state = 1003
                self.match(evaql_parser.RR_BRACKET)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1017
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,123,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1015
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
                    if la_ == 1:
                        localctx = evaql_parser.BitExpressionAtomContext(self, evaql_parser.ExpressionAtomContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expressionAtom)
                        self.state = 1007
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1008
                        self.bitOperator()
                        self.state = 1009
                        localctx.right = self.expressionAtom(3)
                        pass

                    elif la_ == 2:
                        localctx = evaql_parser.MathExpressionAtomContext(self, evaql_parser.ExpressionAtomContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expressionAtom)
                        self.state = 1011
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1012
                        self.mathOperator()
                        self.state = 1013
                        localctx.right = self.expressionAtom(2)
                        pass

             
                self.state = 1019
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,123,self._ctx)

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


    class UnaryOperatorContext(ParserRuleContext):

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

        def EXCLAMATION_SYMBOL(self):
            return self.getToken(evaql_parser.EXCLAMATION_SYMBOL, 0)

        def BIT_NOT_OP(self):
            return self.getToken(evaql_parser.BIT_NOT_OP, 0)

        def PLUS(self):
            return self.getToken(evaql_parser.PLUS, 0)

        def MINUS(self):
            return self.getToken(evaql_parser.MINUS, 0)

        def NOT(self):
            return self.getToken(evaql_parser.NOT, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_unaryOperator

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

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

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




    def unaryOperator(self):

        localctx = evaql_parser.UnaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1020
            _la = self._input.LA(1)
            if not(_la==evaql_parser.NOT or ((((_la - 126)) & ~0x3f) == 0 and ((1 << (_la - 126)) & ((1 << (evaql_parser.PLUS - 126)) | (1 << (evaql_parser.MINUS - 126)) | (1 << (evaql_parser.EXCLAMATION_SYMBOL - 126)) | (1 << (evaql_parser.BIT_NOT_OP - 126)))) != 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 ComparisonOperatorContext(ParserRuleContext):

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

        def EQUAL_SYMBOL(self):
            return self.getToken(evaql_parser.EQUAL_SYMBOL, 0)

        def GREATER_SYMBOL(self):
            return self.getToken(evaql_parser.GREATER_SYMBOL, 0)

        def LESS_SYMBOL(self):
            return self.getToken(evaql_parser.LESS_SYMBOL, 0)

        def EXCLAMATION_SYMBOL(self):
            return self.getToken(evaql_parser.EXCLAMATION_SYMBOL, 0)

        def AT_SIGN(self):
            return self.getToken(evaql_parser.AT_SIGN, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_comparisonOperator

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

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

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




    def comparisonOperator(self):

        localctx = evaql_parser.ComparisonOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_comparisonOperator)
        try:
            self.state = 1040
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1022
                self.match(evaql_parser.EQUAL_SYMBOL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1023
                self.match(evaql_parser.GREATER_SYMBOL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1024
                self.match(evaql_parser.LESS_SYMBOL)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1025
                self.match(evaql_parser.LESS_SYMBOL)
                self.state = 1026
                self.match(evaql_parser.EQUAL_SYMBOL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1027
                self.match(evaql_parser.GREATER_SYMBOL)
                self.state = 1028
                self.match(evaql_parser.EQUAL_SYMBOL)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1029
                self.match(evaql_parser.LESS_SYMBOL)
                self.state = 1030
                self.match(evaql_parser.GREATER_SYMBOL)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1031
                self.match(evaql_parser.EXCLAMATION_SYMBOL)
                self.state = 1032
                self.match(evaql_parser.EQUAL_SYMBOL)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1033
                self.match(evaql_parser.LESS_SYMBOL)
                self.state = 1034
                self.match(evaql_parser.EQUAL_SYMBOL)
                self.state = 1035
                self.match(evaql_parser.GREATER_SYMBOL)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1036
                self.match(evaql_parser.AT_SIGN)
                self.state = 1037
                self.match(evaql_parser.GREATER_SYMBOL)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1038
                self.match(evaql_parser.LESS_SYMBOL)
                self.state = 1039
                self.match(evaql_parser.AT_SIGN)
                pass


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


    class LogicalOperatorContext(ParserRuleContext):

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

        def AND(self):
            return self.getToken(evaql_parser.AND, 0)

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

        def XOR(self):
            return self.getToken(evaql_parser.XOR, 0)

        def OR(self):
            return self.getToken(evaql_parser.OR, 0)

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

        def getRuleIndex(self):
            return evaql_parser.RULE_logicalOperator

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

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

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




    def logicalOperator(self):

        localctx = evaql_parser.LogicalOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_logicalOperator)
        try:
            self.state = 1049
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.AND]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1042
                self.match(evaql_parser.AND)
                pass
            elif token in [evaql_parser.BIT_AND_OP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1043
                self.match(evaql_parser.BIT_AND_OP)
                self.state = 1044
                self.match(evaql_parser.BIT_AND_OP)
                pass
            elif token in [evaql_parser.XOR]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1045
                self.match(evaql_parser.XOR)
                pass
            elif token in [evaql_parser.OR]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1046
                self.match(evaql_parser.OR)
                pass
            elif token in [evaql_parser.BIT_OR_OP]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1047
                self.match(evaql_parser.BIT_OR_OP)
                self.state = 1048
                self.match(evaql_parser.BIT_OR_OP)
                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 BitOperatorContext(ParserRuleContext):

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

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

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

        def BIT_AND_OP(self):
            return self.getToken(evaql_parser.BIT_AND_OP, 0)

        def BIT_XOR_OP(self):
            return self.getToken(evaql_parser.BIT_XOR_OP, 0)

        def BIT_OR_OP(self):
            return self.getToken(evaql_parser.BIT_OR_OP, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_bitOperator

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

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

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




    def bitOperator(self):

        localctx = evaql_parser.BitOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_bitOperator)
        try:
            self.state = 1058
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [evaql_parser.LESS_SYMBOL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1051
                self.match(evaql_parser.LESS_SYMBOL)
                self.state = 1052
                self.match(evaql_parser.LESS_SYMBOL)
                pass
            elif token in [evaql_parser.GREATER_SYMBOL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1053
                self.match(evaql_parser.GREATER_SYMBOL)
                self.state = 1054
                self.match(evaql_parser.GREATER_SYMBOL)
                pass
            elif token in [evaql_parser.BIT_AND_OP]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1055
                self.match(evaql_parser.BIT_AND_OP)
                pass
            elif token in [evaql_parser.BIT_XOR_OP]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1056
                self.match(evaql_parser.BIT_XOR_OP)
                pass
            elif token in [evaql_parser.BIT_OR_OP]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1057
                self.match(evaql_parser.BIT_OR_OP)
                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 MathOperatorContext(ParserRuleContext):

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

        def STAR(self):
            return self.getToken(evaql_parser.STAR, 0)

        def DIVIDE(self):
            return self.getToken(evaql_parser.DIVIDE, 0)

        def MODULE(self):
            return self.getToken(evaql_parser.MODULE, 0)

        def DIV(self):
            return self.getToken(evaql_parser.DIV, 0)

        def MOD(self):
            return self.getToken(evaql_parser.MOD, 0)

        def PLUS(self):
            return self.getToken(evaql_parser.PLUS, 0)

        def MINUS(self):
            return self.getToken(evaql_parser.MINUS, 0)

        def MINUSMINUS(self):
            return self.getToken(evaql_parser.MINUSMINUS, 0)

        def getRuleIndex(self):
            return evaql_parser.RULE_mathOperator

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

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

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




    def mathOperator(self):

        localctx = evaql_parser.MathOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_mathOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1060
            _la = self._input.LA(1)
            if not(((((_la - 123)) & ~0x3f) == 0 and ((1 << (_la - 123)) & ((1 << (evaql_parser.STAR - 123)) | (1 << (evaql_parser.DIVIDE - 123)) | (1 << (evaql_parser.MODULE - 123)) | (1 << (evaql_parser.PLUS - 123)) | (1 << (evaql_parser.MINUSMINUS - 123)) | (1 << (evaql_parser.MINUS - 123)) | (1 << (evaql_parser.DIV - 123)) | (1 << (evaql_parser.MOD - 123)))) != 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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[25] = self.selectStatement_sempred
        self._predicates[89] = self.expression_sempred
        self._predicates[90] = self.predicate_sempred
        self._predicates[91] = self.expressionAtom_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def selectStatement_sempred(self, localctx:SelectStatementContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 3)
         

    def predicate_sempred(self, localctx:PredicateContext, predIndex:int):
            if predIndex == 2:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 2)
         

    def expressionAtom_sempred(self, localctx:ExpressionAtomContext, predIndex:int):
            if predIndex == 7:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 1)
         




