# Generated from _qpd_antlr/sql.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\u012b")
        buf.write("\u0bb7\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\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
        buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
        buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
        buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
        buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
        buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
        buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\3\2\3")
        buf.write("\2\7\2\u0117\n\2\f\2\16\2\u011a\13\2\3\2\3\2\3\3\3\3\3")
        buf.write("\3\3\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b")
        buf.write("\3\b\3\b\3\t\3\t\5\t\u0132\n\t\3\t\3\t\3\t\5\t\u0137\n")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u013f\n\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\7\t\u0147\n\t\f\t\16\t\u014a\13\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t")
        buf.write("\3\t\5\t\u015d\n\t\3\t\3\t\5\t\u0161\n\t\3\t\3\t\3\t\3")
        buf.write("\t\5\t\u0167\n\t\3\t\5\t\u016a\n\t\3\t\5\t\u016d\n\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\5\t\u0174\n\t\3\t\3\t\3\t\5\t\u0179")
        buf.write("\n\t\3\t\5\t\u017c\n\t\3\t\3\t\3\t\3\t\3\t\5\t\u0183\n")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u018f\n")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u0198\n\t\f\t\16\t")
        buf.write("\u019b\13\t\3\t\5\t\u019e\n\t\3\t\5\t\u01a1\n\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\5\t\u01a8\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\7\t\u01b3\n\t\f\t\16\t\u01b6\13\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\5\t\u01bd\n\t\3\t\3\t\3\t\5\t\u01c2\n\t\3\t")
        buf.write("\5\t\u01c5\n\t\3\t\3\t\3\t\3\t\5\t\u01cb\n\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u01d6\n\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t")
        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t")
        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\5\t\u0216\n\t\3\t\3\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\5\t\u021f\n\t\3\t\3\t\5\t\u0223\n\t\3\t\3\t\3\t")
        buf.write("\3\t\5\t\u0229\n\t\3\t\3\t\5\t\u022d\n\t\3\t\3\t\3\t\5")
        buf.write("\t\u0232\n\t\3\t\3\t\3\t\3\t\5\t\u0238\n\t\3\t\3\t\3\t")
        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u0244\n\t\3\t\3\t\3\t")
        buf.write("\3\t\3\t\3\t\5\t\u024c\n\t\3\t\3\t\3\t\3\t\5\t\u0252\n")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u025f")
        buf.write("\n\t\3\t\6\t\u0262\n\t\r\t\16\t\u0263\3\t\3\t\3\t\3\t")
        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u0274\n\t")
        buf.write("\3\t\3\t\3\t\7\t\u0279\n\t\f\t\16\t\u027c\13\t\3\t\5\t")
        buf.write("\u027f\n\t\3\t\3\t\3\t\3\t\5\t\u0285\n\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u0294\n\t\3")
        buf.write("\t\3\t\5\t\u0298\n\t\3\t\3\t\3\t\3\t\5\t\u029e\n\t\3\t")
        buf.write("\3\t\3\t\3\t\5\t\u02a4\n\t\3\t\5\t\u02a7\n\t\3\t\5\t\u02aa")
        buf.write("\n\t\3\t\3\t\3\t\3\t\5\t\u02b0\n\t\3\t\3\t\5\t\u02b4\n")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u02bc\n\t\f\t\16\t\u02bf")
        buf.write("\13\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u02c7\n\t\3\t\5\t\u02ca")
        buf.write("\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u02d3\n\t\3\t\3\t")
        buf.write("\3\t\5\t\u02d8\n\t\3\t\3\t\3\t\3\t\5\t\u02de\n\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\5\t\u02e5\n\t\3\t\5\t\u02e8\n\t\3\t\3\t")
        buf.write("\3\t\3\t\5\t\u02ee\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t")
        buf.write("\u02f7\n\t\f\t\16\t\u02fa\13\t\5\t\u02fc\n\t\3\t\3\t\5")
        buf.write("\t\u0300\n\t\3\t\3\t\3\t\5\t\u0305\n\t\3\t\3\t\3\t\5\t")
        buf.write("\u030a\n\t\3\t\3\t\3\t\3\t\3\t\5\t\u0311\n\t\3\t\5\t\u0314")
        buf.write("\n\t\3\t\5\t\u0317\n\t\3\t\3\t\3\t\3\t\3\t\5\t\u031e\n")
        buf.write("\t\3\t\3\t\3\t\5\t\u0323\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
        buf.write("\t\5\t\u032c\n\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u0334\n\t")
        buf.write("\3\t\3\t\3\t\3\t\5\t\u033a\n\t\3\t\5\t\u033d\n\t\3\t\5")
        buf.write("\t\u0340\n\t\3\t\3\t\3\t\3\t\5\t\u0346\n\t\3\t\3\t\5\t")
        buf.write("\u034a\n\t\3\t\3\t\5\t\u034e\n\t\3\t\3\t\5\t\u0352\n\t")
        buf.write("\5\t\u0354\n\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u035c\n\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\5\t\u0364\n\t\3\t\3\t\3\t\3\t\5")
        buf.write("\t\u036a\n\t\3\t\3\t\3\t\3\t\5\t\u0370\n\t\3\t\5\t\u0373")
        buf.write("\n\t\3\t\3\t\5\t\u0377\n\t\3\t\5\t\u037a\n\t\3\t\3\t\5")
        buf.write("\t\u037e\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u0395\n")
        buf.write("\t\f\t\16\t\u0398\13\t\5\t\u039a\n\t\3\t\3\t\5\t\u039e")
        buf.write("\n\t\3\t\3\t\3\t\3\t\5\t\u03a4\n\t\3\t\5\t\u03a7\n\t\3")
        buf.write("\t\5\t\u03aa\n\t\3\t\3\t\3\t\3\t\5\t\u03b0\n\t\3\t\3\t")
        buf.write("\3\t\3\t\3\t\3\t\5\t\u03b8\n\t\3\t\3\t\3\t\5\t\u03bd\n")
        buf.write("\t\3\t\3\t\3\t\3\t\5\t\u03c3\n\t\3\t\3\t\3\t\3\t\5\t\u03c9")
        buf.write("\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u03d3\n\t\f\t")
        buf.write("\16\t\u03d6\13\t\5\t\u03d8\n\t\3\t\3\t\3\t\7\t\u03dd\n")
        buf.write("\t\f\t\16\t\u03e0\13\t\3\t\3\t\7\t\u03e4\n\t\f\t\16\t")
        buf.write("\u03e7\13\t\3\t\3\t\3\t\7\t\u03ec\n\t\f\t\16\t\u03ef\13")
        buf.write("\t\5\t\u03f1\n\t\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u03f9\n\n")
        buf.write("\3\n\3\n\5\n\u03fd\n\n\3\n\3\n\3\n\3\n\3\n\5\n\u0404\n")
        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u0478\n\n\3\n\3\n\3\n\3")
        buf.write("\n\3\n\3\n\5\n\u0480\n\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u0488")
        buf.write("\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u0491\n\n\3\n\3\n")
        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u049b\n\n\3\13\3\13\5\13")
        buf.write("\u049f\n\13\3\13\5\13\u04a2\n\13\3\13\3\13\3\13\3\13\5")
        buf.write("\13\u04a8\n\13\3\13\3\13\3\f\3\f\5\f\u04ae\n\f\3\f\3\f")
        buf.write("\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\5\r\u04ba\n\r\3\r\3\r")
        buf.write("\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u04c6\n\16")
        buf.write("\3\16\3\16\3\16\5\16\u04cb\n\16\3\17\3\17\3\17\3\20\3")
        buf.write("\20\3\20\3\21\5\21\u04d4\n\21\3\21\3\21\3\21\3\22\3\22")
        buf.write("\3\22\5\22\u04dc\n\22\3\22\3\22\3\22\3\22\3\22\5\22\u04e3")
        buf.write("\n\22\5\22\u04e5\n\22\3\22\3\22\3\22\5\22\u04ea\n\22\3")
        buf.write("\22\3\22\5\22\u04ee\n\22\3\22\3\22\3\22\5\22\u04f3\n\22")
        buf.write("\3\22\3\22\3\22\5\22\u04f8\n\22\3\22\3\22\3\22\5\22\u04fd")
        buf.write("\n\22\3\22\5\22\u0500\n\22\3\22\3\22\3\22\5\22\u0505\n")
        buf.write("\22\3\22\3\22\5\22\u0509\n\22\3\22\3\22\3\22\5\22\u050e")
        buf.write("\n\22\5\22\u0510\n\22\3\23\3\23\5\23\u0514\n\23\3\24\3")
        buf.write("\24\3\24\3\24\3\24\7\24\u051b\n\24\f\24\16\24\u051e\13")
        buf.write("\24\3\24\3\24\3\25\3\25\3\25\5\25\u0525\n\25\3\26\3\26")
        buf.write("\3\27\3\27\3\27\3\27\3\27\5\27\u052e\n\27\3\30\3\30\3")
        buf.write("\30\7\30\u0533\n\30\f\30\16\30\u0536\13\30\3\31\3\31\3")
        buf.write("\31\3\31\7\31\u053c\n\31\f\31\16\31\u053f\13\31\3\32\3")
        buf.write("\32\5\32\u0543\n\32\3\32\5\32\u0546\n\32\3\32\3\32\3\32")
        buf.write("\3\32\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
        buf.write("\3\34\3\34\3\34\7\34\u0559\n\34\f\34\16\34\u055c\13\34")
        buf.write("\3\35\3\35\3\35\3\35\7\35\u0562\n\35\f\35\16\35\u0565")
        buf.write("\13\35\3\35\3\35\3\36\3\36\5\36\u056b\n\36\3\36\5\36\u056e")
        buf.write("\n\36\3\37\3\37\3\37\7\37\u0573\n\37\f\37\16\37\u0576")
        buf.write("\13\37\3\37\5\37\u0579\n\37\3 \3 \3 \3 \5 \u057f\n \3")
        buf.write("!\3!\3!\3!\7!\u0585\n!\f!\16!\u0588\13!\3!\3!\3\"\3\"")
        buf.write("\3\"\3\"\7\"\u0590\n\"\f\"\16\"\u0593\13\"\3\"\3\"\3#")
        buf.write("\3#\3#\3#\3#\3#\5#\u059d\n#\3$\3$\3$\3$\3$\5$\u05a4\n")
        buf.write("$\3%\3%\3%\3%\5%\u05aa\n%\3&\3&\3&\3\'\3\'\3\'\3\'\3\'")
        buf.write("\3\'\6\'\u05b5\n\'\r\'\16\'\u05b6\3\'\3\'\3\'\3\'\3\'")
        buf.write("\5\'\u05be\n\'\3\'\3\'\3\'\3\'\3\'\5\'\u05c5\n\'\3\'\3")
        buf.write("\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u05d1\n\'\3\'\3")
        buf.write("\'\3\'\3\'\7\'\u05d7\n\'\f\'\16\'\u05da\13\'\3\'\7\'\u05dd")
        buf.write("\n\'\f\'\16\'\u05e0\13\'\5\'\u05e2\n\'\3(\3(\3(\3(\3(")
        buf.write("\7(\u05e9\n(\f(\16(\u05ec\13(\5(\u05ee\n(\3(\3(\3(\3(")
        buf.write("\3(\7(\u05f5\n(\f(\16(\u05f8\13(\5(\u05fa\n(\3(\3(\3(")
        buf.write("\3(\3(\7(\u0601\n(\f(\16(\u0604\13(\5(\u0606\n(\3(\3(")
        buf.write("\3(\3(\3(\7(\u060d\n(\f(\16(\u0610\13(\5(\u0612\n(\3(")
        buf.write("\5(\u0615\n(\3(\3(\3(\5(\u061a\n(\5(\u061c\n(\3)\3)\3")
        buf.write(")\3*\3*\3*\3*\3*\3*\3*\5*\u0628\n*\3*\3*\3*\3*\3*\5*\u062f")
        buf.write("\n*\3*\3*\3*\3*\3*\5*\u0636\n*\3*\7*\u0639\n*\f*\16*\u063c")
        buf.write("\13*\3+\3+\3+\3+\3+\3+\3+\3+\3+\5+\u0647\n+\3,\3,\5,\u064b")
        buf.write("\n,\3,\3,\5,\u064f\n,\3-\3-\6-\u0653\n-\r-\16-\u0654\3")
        buf.write(".\3.\5.\u0659\n.\3.\3.\3.\3.\7.\u065f\n.\f.\16.\u0662")
        buf.write("\13.\3.\5.\u0665\n.\3.\5.\u0668\n.\3.\5.\u066b\n.\3.\5")
        buf.write(".\u066e\n.\3.\3.\5.\u0672\n.\3/\3/\5/\u0676\n/\3/\5/\u0679")
        buf.write("\n/\3/\3/\5/\u067d\n/\3/\7/\u0680\n/\f/\16/\u0683\13/")
        buf.write("\3/\5/\u0686\n/\3/\5/\u0689\n/\3/\5/\u068c\n/\3/\5/\u068f")
        buf.write("\n/\5/\u0691\n/\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60")
        buf.write("\3\60\3\60\5\60\u069d\n\60\3\60\5\60\u06a0\n\60\3\60\3")
        buf.write("\60\5\60\u06a4\n\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60")
        buf.write("\3\60\5\60\u06ae\n\60\3\60\3\60\5\60\u06b2\n\60\5\60\u06b4")
        buf.write("\n\60\3\60\5\60\u06b7\n\60\3\60\3\60\5\60\u06bb\n\60\3")
        buf.write("\61\3\61\7\61\u06bf\n\61\f\61\16\61\u06c2\13\61\3\61\5")
        buf.write("\61\u06c5\n\61\3\61\3\61\3\62\3\62\3\62\3\63\3\63\3\63")
        buf.write("\3\63\5\63\u06d0\n\63\3\63\3\63\3\63\3\64\3\64\3\64\3")
        buf.write("\64\3\64\5\64\u06da\n\64\3\64\3\64\3\64\3\65\3\65\3\65")
        buf.write("\3\65\3\65\3\65\3\65\5\65\u06e6\n\65\3\66\3\66\3\66\3")
        buf.write("\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\7\66\u06f3\n\66")
        buf.write("\f\66\16\66\u06f6\13\66\3\66\3\66\5\66\u06fa\n\66\3\67")
        buf.write("\3\67\3\67\7\67\u06ff\n\67\f\67\16\67\u0702\13\67\38\3")
        buf.write("8\38\38\39\39\39\3:\3:\3:\3;\3;\3;\5;\u0711\n;\3;\7;\u0714")
        buf.write("\n;\f;\16;\u0717\13;\3;\3;\3<\3<\3<\3<\3<\3<\7<\u0721")
        buf.write("\n<\f<\16<\u0724\13<\3<\3<\5<\u0728\n<\3=\3=\3=\3=\7=")
        buf.write("\u072e\n=\f=\16=\u0731\13=\3=\7=\u0734\n=\f=\16=\u0737")
        buf.write("\13=\3=\5=\u073a\n=\3>\3>\3>\3>\3>\7>\u0741\n>\f>\16>")
        buf.write("\u0744\13>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\7>\u0750\n>\f")
        buf.write(">\16>\u0753\13>\3>\3>\5>\u0757\n>\3>\3>\3>\3>\3>\3>\3")
        buf.write(">\3>\7>\u0761\n>\f>\16>\u0764\13>\3>\3>\5>\u0768\n>\3")
        buf.write("?\3?\3?\3?\7?\u076e\n?\f?\16?\u0771\13?\5?\u0773\n?\3")
        buf.write("?\3?\5?\u0777\n?\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\7@\u0783")
        buf.write("\n@\f@\16@\u0786\13@\3@\3@\3@\3A\3A\3A\3A\3A\7A\u0790")
        buf.write("\nA\fA\16A\u0793\13A\3A\3A\5A\u0797\nA\3B\3B\5B\u079b")
        buf.write("\nB\3B\5B\u079e\nB\3C\3C\3C\5C\u07a3\nC\3C\3C\3C\3C\3")
        buf.write("C\7C\u07aa\nC\fC\16C\u07ad\13C\5C\u07af\nC\3C\3C\3C\5")
        buf.write("C\u07b4\nC\3C\3C\3C\7C\u07b9\nC\fC\16C\u07bc\13C\5C\u07be")
        buf.write("\nC\3D\3D\3E\3E\7E\u07c4\nE\fE\16E\u07c7\13E\3F\3F\3F")
        buf.write("\3F\5F\u07cd\nF\3F\3F\3F\3F\3F\5F\u07d4\nF\3G\5G\u07d7")
        buf.write("\nG\3G\3G\3G\5G\u07dc\nG\3G\5G\u07df\nG\3G\3G\3G\5G\u07e4")
        buf.write("\nG\3G\3G\5G\u07e8\nG\3G\5G\u07eb\nG\3G\5G\u07ee\nG\3")
        buf.write("H\3H\3H\3H\5H\u07f4\nH\3I\3I\3I\5I\u07f9\nI\3I\3I\3J\5")
        buf.write("J\u07fe\nJ\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3")
        buf.write("J\3J\5J\u0810\nJ\5J\u0812\nJ\3J\5J\u0815\nJ\3K\3K\3K\3")
        buf.write("K\3L\3L\3L\7L\u081e\nL\fL\16L\u0821\13L\3M\3M\3M\3M\7")
        buf.write("M\u0827\nM\fM\16M\u082a\13M\3M\3M\3N\3N\5N\u0830\nN\3")
        buf.write("O\3O\3O\3O\7O\u0836\nO\fO\16O\u0839\13O\3O\3O\3P\3P\5")
        buf.write("P\u083f\nP\3Q\3Q\5Q\u0843\nQ\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u084b")
        buf.write("\nQ\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u0853\nQ\3Q\3Q\5Q\u0857\nQ\3")
        buf.write("R\3R\3R\3R\7R\u085d\nR\fR\16R\u0860\13R\3R\3R\3S\3S\3")
        buf.write("S\3S\3S\7S\u0869\nS\fS\16S\u086c\13S\5S\u086e\nS\3S\3")
        buf.write("S\3S\3T\5T\u0874\nT\3T\3T\5T\u0878\nT\5T\u087a\nT\3U\3")
        buf.write("U\3U\3U\3U\3U\3U\5U\u0883\nU\3U\3U\3U\3U\3U\3U\3U\3U\3")
        buf.write("U\3U\5U\u088f\nU\5U\u0891\nU\3U\3U\3U\3U\3U\5U\u0898\n")
        buf.write("U\3U\3U\3U\3U\3U\5U\u089f\nU\3U\3U\3U\3U\5U\u08a5\nU\3")
        buf.write("U\3U\3U\3U\5U\u08ab\nU\5U\u08ad\nU\3V\3V\3V\7V\u08b2\n")
        buf.write("V\fV\16V\u08b5\13V\3W\3W\3W\7W\u08ba\nW\fW\16W\u08bd\13")
        buf.write("W\3X\3X\3X\5X\u08c2\nX\3X\3X\3Y\3Y\3Y\5Y\u08c9\nY\3Y\3")
        buf.write("Y\3Z\3Z\5Z\u08cf\nZ\3Z\3Z\5Z\u08d3\nZ\5Z\u08d5\nZ\3[\3")
        buf.write("[\3[\7[\u08da\n[\f[\16[\u08dd\13[\3\\\3\\\3\\\3\\\7\\")
        buf.write("\u08e3\n\\\f\\\16\\\u08e6\13\\\3\\\3\\\3]\3]\3]\3]\3]")
        buf.write("\3]\7]\u08f0\n]\f]\16]\u08f3\13]\3]\3]\5]\u08f7\n]\3^")
        buf.write("\3^\5^\u08fb\n^\3_\3_\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\5")
        buf.write("`\u0909\n`\5`\u090b\n`\3`\3`\3`\3`\3`\3`\7`\u0913\n`\f")
        buf.write("`\16`\u0916\13`\3a\5a\u0919\na\3a\3a\3a\3a\3a\3a\5a\u0921")
        buf.write("\na\3a\3a\3a\3a\3a\7a\u0928\na\fa\16a\u092b\13a\3a\3a")
        buf.write("\3a\5a\u0930\na\3a\3a\3a\3a\3a\3a\5a\u0938\na\3a\3a\3")
        buf.write("a\5a\u093d\na\3a\3a\3a\3a\3a\3a\3a\3a\7a\u0947\na\fa\16")
        buf.write("a\u094a\13a\3a\3a\5a\u094e\na\3a\5a\u0951\na\3a\3a\3a")
        buf.write("\3a\5a\u0957\na\3a\3a\5a\u095b\na\3a\3a\3a\5a\u0960\n")
        buf.write("a\3a\3a\3a\5a\u0965\na\3a\3a\3a\5a\u096a\na\3b\3b\3b\3")
        buf.write("b\5b\u0970\nb\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3")
        buf.write("b\3b\3b\3b\3b\3b\7b\u0985\nb\fb\16b\u0988\13b\3c\3c\3")
        buf.write("c\3c\6c\u098e\nc\rc\16c\u098f\3c\3c\5c\u0994\nc\3c\3c")
        buf.write("\3c\3c\3c\6c\u099b\nc\rc\16c\u099c\3c\3c\5c\u09a1\nc\3")
        buf.write("c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\7c\u09b1\nc\f")
        buf.write("c\16c\u09b4\13c\5c\u09b6\nc\3c\3c\3c\3c\3c\3c\5c\u09be")
        buf.write("\nc\3c\3c\3c\3c\3c\3c\3c\5c\u09c7\nc\3c\3c\3c\3c\3c\3")
        buf.write("c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\6c\u09dc\nc\r")
        buf.write("c\16c\u09dd\3c\3c\3c\3c\3c\3c\3c\3c\3c\5c\u09e9\nc\3c")
        buf.write("\3c\3c\7c\u09ee\nc\fc\16c\u09f1\13c\5c\u09f3\nc\3c\3c")
        buf.write("\3c\3c\3c\3c\3c\5c\u09fc\nc\3c\3c\5c\u0a00\nc\3c\3c\3")
        buf.write("c\3c\3c\3c\3c\3c\6c\u0a0a\nc\rc\16c\u0a0b\3c\3c\3c\3c")
        buf.write("\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3")
        buf.write("c\3c\5c\u0a25\nc\3c\3c\3c\3c\3c\5c\u0a2c\nc\3c\5c\u0a2f")
        buf.write("\nc\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\5c\u0a3e\n")
        buf.write("c\3c\3c\5c\u0a42\nc\3c\3c\3c\3c\3c\3c\3c\3c\7c\u0a4c\n")
        buf.write("c\fc\16c\u0a4f\13c\3d\3d\3d\3d\3d\3d\3d\3d\6d\u0a59\n")
        buf.write("d\rd\16d\u0a5a\5d\u0a5d\nd\3e\3e\3f\3f\3g\3g\3h\3h\3i")
        buf.write("\3i\3i\5i\u0a6a\ni\3j\3j\5j\u0a6e\nj\3k\3k\3k\6k\u0a73")
        buf.write("\nk\rk\16k\u0a74\3l\3l\3l\5l\u0a7a\nl\3m\3m\3m\3m\3m\3")
        buf.write("n\5n\u0a82\nn\3n\3n\5n\u0a86\nn\3o\3o\3o\3o\3o\3o\3o\5")
        buf.write("o\u0a8f\no\3p\3p\3p\5p\u0a94\np\3q\3q\3q\3q\3q\3q\3q\3")
        buf.write("q\3q\3q\3q\3q\3q\3q\3q\5q\u0aa5\nq\3q\3q\5q\u0aa9\nq\3")
        buf.write("q\3q\3q\3q\3q\7q\u0ab0\nq\fq\16q\u0ab3\13q\3q\5q\u0ab6")
        buf.write("\nq\5q\u0ab8\nq\3r\3r\3r\7r\u0abd\nr\fr\16r\u0ac0\13r")
        buf.write("\3s\3s\3s\3s\5s\u0ac6\ns\3s\5s\u0ac9\ns\3s\5s\u0acc\n")
        buf.write("s\3t\3t\3t\7t\u0ad1\nt\ft\16t\u0ad4\13t\3u\3u\3u\3u\5")
        buf.write("u\u0ada\nu\3u\5u\u0add\nu\3v\3v\3v\7v\u0ae2\nv\fv\16v")
        buf.write("\u0ae5\13v\3w\3w\3w\3w\3w\5w\u0aec\nw\3w\5w\u0aef\nw\3")
        buf.write("x\3x\3x\3x\3x\3y\3y\3y\3y\7y\u0afa\ny\fy\16y\u0afd\13")
        buf.write("y\3z\3z\3z\3z\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\7{\u0b0e")
        buf.write("\n{\f{\16{\u0b11\13{\3{\3{\3{\3{\3{\7{\u0b18\n{\f{\16")
        buf.write("{\u0b1b\13{\5{\u0b1d\n{\3{\3{\3{\3{\3{\7{\u0b24\n{\f{")
        buf.write("\16{\u0b27\13{\5{\u0b29\n{\5{\u0b2b\n{\3{\5{\u0b2e\n{")
        buf.write("\3{\5{\u0b31\n{\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3")
        buf.write("|\3|\3|\3|\5|\u0b43\n|\3}\3}\3}\3}\3}\3}\3}\5}\u0b4c\n")
        buf.write("}\3~\3~\3~\7~\u0b51\n~\f~\16~\u0b54\13~\3\177\3\177\3")
        buf.write("\177\3\177\5\177\u0b5a\n\177\3\u0080\3\u0080\3\u0080\7")
        buf.write("\u0080\u0b5f\n\u0080\f\u0080\16\u0080\u0b62\13\u0080\3")
        buf.write("\u0081\3\u0081\3\u0081\3\u0082\3\u0082\6\u0082\u0b69\n")
        buf.write("\u0082\r\u0082\16\u0082\u0b6a\3\u0082\5\u0082\u0b6e\n")
        buf.write("\u0082\3\u0083\3\u0083\3\u0083\5\u0083\u0b73\n\u0083\3")
        buf.write("\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\5\u0084")
        buf.write("\u0b7b\n\u0084\3\u0085\3\u0085\3\u0086\3\u0086\5\u0086")
        buf.write("\u0b81\n\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u0b86\n")
        buf.write("\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u0b8b\n\u0086\3")
        buf.write("\u0086\3\u0086\5\u0086\u0b8f\n\u0086\3\u0086\3\u0086\5")
        buf.write("\u0086\u0b93\n\u0086\3\u0086\3\u0086\5\u0086\u0b97\n\u0086")
        buf.write("\3\u0086\3\u0086\5\u0086\u0b9b\n\u0086\3\u0086\3\u0086")
        buf.write("\5\u0086\u0b9f\n\u0086\3\u0086\3\u0086\5\u0086\u0ba3\n")
        buf.write("\u0086\3\u0086\5\u0086\u0ba6\n\u0086\3\u0087\3\u0087\3")
        buf.write("\u0087\3\u0087\3\u0087\3\u0087\3\u0087\5\u0087\u0baf\n")
        buf.write("\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a")
        buf.write("\3\u008a\7\u0396\u03d4\u03de\u03e5\u03ed\6R\u00be\u00c2")
        buf.write("\u00c4\u008b\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"")
        buf.write("$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz")
        buf.write("|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090")
        buf.write("\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2")
        buf.write("\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4")
        buf.write("\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6")
        buf.write("\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8")
        buf.write("\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea")
        buf.write("\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc")
        buf.write("\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e")
        buf.write("\u0110\u0112\2,\4\2CC\u00b6\u00b6\4\2\"\"\u00c4\u00c4")
        buf.write("\4\2AA\u0098\u0098\4\2ffss\3\2-.\4\2\u00e5\u00e5\u0103")
        buf.write("\u0103\4\2\21\21%%\7\2**\66\66XXee\u008f\u008f\3\2GH\4")
        buf.write("\2XXee\4\2\u009c\u009c\u011d\u011d\4\2\16\16\u0089\u0089")
        buf.write("\5\2@@\u0097\u0097\u00ce\u00ce\6\2SSzz\u00d7\u00d7\u00f9")
        buf.write("\u00f9\5\2SS\u00d7\u00d7\u00f9\u00f9\4\2\31\31GG\4\2`")
        buf.write("`\u0081\u0081\4\2\20\20LL\4\2\u0121\u0121\u0123\u0123")
        buf.write("\5\2\20\20\25\25\u00db\u00db\5\2[[\u00f3\u00f3\u00fb\u00fb")
        buf.write("\4\2\u0112\u0113\u0118\u0118\3\2\u0114\u0117\4\2\u0112")
        buf.write("\u0113\u011b\u011b\4\2;;==\3\2\u00e3\u00e4\4\2\6\6ff\4")
        buf.write("\2\6\6bb\5\2\35\35\u0084\u0084\u00ee\u00ee\3\2\u010a\u0111")
        buf.write("\3\2\u0112\u011c\6\2\23\23ss\u009b\u009b\u00a3\u00a3\4")
        buf.write("\2[[\u00f3\u00f3\3\2\u0112\u0113\4\2MM\u00ac\u00ac\4\2")
        buf.write("\u00a4\u00a4\u00dc\u00dc\4\2aa\u00b3\u00b3\3\2\u0122\u0123")
        buf.write("\4\2NN\u00d6\u00d6\65\2\16\17\21\22\26\27\31\32\34\34")
        buf.write("\36\"%%\'*,,.\64\66\669:?ACKMNRRTZ]]_adehjmmprtuwy{{~")
        buf.write("~\u0080\u0083\u0086\u0093\u0096\u0098\u009a\u009a\u009d")
        buf.write("\u009e\u00a1\u00a2\u00a5\u00a5\u00a7\u00a8\u00aa\u00b3")
        buf.write("\u00b5\u00bd\u00bf\u00c5\u00c7\u00ce\u00d2\u00d4\u00d6")
        buf.write("\u00d6\u00d8\u00da\u00dc\u00e4\u00e6\u00ea\u00ed\u00ed")
        buf.write("\u00ef\u00f4\u00f6\u00f8\u00fc\u00ff\u0102\u0104\u0107")
        buf.write("\u0107\u0117\u0117\21\2\24\2488SSggvvzz\177\177\u0085")
        buf.write("\u0085\u0099\u0099\u009f\u009f\u00c6\u00c6\u00d1\u00d1")
        buf.write("\u00d7\u00d7\u00f9\u00f9\u0101\u0101\23\2\16\23\25\67")
        buf.write("9RTfhuwy{~\u0080\u0084\u0086\u0098\u009a\u009e\u00a0\u00c5")
        buf.write("\u00c7\u00d0\u00d2\u00d6\u00d8\u00f8\u00fa\u0100\u0102")
        buf.write("\u0109\u0117\u0117\2\u0d88\2\u0114\3\2\2\2\4\u011d\3\2")
        buf.write("\2\2\6\u0120\3\2\2\2\b\u0123\3\2\2\2\n\u0126\3\2\2\2\f")
        buf.write("\u0129\3\2\2\2\16\u012c\3\2\2\2\20\u03f0\3\2\2\2\22\u049a")
        buf.write("\3\2\2\2\24\u049c\3\2\2\2\26\u04ad\3\2\2\2\30\u04b3\3")
        buf.write("\2\2\2\32\u04bf\3\2\2\2\34\u04cc\3\2\2\2\36\u04cf\3\2")
        buf.write("\2\2 \u04d3\3\2\2\2\"\u050f\3\2\2\2$\u0511\3\2\2\2&\u0515")
        buf.write("\3\2\2\2(\u0521\3\2\2\2*\u0526\3\2\2\2,\u052d\3\2\2\2")
        buf.write(".\u052f\3\2\2\2\60\u0537\3\2\2\2\62\u0540\3\2\2\2\64\u054b")
        buf.write("\3\2\2\2\66\u055a\3\2\2\28\u055d\3\2\2\2:\u0568\3\2\2")
        buf.write("\2<\u0578\3\2\2\2>\u057e\3\2\2\2@\u0580\3\2\2\2B\u058b")
        buf.write("\3\2\2\2D\u059c\3\2\2\2F\u05a3\3\2\2\2H\u05a5\3\2\2\2")
        buf.write("J\u05ab\3\2\2\2L\u05e1\3\2\2\2N\u05ed\3\2\2\2P\u061d\3")
        buf.write("\2\2\2R\u0620\3\2\2\2T\u0646\3\2\2\2V\u0648\3\2\2\2X\u0650")
        buf.write("\3\2\2\2Z\u0671\3\2\2\2\\\u0690\3\2\2\2^\u069c\3\2\2\2")
        buf.write("`\u06bc\3\2\2\2b\u06c8\3\2\2\2d\u06cb\3\2\2\2f\u06d4\3")
        buf.write("\2\2\2h\u06e5\3\2\2\2j\u06f9\3\2\2\2l\u06fb\3\2\2\2n\u0703")
        buf.write("\3\2\2\2p\u0707\3\2\2\2r\u070a\3\2\2\2t\u070d\3\2\2\2")
        buf.write("v\u0727\3\2\2\2x\u0729\3\2\2\2z\u0767\3\2\2\2|\u0776\3")
        buf.write("\2\2\2~\u0778\3\2\2\2\u0080\u0796\3\2\2\2\u0082\u0798")
        buf.write("\3\2\2\2\u0084\u079f\3\2\2\2\u0086\u07bf\3\2\2\2\u0088")
        buf.write("\u07c1\3\2\2\2\u008a\u07d3\3\2\2\2\u008c\u07ed\3\2\2\2")
        buf.write("\u008e\u07f3\3\2\2\2\u0090\u07f5\3\2\2\2\u0092\u0814\3")
        buf.write("\2\2\2\u0094\u0816\3\2\2\2\u0096\u081a\3\2\2\2\u0098\u0822")
        buf.write("\3\2\2\2\u009a\u082d\3\2\2\2\u009c\u0831\3\2\2\2\u009e")
        buf.write("\u083c\3\2\2\2\u00a0\u0856\3\2\2\2\u00a2\u0858\3\2\2\2")
        buf.write("\u00a4\u0863\3\2\2\2\u00a6\u0879\3\2\2\2\u00a8\u08ac\3")
        buf.write("\2\2\2\u00aa\u08ae\3\2\2\2\u00ac\u08b6\3\2\2\2\u00ae\u08c1")
        buf.write("\3\2\2\2\u00b0\u08c8\3\2\2\2\u00b2\u08cc\3\2\2\2\u00b4")
        buf.write("\u08d6\3\2\2\2\u00b6\u08de\3\2\2\2\u00b8\u08f6\3\2\2\2")
        buf.write("\u00ba\u08fa\3\2\2\2\u00bc\u08fc\3\2\2\2\u00be\u090a\3")
        buf.write("\2\2\2\u00c0\u0969\3\2\2\2\u00c2\u096f\3\2\2\2\u00c4\u0a41")
        buf.write("\3\2\2\2\u00c6\u0a5c\3\2\2\2\u00c8\u0a5e\3\2\2\2\u00ca")
        buf.write("\u0a60\3\2\2\2\u00cc\u0a62\3\2\2\2\u00ce\u0a64\3\2\2\2")
        buf.write("\u00d0\u0a66\3\2\2\2\u00d2\u0a6b\3\2\2\2\u00d4\u0a72\3")
        buf.write("\2\2\2\u00d6\u0a76\3\2\2\2\u00d8\u0a7b\3\2\2\2\u00da\u0a85")
        buf.write("\3\2\2\2\u00dc\u0a8e\3\2\2\2\u00de\u0a93\3\2\2\2\u00e0")
        buf.write("\u0ab7\3\2\2\2\u00e2\u0ab9\3\2\2\2\u00e4\u0ac1\3\2\2\2")
        buf.write("\u00e6\u0acd\3\2\2\2\u00e8\u0ad5\3\2\2\2\u00ea\u0ade\3")
        buf.write("\2\2\2\u00ec\u0ae6\3\2\2\2\u00ee\u0af0\3\2\2\2\u00f0\u0af5")
        buf.write("\3\2\2\2\u00f2\u0afe\3\2\2\2\u00f4\u0b30\3\2\2\2\u00f6")
        buf.write("\u0b42\3\2\2\2\u00f8\u0b4b\3\2\2\2\u00fa\u0b4d\3\2\2\2")
        buf.write("\u00fc\u0b59\3\2\2\2\u00fe\u0b5b\3\2\2\2\u0100\u0b63\3")
        buf.write("\2\2\2\u0102\u0b6d\3\2\2\2\u0104\u0b72\3\2\2\2\u0106\u0b7a")
        buf.write("\3\2\2\2\u0108\u0b7c\3\2\2\2\u010a\u0ba5\3\2\2\2\u010c")
        buf.write("\u0bae\3\2\2\2\u010e\u0bb0\3\2\2\2\u0110\u0bb2\3\2\2\2")
        buf.write("\u0112\u0bb4\3\2\2\2\u0114\u0118\5\20\t\2\u0115\u0117")
        buf.write("\7\3\2\2\u0116\u0115\3\2\2\2\u0117\u011a\3\2\2\2\u0118")
        buf.write("\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b\3\2\2\2")
        buf.write("\u011a\u0118\3\2\2\2\u011b\u011c\7\2\2\3\u011c\3\3\2\2")
        buf.write("\2\u011d\u011e\5\u00b2Z\2\u011e\u011f\7\2\2\3\u011f\5")
        buf.write("\3\2\2\2\u0120\u0121\5\u00aeX\2\u0121\u0122\7\2\2\3\u0122")
        buf.write("\7\3\2\2\2\u0123\u0124\5\u00acW\2\u0124\u0125\7\2\2\3")
        buf.write("\u0125\t\3\2\2\2\u0126\u0127\5\u00b0Y\2\u0127\u0128\7")
        buf.write("\2\2\3\u0128\13\3\2\2\2\u0129\u012a\5\u00e0q\2\u012a\u012b")
        buf.write("\7\2\2\3\u012b\r\3\2\2\2\u012c\u012d\5\u00e6t\2\u012d")
        buf.write("\u012e\7\2\2\3\u012e\17\3\2\2\2\u012f\u03f1\5 \21\2\u0130")
        buf.write("\u0132\5\60\31\2\u0131\u0130\3\2\2\2\u0131\u0132\3\2\2")
        buf.write("\2\u0132\u0133\3\2\2\2\u0133\u03f1\5L\'\2\u0134\u0136")
        buf.write("\7\u00ff\2\2\u0135\u0137\7\u0097\2\2\u0136\u0135\3\2\2")
        buf.write("\2\u0136\u0137\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u03f1")
        buf.write("\5\u00acW\2\u0139\u013a\7\67\2\2\u013a\u013e\5*\26\2\u013b")
        buf.write("\u013c\7p\2\2\u013c\u013d\7\u009b\2\2\u013d\u013f\7U\2")
        buf.write("\2\u013e\u013b\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0140")
        buf.write("\3\2\2\2\u0140\u0148\5\u00acW\2\u0141\u0147\5\36\20\2")
        buf.write("\u0142\u0147\5\34\17\2\u0143\u0144\7\u0108\2\2\u0144\u0145")
        buf.write("\t\2\2\2\u0145\u0147\58\35\2\u0146\u0141\3\2\2\2\u0146")
        buf.write("\u0142\3\2\2\2\u0146\u0143\3\2\2\2\u0147\u014a\3\2\2\2")
        buf.write("\u0148\u0146\3\2\2\2\u0148\u0149\3\2\2\2\u0149\u03f1\3")
        buf.write("\2\2\2\u014a\u0148\3\2\2\2\u014b\u014c\7\21\2\2\u014c")
        buf.write("\u014d\5*\26\2\u014d\u014e\5\u00acW\2\u014e\u014f\7\u00d6")
        buf.write("\2\2\u014f\u0150\t\2\2\2\u0150\u0151\58\35\2\u0151\u03f1")
        buf.write("\3\2\2\2\u0152\u0153\7\21\2\2\u0153\u0154\5*\26\2\u0154")
        buf.write("\u0155\5\u00acW\2\u0155\u0156\7\u00d6\2\2\u0156\u0157")
        buf.write("\5\34\17\2\u0157\u03f1\3\2\2\2\u0158\u0159\7N\2\2\u0159")
        buf.write("\u015c\5*\26\2\u015a\u015b\7p\2\2\u015b\u015d\7U\2\2\u015c")
        buf.write("\u015a\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015e\3\2\2\2")
        buf.write("\u015e\u0160\5\u00acW\2\u015f\u0161\t\3\2\2\u0160\u015f")
        buf.write("\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u03f1\3\2\2\2\u0162")
        buf.write("\u0163\7\u00d9\2\2\u0163\u0166\t\4\2\2\u0164\u0165\t\5")
        buf.write("\2\2\u0165\u0167\5\u00acW\2\u0166\u0164\3\2\2\2\u0166")
        buf.write("\u0167\3\2\2\2\u0167\u016c\3\2\2\2\u0168\u016a\7\u0086")
        buf.write("\2\2\u0169\u0168\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u016b")
        buf.write("\3\2\2\2\u016b\u016d\7\u011d\2\2\u016c\u0169\3\2\2\2\u016c")
        buf.write("\u016d\3\2\2\2\u016d\u03f1\3\2\2\2\u016e\u0173\5\24\13")
        buf.write("\2\u016f\u0170\7\4\2\2\u0170\u0171\5\u00e6t\2\u0171\u0172")
        buf.write("\7\5\2\2\u0172\u0174\3\2\2\2\u0173\u016f\3\2\2\2\u0173")
        buf.write("\u0174\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u0176\5\64\33")
        buf.write("\2\u0176\u017b\5\66\34\2\u0177\u0179\7\30\2\2\u0178\u0177")
        buf.write("\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017a\3\2\2\2\u017a")
        buf.write("\u017c\5 \21\2\u017b\u0178\3\2\2\2\u017b\u017c\3\2\2\2")
        buf.write("\u017c\u03f1\3\2\2\2\u017d\u0182\5\24\13\2\u017e\u017f")
        buf.write("\7\4\2\2\u017f\u0180\5\u00e6t\2\u0180\u0181\7\5\2\2\u0181")
        buf.write("\u0183\3\2\2\2\u0182\u017e\3\2\2\2\u0182\u0183\3\2\2\2")
        buf.write("\u0183\u0199\3\2\2\2\u0184\u0198\5\36\20\2\u0185\u0186")
        buf.write("\7\u00ad\2\2\u0186\u0187\7 \2\2\u0187\u0188\7\4\2\2\u0188")
        buf.write("\u0189\5\u00e6t\2\u0189\u018a\7\5\2\2\u018a\u018f\3\2")
        buf.write("\2\2\u018b\u018c\7\u00ad\2\2\u018c\u018d\7 \2\2\u018d")
        buf.write("\u018f\5\u0094K\2\u018e\u0185\3\2\2\2\u018e\u018b\3\2")
        buf.write("\2\2\u018f\u0198\3\2\2\2\u0190\u0198\5\30\r\2\u0191\u0198")
        buf.write("\5\32\16\2\u0192\u0198\5\u00a8U\2\u0193\u0198\5D#\2\u0194")
        buf.write("\u0198\5\34\17\2\u0195\u0196\7\u00e8\2\2\u0196\u0198\5")
        buf.write("8\35\2\u0197\u0184\3\2\2\2\u0197\u018e\3\2\2\2\u0197\u0190")
        buf.write("\3\2\2\2\u0197\u0191\3\2\2\2\u0197\u0192\3\2\2\2\u0197")
        buf.write("\u0193\3\2\2\2\u0197\u0194\3\2\2\2\u0197\u0195\3\2\2\2")
        buf.write("\u0198\u019b\3\2\2\2\u0199\u0197\3\2\2\2\u0199\u019a\3")
        buf.write("\2\2\2\u019a\u01a0\3\2\2\2\u019b\u0199\3\2\2\2\u019c\u019e")
        buf.write("\7\30\2\2\u019d\u019c\3\2\2\2\u019d\u019e\3\2\2\2\u019e")
        buf.write("\u019f\3\2\2\2\u019f\u01a1\5 \21\2\u01a0\u019d\3\2\2\2")
        buf.write("\u01a0\u01a1\3\2\2\2\u01a1\u03f1\3\2\2\2\u01a2\u01a3\7")
        buf.write("\67\2\2\u01a3\u01a7\7\u00e5\2\2\u01a4\u01a5\7p\2\2\u01a5")
        buf.write("\u01a6\7\u009b\2\2\u01a6\u01a8\7U\2\2\u01a7\u01a4\3\2")
        buf.write("\2\2\u01a7\u01a8\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa")
        buf.write("\5\u00aeX\2\u01aa\u01ab\7\u0086\2\2\u01ab\u01b4\5\u00ae")
        buf.write("X\2\u01ac\u01b3\5\64\33\2\u01ad\u01b3\5\u00a8U\2\u01ae")
        buf.write("\u01b3\5D#\2\u01af\u01b3\5\34\17\2\u01b0\u01b1\7\u00e8")
        buf.write("\2\2\u01b1\u01b3\58\35\2\u01b2\u01ac\3\2\2\2\u01b2\u01ad")
        buf.write("\3\2\2\2\u01b2\u01ae\3\2\2\2\u01b2\u01af\3\2\2\2\u01b2")
        buf.write("\u01b0\3\2\2\2\u01b3\u01b6\3\2\2\2\u01b4\u01b2\3\2\2\2")
        buf.write("\u01b4\u01b5\3\2\2\2\u01b5\u03f1\3\2\2\2\u01b6\u01b4\3")
        buf.write("\2\2\2\u01b7\u01bc\5\26\f\2\u01b8\u01b9\7\4\2\2\u01b9")
        buf.write("\u01ba\5\u00e6t\2\u01ba\u01bb\7\5\2\2\u01bb\u01bd\3\2")
        buf.write("\2\2\u01bc\u01b8\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd\u01be")
        buf.write("\3\2\2\2\u01be\u01bf\5\64\33\2\u01bf\u01c4\5\66\34\2\u01c0")
        buf.write("\u01c2\7\30\2\2\u01c1\u01c0\3\2\2\2\u01c1\u01c2\3\2\2")
        buf.write("\2\u01c2\u01c3\3\2\2\2\u01c3\u01c5\5 \21\2\u01c4\u01c1")
        buf.write("\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u03f1\3\2\2\2\u01c6")
        buf.write("\u01c7\7\22\2\2\u01c7\u01c8\7\u00e5\2\2\u01c8\u01ca\5")
        buf.write("\u00acW\2\u01c9\u01cb\5&\24\2\u01ca\u01c9\3\2\2\2\u01ca")
        buf.write("\u01cb\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01cd\7\63\2")
        buf.write("\2\u01cd\u01d5\7\u00df\2\2\u01ce\u01d6\5\u0104\u0083\2")
        buf.write("\u01cf\u01d0\7b\2\2\u01d0\u01d1\7.\2\2\u01d1\u01d6\5\u0096")
        buf.write("L\2\u01d2\u01d3\7b\2\2\u01d3\u01d4\7\20\2\2\u01d4\u01d6")
        buf.write("\7.\2\2\u01d5\u01ce\3\2\2\2\u01d5\u01cf\3\2\2\2\u01d5")
        buf.write("\u01d2\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u03f1\3\2\2\2")
        buf.write("\u01d7\u01d8\7\21\2\2\u01d8\u01d9\7\u00e5\2\2\u01d9\u01da")
        buf.write("\5\u00acW\2\u01da\u01db\7\16\2\2\u01db\u01dc\t\6\2\2\u01dc")
        buf.write("\u01dd\5\u00e2r\2\u01dd\u03f1\3\2\2\2\u01de\u01df\7\21")
        buf.write("\2\2\u01df\u01e0\7\u00e5\2\2\u01e0\u01e1\5\u00acW\2\u01e1")
        buf.write("\u01e2\7\16\2\2\u01e2\u01e3\t\6\2\2\u01e3\u01e4\7\4\2")
        buf.write("\2\u01e4\u01e5\5\u00e2r\2\u01e5\u01e6\7\5\2\2\u01e6\u03f1")
        buf.write("\3\2\2\2\u01e7\u01e8\7\21\2\2\u01e8\u01e9\7\u00e5\2\2")
        buf.write("\u01e9\u01ea\5\u00acW\2\u01ea\u01eb\7\u00c0\2\2\u01eb")
        buf.write("\u01ec\7-\2\2\u01ec\u01ed\5\u00acW\2\u01ed\u01ee\7\u00ec")
        buf.write("\2\2\u01ee\u01ef\5\u0100\u0081\2\u01ef\u03f1\3\2\2\2\u01f0")
        buf.write("\u01f1\7\21\2\2\u01f1\u01f2\7\u00e5\2\2\u01f2\u01f3\5")
        buf.write("\u00acW\2\u01f3\u01f4\7N\2\2\u01f4\u01f5\t\6\2\2\u01f5")
        buf.write("\u01f6\7\4\2\2\u01f6\u01f7\5\u00aaV\2\u01f7\u01f8\7\5")
        buf.write("\2\2\u01f8\u03f1\3\2\2\2\u01f9\u01fa\7\21\2\2\u01fa\u01fb")
        buf.write("\7\u00e5\2\2\u01fb\u01fc\5\u00acW\2\u01fc\u01fd\7N\2\2")
        buf.write("\u01fd\u01fe\t\6\2\2\u01fe\u01ff\5\u00aaV\2\u01ff\u03f1")
        buf.write("\3\2\2\2\u0200\u0201\7\21\2\2\u0201\u0202\t\7\2\2\u0202")
        buf.write("\u0203\5\u00acW\2\u0203\u0204\7\u00c0\2\2\u0204\u0205")
        buf.write("\7\u00ec\2\2\u0205\u0206\5\u00acW\2\u0206\u03f1\3\2\2")
        buf.write("\2\u0207\u0208\7\21\2\2\u0208\u0209\t\7\2\2\u0209\u020a")
        buf.write("\5\u00acW\2\u020a\u020b\7\u00d6\2\2\u020b\u020c\7\u00e8")
        buf.write("\2\2\u020c\u020d\58\35\2\u020d\u03f1\3\2\2\2\u020e\u020f")
        buf.write("\7\21\2\2\u020f\u0210\t\7\2\2\u0210\u0211\5\u00acW\2\u0211")
        buf.write("\u0212\7\u00fd\2\2\u0212\u0215\7\u00e8\2\2\u0213\u0214")
        buf.write("\7p\2\2\u0214\u0216\7U\2\2\u0215\u0213\3\2\2\2\u0215\u0216")
        buf.write("\3\2\2\2\u0216\u0217\3\2\2\2\u0217\u0218\58\35\2\u0218")
        buf.write("\u03f1\3\2\2\2\u0219\u021a\7\21\2\2\u021a\u021b\7\u00e5")
        buf.write("\2\2\u021b\u021c\5\u00acW\2\u021c\u021e\t\b\2\2\u021d")
        buf.write("\u021f\7-\2\2\u021e\u021d\3\2\2\2\u021e\u021f\3\2\2\2")
        buf.write("\u021f\u0220\3\2\2\2\u0220\u0222\5\u00acW\2\u0221\u0223")
        buf.write("\5\u010c\u0087\2\u0222\u0221\3\2\2\2\u0222\u0223\3\2\2")
        buf.write("\2\u0223\u03f1\3\2\2\2\u0224\u0225\7\21\2\2\u0225\u0226")
        buf.write("\7\u00e5\2\2\u0226\u0228\5\u00acW\2\u0227\u0229\5&\24")
        buf.write("\2\u0228\u0227\3\2\2\2\u0228\u0229\3\2\2\2\u0229\u022a")
        buf.write("\3\2\2\2\u022a\u022c\7%\2\2\u022b\u022d\7-\2\2\u022c\u022b")
        buf.write("\3\2\2\2\u022c\u022d\3\2\2\2\u022d\u022e\3\2\2\2\u022e")
        buf.write("\u022f\5\u00acW\2\u022f\u0231\5\u00e8u\2\u0230\u0232\5")
        buf.write("\u00dep\2\u0231\u0230\3\2\2\2\u0231\u0232\3\2\2\2\u0232")
        buf.write("\u03f1\3\2\2\2\u0233\u0234\7\21\2\2\u0234\u0235\7\u00e5")
        buf.write("\2\2\u0235\u0237\5\u00acW\2\u0236\u0238\5&\24\2\u0237")
        buf.write("\u0236\3\2\2\2\u0237\u0238\3\2\2\2\u0238\u0239\3\2\2\2")
        buf.write("\u0239\u023a\7\u00c2\2\2\u023a\u023b\7.\2\2\u023b\u023c")
        buf.write("\7\4\2\2\u023c\u023d\5\u00e2r\2\u023d\u023e\7\5\2\2\u023e")
        buf.write("\u03f1\3\2\2\2\u023f\u0240\7\21\2\2\u0240\u0241\7\u00e5")
        buf.write("\2\2\u0241\u0243\5\u00acW\2\u0242\u0244\5&\24\2\u0243")
        buf.write("\u0242\3\2\2\2\u0243\u0244\3\2\2\2\u0244\u0245\3\2\2\2")
        buf.write("\u0245\u0246\7\u00d6\2\2\u0246\u0247\7\u00d3\2\2\u0247")
        buf.write("\u024b\7\u011d\2\2\u0248\u0249\7\u0108\2\2\u0249\u024a")
        buf.write("\7\u00d4\2\2\u024a\u024c\58\35\2\u024b\u0248\3\2\2\2\u024b")
        buf.write("\u024c\3\2\2\2\u024c\u03f1\3\2\2\2\u024d\u024e\7\21\2")
        buf.write("\2\u024e\u024f\7\u00e5\2\2\u024f\u0251\5\u00acW\2\u0250")
        buf.write("\u0252\5&\24\2\u0251\u0250\3\2\2\2\u0251\u0252\3\2\2\2")
        buf.write("\u0252\u0253\3\2\2\2\u0253\u0254\7\u00d6\2\2\u0254\u0255")
        buf.write("\7\u00d4\2\2\u0255\u0256\58\35\2\u0256\u03f1\3\2\2\2\u0257")
        buf.write("\u0258\7\21\2\2\u0258\u0259\t\7\2\2\u0259\u025a\5\u00ac")
        buf.write("W\2\u025a\u025e\7\16\2\2\u025b\u025c\7p\2\2\u025c\u025d")
        buf.write("\7\u009b\2\2\u025d\u025f\7U\2\2\u025e\u025b\3\2\2\2\u025e")
        buf.write("\u025f\3\2\2\2\u025f\u0261\3\2\2\2\u0260\u0262\5$\23\2")
        buf.write("\u0261\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263\u0261\3")
        buf.write("\2\2\2\u0263\u0264\3\2\2\2\u0264\u03f1\3\2\2\2\u0265\u0266")
        buf.write("\7\21\2\2\u0266\u0267\7\u00e5\2\2\u0267\u0268\5\u00ac")
        buf.write("W\2\u0268\u0269\5&\24\2\u0269\u026a\7\u00c0\2\2\u026a")
        buf.write("\u026b\7\u00ec\2\2\u026b\u026c\5&\24\2\u026c\u03f1\3\2")
        buf.write("\2\2\u026d\u026e\7\21\2\2\u026e\u026f\t\7\2\2\u026f\u0270")
        buf.write("\5\u00acW\2\u0270\u0273\7N\2\2\u0271\u0272\7p\2\2\u0272")
        buf.write("\u0274\7U\2\2\u0273\u0271\3\2\2\2\u0273\u0274\3\2\2\2")
        buf.write("\u0274\u0275\3\2\2\2\u0275\u027a\5&\24\2\u0276\u0277\7")
        buf.write("\6\2\2\u0277\u0279\5&\24\2\u0278\u0276\3\2\2\2\u0279\u027c")
        buf.write("\3\2\2\2\u027a\u0278\3\2\2\2\u027a\u027b\3\2\2\2\u027b")
        buf.write("\u027e\3\2\2\2\u027c\u027a\3\2\2\2\u027d\u027f\7\u00b7")
        buf.write("\2\2\u027e\u027d\3\2\2\2\u027e\u027f\3\2\2\2\u027f\u03f1")
        buf.write("\3\2\2\2\u0280\u0281\7\21\2\2\u0281\u0282\7\u00e5\2\2")
        buf.write("\u0282\u0284\5\u00acW\2\u0283\u0285\5&\24\2\u0284\u0283")
        buf.write("\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u0286\3\2\2\2\u0286")
        buf.write("\u0287\7\u00d6\2\2\u0287\u0288\5\34\17\2\u0288\u03f1\3")
        buf.write("\2\2\2\u0289\u028a\7\21\2\2\u028a\u028b\7\u00e5\2\2\u028b")
        buf.write("\u028c\5\u00acW\2\u028c\u028d\7\u00bc\2\2\u028d\u028e")
        buf.write("\7\u00ae\2\2\u028e\u03f1\3\2\2\2\u028f\u0290\7N\2\2\u0290")
        buf.write("\u0293\7\u00e5\2\2\u0291\u0292\7p\2\2\u0292\u0294\7U\2")
        buf.write("\2\u0293\u0291\3\2\2\2\u0293\u0294\3\2\2\2\u0294\u0295")
        buf.write("\3\2\2\2\u0295\u0297\5\u00acW\2\u0296\u0298\7\u00b7\2")
        buf.write("\2\u0297\u0296\3\2\2\2\u0297\u0298\3\2\2\2\u0298\u03f1")
        buf.write("\3\2\2\2\u0299\u029a\7N\2\2\u029a\u029d\7\u0103\2\2\u029b")
        buf.write("\u029c\7p\2\2\u029c\u029e\7U\2\2\u029d\u029b\3\2\2\2\u029d")
        buf.write("\u029e\3\2\2\2\u029e\u029f\3\2\2\2\u029f\u03f1\5\u00ac")
        buf.write("W\2\u02a0\u02a3\7\67\2\2\u02a1\u02a2\7\u00a3\2\2\u02a2")
        buf.write("\u02a4\7\u00c2\2\2\u02a3\u02a1\3\2\2\2\u02a3\u02a4\3\2")
        buf.write("\2\2\u02a4\u02a9\3\2\2\2\u02a5\u02a7\7j\2\2\u02a6\u02a5")
        buf.write("\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8")
        buf.write("\u02aa\7\u00e9\2\2\u02a9\u02a6\3\2\2\2\u02a9\u02aa\3\2")
        buf.write("\2\2\u02aa\u02ab\3\2\2\2\u02ab\u02af\7\u0103\2\2\u02ac")
        buf.write("\u02ad\7p\2\2\u02ad\u02ae\7\u009b\2\2\u02ae\u02b0\7U\2")
        buf.write("\2\u02af\u02ac\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b1")
        buf.write("\3\2\2\2\u02b1\u02b3\5\u00acW\2\u02b2\u02b4\5\u009cO\2")
        buf.write("\u02b3\u02b2\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02bd\3")
        buf.write("\2\2\2\u02b5\u02bc\5\36\20\2\u02b6\u02b7\7\u00ad\2\2\u02b7")
        buf.write("\u02b8\7\u009f\2\2\u02b8\u02bc\5\u0094K\2\u02b9\u02ba")
        buf.write("\7\u00e8\2\2\u02ba\u02bc\58\35\2\u02bb\u02b5\3\2\2\2\u02bb")
        buf.write("\u02b6\3\2\2\2\u02bb\u02b9\3\2\2\2\u02bc\u02bf\3\2\2\2")
        buf.write("\u02bd\u02bb\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02c0\3")
        buf.write("\2\2\2\u02bf\u02bd\3\2\2\2\u02c0\u02c1\7\30\2\2\u02c1")
        buf.write("\u02c2\5 \21\2\u02c2\u03f1\3\2\2\2\u02c3\u02c6\7\67\2")
        buf.write("\2\u02c4\u02c5\7\u00a3\2\2\u02c5\u02c7\7\u00c2\2\2\u02c6")
        buf.write("\u02c4\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c9\3\2\2\2")
        buf.write("\u02c8\u02ca\7j\2\2\u02c9\u02c8\3\2\2\2\u02c9\u02ca\3")
        buf.write("\2\2\2\u02ca\u02cb\3\2\2\2\u02cb\u02cc\7\u00e9\2\2\u02cc")
        buf.write("\u02cd\7\u0103\2\2\u02cd\u02d2\5\u00aeX\2\u02ce\u02cf")
        buf.write("\7\4\2\2\u02cf\u02d0\5\u00e6t\2\u02d0\u02d1\7\5\2\2\u02d1")
        buf.write("\u02d3\3\2\2\2\u02d2\u02ce\3\2\2\2\u02d2\u02d3\3\2\2\2")
        buf.write("\u02d3\u02d4\3\2\2\2\u02d4\u02d7\5\64\33\2\u02d5\u02d6")
        buf.write("\7\u00a2\2\2\u02d6\u02d8\58\35\2\u02d7\u02d5\3\2\2\2\u02d7")
        buf.write("\u02d8\3\2\2\2\u02d8\u03f1\3\2\2\2\u02d9\u02da\7\21\2")
        buf.write("\2\u02da\u02db\7\u0103\2\2\u02db\u02dd\5\u00acW\2\u02dc")
        buf.write("\u02de\7\30\2\2\u02dd\u02dc\3\2\2\2\u02dd\u02de\3\2\2")
        buf.write("\2\u02de\u02df\3\2\2\2\u02df\u02e0\5 \21\2\u02e0\u03f1")
        buf.write("\3\2\2\2\u02e1\u02e4\7\67\2\2\u02e2\u02e3\7\u00a3\2\2")
        buf.write("\u02e3\u02e5\7\u00c2\2\2\u02e4\u02e2\3\2\2\2\u02e4\u02e5")
        buf.write("\3\2\2\2\u02e5\u02e7\3\2\2\2\u02e6\u02e8\7\u00e9\2\2\u02e7")
        buf.write("\u02e6\3\2\2\2\u02e7\u02e8\3\2\2\2\u02e8\u02e9\3\2\2\2")
        buf.write("\u02e9\u02ed\7h\2\2\u02ea\u02eb\7p\2\2\u02eb\u02ec\7\u009b")
        buf.write("\2\2\u02ec\u02ee\7U\2\2\u02ed\u02ea\3\2\2\2\u02ed\u02ee")
        buf.write("\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02f0\5\u00acW\2\u02f0")
        buf.write("\u02f1\7\30\2\2\u02f1\u02fb\7\u011d\2\2\u02f2\u02f3\7")
        buf.write("\u0101\2\2\u02f3\u02f8\5J&\2\u02f4\u02f5\7\6\2\2\u02f5")
        buf.write("\u02f7\5J&\2\u02f6\u02f4\3\2\2\2\u02f7\u02fa\3\2\2\2\u02f8")
        buf.write("\u02f6\3\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fc\3\2\2\2")
        buf.write("\u02fa\u02f8\3\2\2\2\u02fb\u02f2\3\2\2\2\u02fb\u02fc\3")
        buf.write("\2\2\2\u02fc\u03f1\3\2\2\2\u02fd\u02ff\7N\2\2\u02fe\u0300")
        buf.write("\7\u00e9\2\2\u02ff\u02fe\3\2\2\2\u02ff\u0300\3\2\2\2\u0300")
        buf.write("\u0301\3\2\2\2\u0301\u0304\7h\2\2\u0302\u0303\7p\2\2\u0303")
        buf.write("\u0305\7U\2\2\u0304\u0302\3\2\2\2\u0304\u0305\3\2\2\2")
        buf.write("\u0305\u0306\3\2\2\2\u0306\u03f1\5\u00acW\2\u0307\u0309")
        buf.write("\7V\2\2\u0308\u030a\t\t\2\2\u0309\u0308\3\2\2\2\u0309")
        buf.write("\u030a\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u03f1\5\20\t")
        buf.write("\2\u030c\u030d\7\u00d9\2\2\u030d\u0310\7\u00e6\2\2\u030e")
        buf.write("\u030f\t\5\2\2\u030f\u0311\5\u00acW\2\u0310\u030e\3\2")
        buf.write("\2\2\u0310\u0311\3\2\2\2\u0311\u0316\3\2\2\2\u0312\u0314")
        buf.write("\7\u0086\2\2\u0313\u0312\3\2\2\2\u0313\u0314\3\2\2\2\u0314")
        buf.write("\u0315\3\2\2\2\u0315\u0317\7\u011d\2\2\u0316\u0313\3\2")
        buf.write("\2\2\u0316\u0317\3\2\2\2\u0317\u03f1\3\2\2\2\u0318\u0319")
        buf.write("\7\u00d9\2\2\u0319\u031a\7\u00e5\2\2\u031a\u031d\7X\2")
        buf.write("\2\u031b\u031c\t\5\2\2\u031c\u031e\5\u00acW\2\u031d\u031b")
        buf.write("\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u031f\3\2\2\2\u031f")
        buf.write("\u0320\7\u0086\2\2\u0320\u0322\7\u011d\2\2\u0321\u0323")
        buf.write("\5&\24\2\u0322\u0321\3\2\2\2\u0322\u0323\3\2\2\2\u0323")
        buf.write("\u03f1\3\2\2\2\u0324\u0325\7\u00d9\2\2\u0325\u0326\7\u00e8")
        buf.write("\2\2\u0326\u032b\5\u00acW\2\u0327\u0328\7\4\2\2\u0328")
        buf.write("\u0329\5<\37\2\u0329\u032a\7\5\2\2\u032a\u032c\3\2\2\2")
        buf.write("\u032b\u0327\3\2\2\2\u032b\u032c\3\2\2\2\u032c\u03f1\3")
        buf.write("\2\2\2\u032d\u032e\7\u00d9\2\2\u032e\u032f\7.\2\2\u032f")
        buf.write("\u0330\t\5\2\2\u0330\u0333\5\u00acW\2\u0331\u0332\t\5")
        buf.write("\2\2\u0332\u0334\5\u00acW\2\u0333\u0331\3\2\2\2\u0333")
        buf.write("\u0334\3\2\2\2\u0334\u03f1\3\2\2\2\u0335\u0336\7\u00d9")
        buf.write("\2\2\u0336\u0339\7\u0104\2\2\u0337\u0338\t\5\2\2\u0338")
        buf.write("\u033a\5\u00acW\2\u0339\u0337\3\2\2\2\u0339\u033a\3\2")
        buf.write("\2\2\u033a\u033f\3\2\2\2\u033b\u033d\7\u0086\2\2\u033c")
        buf.write("\u033b\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033e\3\2\2\2")
        buf.write("\u033e\u0340\7\u011d\2\2\u033f\u033c\3\2\2\2\u033f\u0340")
        buf.write("\3\2\2\2\u0340\u03f1\3\2\2\2\u0341\u0342\7\u00d9\2\2\u0342")
        buf.write("\u0343\7\u00ae\2\2\u0343\u0345\5\u00acW\2\u0344\u0346")
        buf.write("\5&\24\2\u0345\u0344\3\2\2\2\u0345\u0346\3\2\2\2\u0346")
        buf.write("\u03f1\3\2\2\2\u0347\u0349\7\u00d9\2\2\u0348\u034a\5\u0104")
        buf.write("\u0083\2\u0349\u0348\3\2\2\2\u0349\u034a\3\2\2\2\u034a")
        buf.write("\u034b\3\2\2\2\u034b\u0353\7i\2\2\u034c\u034e\7\u0086")
        buf.write("\2\2\u034d\u034c\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u0351")
        buf.write("\3\2\2\2\u034f\u0352\5\u00acW\2\u0350\u0352\7\u011d\2")
        buf.write("\2\u0351\u034f\3\2\2\2\u0351\u0350\3\2\2\2\u0352\u0354")
        buf.write("\3\2\2\2\u0353\u034d\3\2\2\2\u0353\u0354\3\2\2\2\u0354")
        buf.write("\u03f1\3\2\2\2\u0355\u0356\7\u00d9\2\2\u0356\u0357\7\67")
        buf.write("\2\2\u0357\u0358\7\u00e5\2\2\u0358\u035b\5\u00acW\2\u0359")
        buf.write("\u035a\7\30\2\2\u035a\u035c\7\u00d3\2\2\u035b\u0359\3")
        buf.write("\2\2\2\u035b\u035c\3\2\2\2\u035c\u03f1\3\2\2\2\u035d\u035e")
        buf.write("\7\u00d9\2\2\u035e\u035f\7:\2\2\u035f\u03f1\7\u0097\2")
        buf.write("\2\u0360\u0361\t\n\2\2\u0361\u0363\7h\2\2\u0362\u0364")
        buf.write("\7X\2\2\u0363\u0362\3\2\2\2\u0363\u0364\3\2\2\2\u0364")
        buf.write("\u0365\3\2\2\2\u0365\u03f1\5,\27\2\u0366\u0367\t\n\2\2")
        buf.write("\u0367\u0369\5*\26\2\u0368\u036a\7X\2\2\u0369\u0368\3")
        buf.write("\2\2\2\u0369\u036a\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u036c")
        buf.write("\5\u00acW\2\u036c\u03f1\3\2\2\2\u036d\u036f\t\n\2\2\u036e")
        buf.write("\u0370\7\u00e5\2\2\u036f\u036e\3\2\2\2\u036f\u0370\3\2")
        buf.write("\2\2\u0370\u0372\3\2\2\2\u0371\u0373\t\13\2\2\u0372\u0371")
        buf.write("\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0374\3\2\2\2\u0374")
        buf.write("\u0376\5\u00acW\2\u0375\u0377\5&\24\2\u0376\u0375\3\2")
        buf.write("\2\2\u0376\u0377\3\2\2\2\u0377\u0379\3\2\2\2\u0378\u037a")
        buf.write("\5.\30\2\u0379\u0378\3\2\2\2\u0379\u037a\3\2\2\2\u037a")
        buf.write("\u03f1\3\2\2\2\u037b\u037d\t\n\2\2\u037c\u037e\7\u00b8")
        buf.write("\2\2\u037d\u037c\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u037f")
        buf.write("\3\2\2\2\u037f\u03f1\5 \21\2\u0380\u0381\7/\2\2\u0381")
        buf.write("\u0382\7\u009f\2\2\u0382\u0383\5*\26\2\u0383\u0384\5\u00ac")
        buf.write("W\2\u0384\u0385\7}\2\2\u0385\u0386\t\f\2\2\u0386\u03f1")
        buf.write("\3\2\2\2\u0387\u0388\7/\2\2\u0388\u0389\7\u009f\2\2\u0389")
        buf.write("\u038a\7\u00e5\2\2\u038a\u038b\5\u00acW\2\u038b\u038c")
        buf.write("\7}\2\2\u038c\u038d\t\f\2\2\u038d\u03f1\3\2\2\2\u038e")
        buf.write("\u038f\7\u00bf\2\2\u038f\u0390\7\u00e5\2\2\u0390\u03f1")
        buf.write("\5\u00acW\2\u0391\u0399\7\u00bf\2\2\u0392\u039a\7\u011d")
        buf.write("\2\2\u0393\u0395\13\2\2\2\u0394\u0393\3\2\2\2\u0395\u0398")
        buf.write("\3\2\2\2\u0396\u0397\3\2\2\2\u0396\u0394\3\2\2\2\u0397")
        buf.write("\u039a\3\2\2\2\u0398\u0396\3\2\2\2\u0399\u0392\3\2\2\2")
        buf.write("\u0399\u0396\3\2\2\2\u039a\u03f1\3\2\2\2\u039b\u039d\7")
        buf.write("!\2\2\u039c\u039e\7\u0083\2\2\u039d\u039c\3\2\2\2\u039d")
        buf.write("\u039e\3\2\2\2\u039e\u039f\3\2\2\2\u039f\u03a0\7\u00e5")
        buf.write("\2\2\u03a0\u03a3\5\u00acW\2\u03a1\u03a2\7\u00a2\2\2\u03a2")
        buf.write("\u03a4\58\35\2\u03a3\u03a1\3\2\2\2\u03a3\u03a4\3\2\2\2")
        buf.write("\u03a4\u03a9\3\2\2\2\u03a5\u03a7\7\30\2\2\u03a6\u03a5")
        buf.write("\3\2\2\2\u03a6\u03a7\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8")
        buf.write("\u03aa\5 \21\2\u03a9\u03a6\3\2\2\2\u03a9\u03aa\3\2\2\2")
        buf.write("\u03aa\u03f1\3\2\2\2\u03ab\u03ac\7\u00f8\2\2\u03ac\u03af")
        buf.write("\7\u00e5\2\2\u03ad\u03ae\7p\2\2\u03ae\u03b0\7U\2\2\u03af")
        buf.write("\u03ad\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0\u03b1\3\2\2\2")
        buf.write("\u03b1\u03f1\5\u00acW\2\u03b2\u03b3\7\'\2\2\u03b3\u03f1")
        buf.write("\7!\2\2\u03b4\u03b5\7\u008a\2\2\u03b5\u03b7\7?\2\2\u03b6")
        buf.write("\u03b8\7\u008b\2\2\u03b7\u03b6\3\2\2\2\u03b7\u03b8\3\2")
        buf.write("\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03ba\7w\2\2\u03ba\u03bc")
        buf.write("\7\u011d\2\2\u03bb\u03bd\7\u00ab\2\2\u03bc\u03bb\3\2\2")
        buf.write("\2\u03bc\u03bd\3\2\2\2\u03bd\u03be\3\2\2\2\u03be\u03bf")
        buf.write("\7|\2\2\u03bf\u03c0\7\u00e5\2\2\u03c0\u03c2\5\u00acW\2")
        buf.write("\u03c1\u03c3\5&\24\2\u03c2\u03c1\3\2\2\2\u03c2\u03c3\3")
        buf.write("\2\2\2\u03c3\u03f1\3\2\2\2\u03c4\u03c5\7\u00f4\2\2\u03c5")
        buf.write("\u03c6\7\u00e5\2\2\u03c6\u03c8\5\u00acW\2\u03c7\u03c9")
        buf.write("\5&\24\2\u03c8\u03c7\3\2\2\2\u03c8\u03c9\3\2\2\2\u03c9")
        buf.write("\u03f1\3\2\2\2\u03ca\u03cb\7\u0096\2\2\u03cb\u03cc\7\u00c1")
        buf.write("\2\2\u03cc\u03cd\7\u00e5\2\2\u03cd\u03f1\5\u00acW\2\u03ce")
        buf.write("\u03cf\t\r\2\2\u03cf\u03d7\5\u0104\u0083\2\u03d0\u03d8")
        buf.write("\7\u011d\2\2\u03d1\u03d3\13\2\2\2\u03d2\u03d1\3\2\2\2")
        buf.write("\u03d3\u03d6\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d4\u03d2\3")
        buf.write("\2\2\2\u03d5\u03d8\3\2\2\2\u03d6\u03d4\3\2\2\2\u03d7\u03d0")
        buf.write("\3\2\2\2\u03d7\u03d4\3\2\2\2\u03d8\u03f1\3\2\2\2\u03d9")
        buf.write("\u03da\7\u00d6\2\2\u03da\u03de\7\u00c8\2\2\u03db\u03dd")
        buf.write("\13\2\2\2\u03dc\u03db\3\2\2\2\u03dd\u03e0\3\2\2\2\u03de")
        buf.write("\u03df\3\2\2\2\u03de\u03dc\3\2\2\2\u03df\u03f1\3\2\2\2")
        buf.write("\u03e0\u03de\3\2\2\2\u03e1\u03e5\7\u00d6\2\2\u03e2\u03e4")
        buf.write("\13\2\2\2\u03e3\u03e2\3\2\2\2\u03e4\u03e7\3\2\2\2\u03e5")
        buf.write("\u03e6\3\2\2\2\u03e5\u03e3\3\2\2\2\u03e6\u03f1\3\2\2\2")
        buf.write("\u03e7\u03e5\3\2\2\2\u03e8\u03f1\7\u00c3\2\2\u03e9\u03ed")
        buf.write("\5\22\n\2\u03ea\u03ec\13\2\2\2\u03eb\u03ea\3\2\2\2\u03ec")
        buf.write("\u03ef\3\2\2\2\u03ed\u03ee\3\2\2\2\u03ed\u03eb\3\2\2\2")
        buf.write("\u03ee\u03f1\3\2\2\2\u03ef\u03ed\3\2\2\2\u03f0\u012f\3")
        buf.write("\2\2\2\u03f0\u0131\3\2\2\2\u03f0\u0134\3\2\2\2\u03f0\u0139")
        buf.write("\3\2\2\2\u03f0\u014b\3\2\2\2\u03f0\u0152\3\2\2\2\u03f0")
        buf.write("\u0158\3\2\2\2\u03f0\u0162\3\2\2\2\u03f0\u016e\3\2\2\2")
        buf.write("\u03f0\u017d\3\2\2\2\u03f0\u01a2\3\2\2\2\u03f0\u01b7\3")
        buf.write("\2\2\2\u03f0\u01c6\3\2\2\2\u03f0\u01d7\3\2\2\2\u03f0\u01de")
        buf.write("\3\2\2\2\u03f0\u01e7\3\2\2\2\u03f0\u01f0\3\2\2\2\u03f0")
        buf.write("\u01f9\3\2\2\2\u03f0\u0200\3\2\2\2\u03f0\u0207\3\2\2\2")
        buf.write("\u03f0\u020e\3\2\2\2\u03f0\u0219\3\2\2\2\u03f0\u0224\3")
        buf.write("\2\2\2\u03f0\u0233\3\2\2\2\u03f0\u023f\3\2\2\2\u03f0\u024d")
        buf.write("\3\2\2\2\u03f0\u0257\3\2\2\2\u03f0\u0265\3\2\2\2\u03f0")
        buf.write("\u026d\3\2\2\2\u03f0\u0280\3\2\2\2\u03f0\u0289\3\2\2\2")
        buf.write("\u03f0\u028f\3\2\2\2\u03f0\u0299\3\2\2\2\u03f0\u02a0\3")
        buf.write("\2\2\2\u03f0\u02c3\3\2\2\2\u03f0\u02d9\3\2\2\2\u03f0\u02e1")
        buf.write("\3\2\2\2\u03f0\u02fd\3\2\2\2\u03f0\u0307\3\2\2\2\u03f0")
        buf.write("\u030c\3\2\2\2\u03f0\u0318\3\2\2\2\u03f0\u0324\3\2\2\2")
        buf.write("\u03f0\u032d\3\2\2\2\u03f0\u0335\3\2\2\2\u03f0\u0341\3")
        buf.write("\2\2\2\u03f0\u0347\3\2\2\2\u03f0\u0355\3\2\2\2\u03f0\u035d")
        buf.write("\3\2\2\2\u03f0\u0360\3\2\2\2\u03f0\u0366\3\2\2\2\u03f0")
        buf.write("\u036d\3\2\2\2\u03f0\u037b\3\2\2\2\u03f0\u0380\3\2\2\2")
        buf.write("\u03f0\u0387\3\2\2\2\u03f0\u038e\3\2\2\2\u03f0\u0391\3")
        buf.write("\2\2\2\u03f0\u039b\3\2\2\2\u03f0\u03ab\3\2\2\2\u03f0\u03b2")
        buf.write("\3\2\2\2\u03f0\u03b4\3\2\2\2\u03f0\u03c4\3\2\2\2\u03f0")
        buf.write("\u03ca\3\2\2\2\u03f0\u03ce\3\2\2\2\u03f0\u03d9\3\2\2\2")
        buf.write("\u03f0\u03e1\3\2\2\2\u03f0\u03e8\3\2\2\2\u03f0\u03e9\3")
        buf.write("\2\2\2\u03f1\21\3\2\2\2\u03f2\u03f3\7\67\2\2\u03f3\u049b")
        buf.write("\7\u00c8\2\2\u03f4\u03f5\7N\2\2\u03f5\u049b\7\u00c8\2")
        buf.write("\2\u03f6\u03f8\7k\2\2\u03f7\u03f9\7\u00c8\2\2\u03f8\u03f7")
        buf.write("\3\2\2\2\u03f8\u03f9\3\2\2\2\u03f9\u049b\3\2\2\2\u03fa")
        buf.write("\u03fc\7\u00c5\2\2\u03fb\u03fd\7\u00c8\2\2\u03fc\u03fb")
        buf.write("\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u049b\3\2\2\2\u03fe")
        buf.write("\u03ff\7\u00d9\2\2\u03ff\u049b\7k\2\2\u0400\u0401\7\u00d9")
        buf.write("\2\2\u0401\u0403\7\u00c8\2\2\u0402\u0404\7k\2\2\u0403")
        buf.write("\u0402\3\2\2\2\u0403\u0404\3\2\2\2\u0404\u049b\3\2\2\2")
        buf.write("\u0405\u0406\7\u00d9\2\2\u0406\u049b\7\u00b5\2\2\u0407")
        buf.write("\u0408\7\u00d9\2\2\u0408\u049b\7\u00c9\2\2\u0409\u040a")
        buf.write("\7\u00d9\2\2\u040a\u040b\7:\2\2\u040b\u049b\7\u00c9\2")
        buf.write("\2\u040c\u040d\7W\2\2\u040d\u049b\7\u00e5\2\2\u040e\u040f")
        buf.write("\7r\2\2\u040f\u049b\7\u00e5\2\2\u0410\u0411\7\u00d9\2")
        buf.write("\2\u0411\u049b\7\62\2\2\u0412\u0413\7\u00d9\2\2\u0413")
        buf.write("\u0414\7\67\2\2\u0414\u049b\7\u00e5\2\2\u0415\u0416\7")
        buf.write("\u00d9\2\2\u0416\u049b\7\u00f0\2\2\u0417\u0418\7\u00d9")
        buf.write("\2\2\u0418\u049b\7u\2\2\u0419\u041a\7\u00d9\2\2\u041a")
        buf.write("\u049b\7\u008e\2\2\u041b\u041c\7\67\2\2\u041c\u049b\7")
        buf.write("t\2\2\u041d\u041e\7N\2\2\u041e\u049b\7t\2\2\u041f\u0420")
        buf.write("\7\21\2\2\u0420\u049b\7t\2\2\u0421\u0422\7\u008d\2\2\u0422")
        buf.write("\u049b\7\u00e5\2\2\u0423\u0424\7\u008d\2\2\u0424\u049b")
        buf.write("\7@\2\2\u0425\u0426\7\u00fc\2\2\u0426\u049b\7\u00e5\2")
        buf.write("\2\u0427\u0428\7\u00fc\2\2\u0428\u049b\7@\2\2\u0429\u042a")
        buf.write("\7\67\2\2\u042a\u042b\7\u00e9\2\2\u042b\u049b\7\u0090")
        buf.write("\2\2\u042c\u042d\7N\2\2\u042d\u042e\7\u00e9\2\2\u042e")
        buf.write("\u049b\7\u0090\2\2\u042f\u0430\7\21\2\2\u0430\u0431\7")
        buf.write("\u00e5\2\2\u0431\u0432\5\u00aeX\2\u0432\u0433\7\u009b")
        buf.write("\2\2\u0433\u0434\7)\2\2\u0434\u049b\3\2\2\2\u0435\u0436")
        buf.write("\7\21\2\2\u0436\u0437\7\u00e5\2\2\u0437\u0438\5\u00ae")
        buf.write("X\2\u0438\u0439\7)\2\2\u0439\u043a\7 \2\2\u043a\u049b")
        buf.write("\3\2\2\2\u043b\u043c\7\21\2\2\u043c\u043d\7\u00e5\2\2")
        buf.write("\u043d\u043e\5\u00aeX\2\u043e\u043f\7\u009b\2\2\u043f")
        buf.write("\u0440\7\u00dd\2\2\u0440\u049b\3\2\2\2\u0441\u0442\7\21")
        buf.write("\2\2\u0442\u0443\7\u00e5\2\2\u0443\u0444\5\u00aeX\2\u0444")
        buf.write("\u0445\7\u00da\2\2\u0445\u0446\7 \2\2\u0446\u049b\3\2")
        buf.write("\2\2\u0447\u0448\7\21\2\2\u0448\u0449\7\u00e5\2\2\u0449")
        buf.write("\u044a\5\u00aeX\2\u044a\u044b\7\u009b\2\2\u044b\u044c")
        buf.write("\7\u00da\2\2\u044c\u049b\3\2\2\2\u044d\u044e\7\21\2\2")
        buf.write("\u044e\u044f\7\u00e5\2\2\u044f\u0450\5\u00aeX\2\u0450")
        buf.write("\u0451\7\u009b\2\2\u0451\u0452\7\u00e0\2\2\u0452\u0453")
        buf.write("\7\30\2\2\u0453\u0454\7J\2\2\u0454\u049b\3\2\2\2\u0455")
        buf.write("\u0456\7\21\2\2\u0456\u0457\7\u00e5\2\2\u0457\u0458\5")
        buf.write("\u00aeX\2\u0458\u0459\7\u00d6\2\2\u0459\u045a\7\u00da")
        buf.write("\2\2\u045a\u045b\7\u008c\2\2\u045b\u049b\3\2\2\2\u045c")
        buf.write("\u045d\7\21\2\2\u045d\u045e\7\u00e5\2\2\u045e\u045f\5")
        buf.write("\u00aeX\2\u045f\u0460\7T\2\2\u0460\u0461\7\u00ac\2\2\u0461")
        buf.write("\u049b\3\2\2\2\u0462\u0463\7\21\2\2\u0463\u0464\7\u00e5")
        buf.write("\2\2\u0464\u0465\5\u00aeX\2\u0465\u0466\7\26\2\2\u0466")
        buf.write("\u0467\7\u00ac\2\2\u0467\u049b\3\2\2\2\u0468\u0469\7\21")
        buf.write("\2\2\u0469\u046a\7\u00e5\2\2\u046a\u046b\5\u00aeX\2\u046b")
        buf.write("\u046c\7\u00f6\2\2\u046c\u046d\7\u00ac\2\2\u046d\u049b")
        buf.write("\3\2\2\2\u046e\u046f\7\21\2\2\u046f\u0470\7\u00e5\2\2")
        buf.write("\u0470\u0471\5\u00aeX\2\u0471\u0472\7\u00ed\2\2\u0472")
        buf.write("\u049b\3\2\2\2\u0473\u0474\7\21\2\2\u0474\u0475\7\u00e5")
        buf.write("\2\2\u0475\u0477\5\u00aeX\2\u0476\u0478\5&\24\2\u0477")
        buf.write("\u0476\3\2\2\2\u0477\u0478\3\2\2\2\u0478\u0479\3\2\2\2")
        buf.write("\u0479\u047a\7\61\2\2\u047a\u049b\3\2\2\2\u047b\u047c")
        buf.write("\7\21\2\2\u047c\u047d\7\u00e5\2\2\u047d\u047f\5\u00ae")
        buf.write("X\2\u047e\u0480\5&\24\2\u047f\u047e\3\2\2\2\u047f\u0480")
        buf.write("\3\2\2\2\u0480\u0481\3\2\2\2\u0481\u0482\7\64\2\2\u0482")
        buf.write("\u049b\3\2\2\2\u0483\u0484\7\21\2\2\u0484\u0485\7\u00e5")
        buf.write("\2\2\u0485\u0487\5\u00aeX\2\u0486\u0488\5&\24\2\u0487")
        buf.write("\u0486\3\2\2\2\u0487\u0488\3\2\2\2\u0488\u0489\3\2\2\2")
        buf.write("\u0489\u048a\7\u00d6\2\2\u048a\u048b\7_\2\2\u048b\u049b")
        buf.write("\3\2\2\2\u048c\u048d\7\21\2\2\u048d\u048e\7\u00e5\2\2")
        buf.write("\u048e\u0490\5\u00aeX\2\u048f\u0491\5&\24\2\u0490\u048f")
        buf.write("\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0492\3\2\2\2\u0492")
        buf.write("\u0493\7\u00c2\2\2\u0493\u0494\7.\2\2\u0494\u049b\3\2")
        buf.write("\2\2\u0495\u0496\7\u00de\2\2\u0496\u049b\7\u00ef\2\2\u0497")
        buf.write("\u049b\7\60\2\2\u0498\u049b\7\u00ca\2\2\u0499\u049b\7")
        buf.write("I\2\2\u049a\u03f2\3\2\2\2\u049a\u03f4\3\2\2\2\u049a\u03f6")
        buf.write("\3\2\2\2\u049a\u03fa\3\2\2\2\u049a\u03fe\3\2\2\2\u049a")
        buf.write("\u0400\3\2\2\2\u049a\u0405\3\2\2\2\u049a\u0407\3\2\2\2")
        buf.write("\u049a\u0409\3\2\2\2\u049a\u040c\3\2\2\2\u049a\u040e\3")
        buf.write("\2\2\2\u049a\u0410\3\2\2\2\u049a\u0412\3\2\2\2\u049a\u0415")
        buf.write("\3\2\2\2\u049a\u0417\3\2\2\2\u049a\u0419\3\2\2\2\u049a")
        buf.write("\u041b\3\2\2\2\u049a\u041d\3\2\2\2\u049a\u041f\3\2\2\2")
        buf.write("\u049a\u0421\3\2\2\2\u049a\u0423\3\2\2\2\u049a\u0425\3")
        buf.write("\2\2\2\u049a\u0427\3\2\2\2\u049a\u0429\3\2\2\2\u049a\u042c")
        buf.write("\3\2\2\2\u049a\u042f\3\2\2\2\u049a\u0435\3\2\2\2\u049a")
        buf.write("\u043b\3\2\2\2\u049a\u0441\3\2\2\2\u049a\u0447\3\2\2\2")
        buf.write("\u049a\u044d\3\2\2\2\u049a\u0455\3\2\2\2\u049a\u045c\3")
        buf.write("\2\2\2\u049a\u0462\3\2\2\2\u049a\u0468\3\2\2\2\u049a\u046e")
        buf.write("\3\2\2\2\u049a\u0473\3\2\2\2\u049a\u047b\3\2\2\2\u049a")
        buf.write("\u0483\3\2\2\2\u049a\u048c\3\2\2\2\u049a\u0495\3\2\2\2")
        buf.write("\u049a\u0497\3\2\2\2\u049a\u0498\3\2\2\2\u049a\u0499\3")
        buf.write("\2\2\2\u049b\23\3\2\2\2\u049c\u049e\7\67\2\2\u049d\u049f")
        buf.write("\7\u00e9\2\2\u049e\u049d\3\2\2\2\u049e\u049f\3\2\2\2\u049f")
        buf.write("\u04a1\3\2\2\2\u04a0\u04a2\7Y\2\2\u04a1\u04a0\3\2\2\2")
        buf.write("\u04a1\u04a2\3\2\2\2\u04a2\u04a3\3\2\2\2\u04a3\u04a7\7")
        buf.write("\u00e5\2\2\u04a4\u04a5\7p\2\2\u04a5\u04a6\7\u009b\2\2")
        buf.write("\u04a6\u04a8\7U\2\2\u04a7\u04a4\3\2\2\2\u04a7\u04a8\3")
        buf.write("\2\2\2\u04a8\u04a9\3\2\2\2\u04a9\u04aa\5\u00acW\2\u04aa")
        buf.write("\25\3\2\2\2\u04ab\u04ac\7\67\2\2\u04ac\u04ae\7\u00a3\2")
        buf.write("\2\u04ad\u04ab\3\2\2\2\u04ad\u04ae\3\2\2\2\u04ae\u04af")
        buf.write("\3\2\2\2\u04af\u04b0\7\u00c2\2\2\u04b0\u04b1\7\u00e5\2")
        buf.write("\2\u04b1\u04b2\5\u00acW\2\u04b2\27\3\2\2\2\u04b3\u04b4")
        buf.write("\7)\2\2\u04b4\u04b5\7 \2\2\u04b5\u04b9\5\u0094K\2\u04b6")
        buf.write("\u04b7\7\u00dd\2\2\u04b7\u04b8\7 \2\2\u04b8\u04ba\5\u0098")
        buf.write("M\2\u04b9\u04b6\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bb")
        buf.write("\3\2\2\2\u04bb\u04bc\7|\2\2\u04bc\u04bd\7\u0121\2\2\u04bd")
        buf.write("\u04be\7\37\2\2\u04be\31\3\2\2\2\u04bf\u04c0\7\u00da\2")
        buf.write("\2\u04c0\u04c1\7 \2\2\u04c1\u04c2\5\u0094K\2\u04c2\u04c5")
        buf.write("\7\u009f\2\2\u04c3\u04c6\5@!\2\u04c4\u04c6\5B\"\2\u04c5")
        buf.write("\u04c3\3\2\2\2\u04c5\u04c4\3\2\2\2\u04c6\u04ca\3\2\2\2")
        buf.write("\u04c7\u04c8\7\u00e0\2\2\u04c8\u04c9\7\30\2\2\u04c9\u04cb")
        buf.write("\7J\2\2\u04ca\u04c7\3\2\2\2\u04ca\u04cb\3\2\2\2\u04cb")
        buf.write("\33\3\2\2\2\u04cc\u04cd\7\u008c\2\2\u04cd\u04ce\7\u011d")
        buf.write("\2\2\u04ce\35\3\2\2\2\u04cf\u04d0\7/\2\2\u04d0\u04d1\7")
        buf.write("\u011d\2\2\u04d1\37\3\2\2\2\u04d2\u04d4\5\60\31\2\u04d3")
        buf.write("\u04d2\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04d5\3\2\2\2")
        buf.write("\u04d5\u04d6\5R*\2\u04d6\u04d7\5N(\2\u04d7!\3\2\2\2\u04d8")
        buf.write("\u04d9\7y\2\2\u04d9\u04db\7\u00ab\2\2\u04da\u04dc\7\u00e5")
        buf.write("\2\2\u04db\u04da\3\2\2\2\u04db\u04dc\3\2\2\2\u04dc\u04dd")
        buf.write("\3\2\2\2\u04dd\u04e4\5\u00acW\2\u04de\u04e2\5&\24\2\u04df")
        buf.write("\u04e0\7p\2\2\u04e0\u04e1\7\u009b\2\2\u04e1\u04e3\7U\2")
        buf.write("\2\u04e2\u04df\3\2\2\2\u04e2\u04e3\3\2\2\2\u04e3\u04e5")
        buf.write("\3\2\2\2\u04e4\u04de\3\2\2\2\u04e4\u04e5\3\2\2\2\u04e5")
        buf.write("\u0510\3\2\2\2\u04e6\u04e7\7y\2\2\u04e7\u04e9\7|\2\2\u04e8")
        buf.write("\u04ea\7\u00e5\2\2\u04e9\u04e8\3\2\2\2\u04e9\u04ea\3\2")
        buf.write("\2\2\u04ea\u04eb\3\2\2\2\u04eb\u04ed\5\u00acW\2\u04ec")
        buf.write("\u04ee\5&\24\2\u04ed\u04ec\3\2\2\2\u04ed\u04ee\3\2\2\2")
        buf.write("\u04ee\u04f2\3\2\2\2\u04ef\u04f0\7p\2\2\u04f0\u04f1\7")
        buf.write("\u009b\2\2\u04f1\u04f3\7U\2\2\u04f2\u04ef\3\2\2\2\u04f2")
        buf.write("\u04f3\3\2\2\2\u04f3\u0510\3\2\2\2\u04f4\u04f5\7y\2\2")
        buf.write("\u04f5\u04f7\7\u00ab\2\2\u04f6\u04f8\7\u008b\2\2\u04f7")
        buf.write("\u04f6\3\2\2\2\u04f7\u04f8\3\2\2\2\u04f8\u04f9\3\2\2\2")
        buf.write("\u04f9\u04fa\7K\2\2\u04fa\u04fc\7\u011d\2\2\u04fb\u04fd")
        buf.write("\5\u00a8U\2\u04fc\u04fb\3\2\2\2\u04fc\u04fd\3\2\2\2\u04fd")
        buf.write("\u04ff\3\2\2\2\u04fe\u0500\5D#\2\u04ff\u04fe\3\2\2\2\u04ff")
        buf.write("\u0500\3\2\2\2\u0500\u0510\3\2\2\2\u0501\u0502\7y\2\2")
        buf.write("\u0502\u0504\7\u00ab\2\2\u0503\u0505\7\u008b\2\2\u0504")
        buf.write("\u0503\3\2\2\2\u0504\u0505\3\2\2\2\u0505\u0506\3\2\2\2")
        buf.write("\u0506\u0508\7K\2\2\u0507\u0509\7\u011d\2\2\u0508\u0507")
        buf.write("\3\2\2\2\u0508\u0509\3\2\2\2\u0509\u050a\3\2\2\2\u050a")
        buf.write("\u050d\5\64\33\2\u050b\u050c\7\u00a2\2\2\u050c\u050e\5")
        buf.write("8\35\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510")
        buf.write("\3\2\2\2\u050f\u04d8\3\2\2\2\u050f\u04e6\3\2\2\2\u050f")
        buf.write("\u04f4\3\2\2\2\u050f\u0501\3\2\2\2\u0510#\3\2\2\2\u0511")
        buf.write("\u0513\5&\24\2\u0512\u0514\5\34\17\2\u0513\u0512\3\2\2")
        buf.write("\2\u0513\u0514\3\2\2\2\u0514%\3\2\2\2\u0515\u0516\7\u00ac")
        buf.write("\2\2\u0516\u0517\7\4\2\2\u0517\u051c\5(\25\2\u0518\u0519")
        buf.write("\7\6\2\2\u0519\u051b\5(\25\2\u051a\u0518\3\2\2\2\u051b")
        buf.write("\u051e\3\2\2\2\u051c\u051a\3\2\2\2\u051c\u051d\3\2\2\2")
        buf.write("\u051d\u051f\3\2\2\2\u051e\u051c\3\2\2\2\u051f\u0520\7")
        buf.write("\5\2\2\u0520\'\3\2\2\2\u0521\u0524\5\u0104\u0083\2\u0522")
        buf.write("\u0523\7\u010a\2\2\u0523\u0525\5\u00c6d\2\u0524\u0522")
        buf.write("\3\2\2\2\u0524\u0525\3\2\2\2\u0525)\3\2\2\2\u0526\u0527")
        buf.write("\t\16\2\2\u0527+\3\2\2\2\u0528\u052e\5\u00fe\u0080\2\u0529")
        buf.write("\u052e\7\u011d\2\2\u052a\u052e\5\u00c8e\2\u052b\u052e")
        buf.write("\5\u00caf\2\u052c\u052e\5\u00ccg\2\u052d\u0528\3\2\2\2")
        buf.write("\u052d\u0529\3\2\2\2\u052d\u052a\3\2\2\2\u052d\u052b\3")
        buf.write("\2\2\2\u052d\u052c\3\2\2\2\u052e-\3\2\2\2\u052f\u0534")
        buf.write("\5\u0104\u0083\2\u0530\u0531\7\7\2\2\u0531\u0533\5\u0104")
        buf.write("\u0083\2\u0532\u0530\3\2\2\2\u0533\u0536\3\2\2\2\u0534")
        buf.write("\u0532\3\2\2\2\u0534\u0535\3\2\2\2\u0535/\3\2\2\2\u0536")
        buf.write("\u0534\3\2\2\2\u0537\u0538\7\u0108\2\2\u0538\u053d\5\62")
        buf.write("\32\2\u0539\u053a\7\6\2\2\u053a\u053c\5\62\32\2\u053b")
        buf.write("\u0539\3\2\2\2\u053c\u053f\3\2\2\2\u053d\u053b\3\2\2\2")
        buf.write("\u053d\u053e\3\2\2\2\u053e\61\3\2\2\2\u053f\u053d\3\2")
        buf.write("\2\2\u0540\u0542\5\u0100\u0081\2\u0541\u0543\5\u0094K")
        buf.write("\2\u0542\u0541\3\2\2\2\u0542\u0543\3\2\2\2\u0543\u0545")
        buf.write("\3\2\2\2\u0544\u0546\7\30\2\2\u0545\u0544\3\2\2\2\u0545")
        buf.write("\u0546\3\2\2\2\u0546\u0547\3\2\2\2\u0547\u0548\7\4\2\2")
        buf.write("\u0548\u0549\5 \21\2\u0549\u054a\7\5\2\2\u054a\63\3\2")
        buf.write("\2\2\u054b\u054c\7\u0101\2\2\u054c\u054d\5\u00acW\2\u054d")
        buf.write("\65\3\2\2\2\u054e\u054f\7\u00a2\2\2\u054f\u0559\58\35")
        buf.write("\2\u0550\u0551\7\u00ad\2\2\u0551\u0552\7 \2\2\u0552\u0559")
        buf.write("\5\u00b6\\\2\u0553\u0559\5\30\r\2\u0554\u0559\5\34\17")
        buf.write("\2\u0555\u0559\5\36\20\2\u0556\u0557\7\u00e8\2\2\u0557")
        buf.write("\u0559\58\35\2\u0558\u054e\3\2\2\2\u0558\u0550\3\2\2\2")
        buf.write("\u0558\u0553\3\2\2\2\u0558\u0554\3\2\2\2\u0558\u0555\3")
        buf.write("\2\2\2\u0558\u0556\3\2\2\2\u0559\u055c\3\2\2\2\u055a\u0558")
        buf.write("\3\2\2\2\u055a\u055b\3\2\2\2\u055b\67\3\2\2\2\u055c\u055a")
        buf.write("\3\2\2\2\u055d\u055e\7\4\2\2\u055e\u0563\5:\36\2\u055f")
        buf.write("\u0560\7\6\2\2\u0560\u0562\5:\36\2\u0561\u055f\3\2\2\2")
        buf.write("\u0562\u0565\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3")
        buf.write("\2\2\2\u0564\u0566\3\2\2\2\u0565\u0563\3\2\2\2\u0566\u0567")
        buf.write("\7\5\2\2\u05679\3\2\2\2\u0568\u056d\5<\37\2\u0569\u056b")
        buf.write("\7\u010a\2\2\u056a\u0569\3\2\2\2\u056a\u056b\3\2\2\2\u056b")
        buf.write("\u056c\3\2\2\2\u056c\u056e\5> \2\u056d\u056a\3\2\2\2\u056d")
        buf.write("\u056e\3\2\2\2\u056e;\3\2\2\2\u056f\u0574\5\u0104\u0083")
        buf.write("\2\u0570\u0571\7\7\2\2\u0571\u0573\5\u0104\u0083\2\u0572")
        buf.write("\u0570\3\2\2\2\u0573\u0576\3\2\2\2\u0574\u0572\3\2\2\2")
        buf.write("\u0574\u0575\3\2\2\2\u0575\u0579\3\2\2\2\u0576\u0574\3")
        buf.write("\2\2\2\u0577\u0579\7\u011d\2\2\u0578\u056f\3\2\2\2\u0578")
        buf.write("\u0577\3\2\2\2\u0579=\3\2\2\2\u057a\u057f\7\u0121\2\2")
        buf.write("\u057b\u057f\7\u0123\2\2\u057c\u057f\5\u00ceh\2\u057d")
        buf.write("\u057f\7\u011d\2\2\u057e\u057a\3\2\2\2\u057e\u057b\3\2")
        buf.write("\2\2\u057e\u057c\3\2\2\2\u057e\u057d\3\2\2\2\u057f?\3")
        buf.write("\2\2\2\u0580\u0581\7\4\2\2\u0581\u0586\5\u00c6d\2\u0582")
        buf.write("\u0583\7\6\2\2\u0583\u0585\5\u00c6d\2\u0584\u0582\3\2")
        buf.write("\2\2\u0585\u0588\3\2\2\2\u0586\u0584\3\2\2\2\u0586\u0587")
        buf.write("\3\2\2\2\u0587\u0589\3\2\2\2\u0588\u0586\3\2\2\2\u0589")
        buf.write("\u058a\7\5\2\2\u058aA\3\2\2\2\u058b\u058c\7\4\2\2\u058c")
        buf.write("\u0591\5@!\2\u058d\u058e\7\6\2\2\u058e\u0590\5@!\2\u058f")
        buf.write("\u058d\3\2\2\2\u0590\u0593\3\2\2\2\u0591\u058f\3\2\2\2")
        buf.write("\u0591\u0592\3\2\2\2\u0592\u0594\3\2\2\2\u0593\u0591\3")
        buf.write("\2\2\2\u0594\u0595\7\5\2\2\u0595C\3\2\2\2\u0596\u0597")
        buf.write("\7\u00e0\2\2\u0597\u0598\7\30\2\2\u0598\u059d\5F$\2\u0599")
        buf.write("\u059a\7\u00e0\2\2\u059a\u059b\7 \2\2\u059b\u059d\5H%")
        buf.write("\2\u059c\u0596\3\2\2\2\u059c\u0599\3\2\2\2\u059dE\3\2")
        buf.write("\2\2\u059e\u059f\7x\2\2\u059f\u05a0\7\u011d\2\2\u05a0")
        buf.write("\u05a1\7\u00a7\2\2\u05a1\u05a4\7\u011d\2\2\u05a2\u05a4")
        buf.write("\5\u0104\u0083\2\u05a3\u059e\3\2\2\2\u05a3\u05a2\3\2\2")
        buf.write("\2\u05a4G\3\2\2\2\u05a5\u05a9\7\u011d\2\2\u05a6\u05a7")
        buf.write("\7\u0108\2\2\u05a7\u05a8\7\u00d4\2\2\u05a8\u05aa\58\35")
        buf.write("\2\u05a9\u05a6\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aaI\3\2")
        buf.write("\2\2\u05ab\u05ac\5\u0104\u0083\2\u05ac\u05ad\7\u011d\2")
        buf.write("\2\u05adK\3\2\2\2\u05ae\u05af\5\"\22\2\u05af\u05b0\5R")
        buf.write("*\2\u05b0\u05b1\5N(\2\u05b1\u05e2\3\2\2\2\u05b2\u05b4")
        buf.write("\5x=\2\u05b3\u05b5\5P)\2\u05b4\u05b3\3\2\2\2\u05b5\u05b6")
        buf.write("\3\2\2\2\u05b6\u05b4\3\2\2\2\u05b6\u05b7\3\2\2\2\u05b7")
        buf.write("\u05e2\3\2\2\2\u05b8\u05b9\7E\2\2\u05b9\u05ba\7f\2\2\u05ba")
        buf.write("\u05bb\5\u00acW\2\u05bb\u05bd\5\u00a6T\2\u05bc\u05be\5")
        buf.write("p9\2\u05bd\u05bc\3\2\2\2\u05bd\u05be\3\2\2\2\u05be\u05e2")
        buf.write("\3\2\2\2\u05bf\u05c0\7\u00fe\2\2\u05c0\u05c1\5\u00acW")
        buf.write("\2\u05c1\u05c2\5\u00a6T\2\u05c2\u05c4\5b\62\2\u05c3\u05c5")
        buf.write("\5p9\2\u05c4\u05c3\3\2\2\2\u05c4\u05c5\3\2\2\2\u05c5\u05e2")
        buf.write("\3\2\2\2\u05c6\u05c7\7\u0093\2\2\u05c7\u05c8\7|\2\2\u05c8")
        buf.write("\u05c9\5\u00acW\2\u05c9\u05ca\5\u00a6T\2\u05ca\u05d0\7")
        buf.write("\u0101\2\2\u05cb\u05d1\5\u00acW\2\u05cc\u05cd\7\4\2\2")
        buf.write("\u05cd\u05ce\5 \21\2\u05ce\u05cf\7\5\2\2\u05cf\u05d1\3")
        buf.write("\2\2\2\u05d0\u05cb\3\2\2\2\u05d0\u05cc\3\2\2\2\u05d1\u05d2")
        buf.write("\3\2\2\2\u05d2\u05d3\5\u00a6T\2\u05d3\u05d4\7\u009f\2")
        buf.write("\2\u05d4\u05d8\5\u00be`\2\u05d5\u05d7\5d\63\2\u05d6\u05d5")
        buf.write("\3\2\2\2\u05d7\u05da\3\2\2\2\u05d8\u05d6\3\2\2\2\u05d8")
        buf.write("\u05d9\3\2\2\2\u05d9\u05de\3\2\2\2\u05da\u05d8\3\2\2\2")
        buf.write("\u05db\u05dd\5f\64\2\u05dc\u05db\3\2\2\2\u05dd\u05e0\3")
        buf.write("\2\2\2\u05de\u05dc\3\2\2\2\u05de\u05df\3\2\2\2\u05df\u05e2")
        buf.write("\3\2\2\2\u05e0\u05de\3\2\2\2\u05e1\u05ae\3\2\2\2\u05e1")
        buf.write("\u05b2\3\2\2\2\u05e1\u05b8\3\2\2\2\u05e1\u05bf\3\2\2\2")
        buf.write("\u05e1\u05c6\3\2\2\2\u05e2M\3\2\2\2\u05e3\u05e4\7\u00a4")
        buf.write("\2\2\u05e4\u05e5\7 \2\2\u05e5\u05ea\5V,\2\u05e6\u05e7")
        buf.write("\7\6\2\2\u05e7\u05e9\5V,\2\u05e8\u05e6\3\2\2\2\u05e9\u05ec")
        buf.write("\3\2\2\2\u05ea\u05e8\3\2\2\2\u05ea\u05eb\3\2\2\2\u05eb")
        buf.write("\u05ee\3\2\2\2\u05ec\u05ea\3\2\2\2\u05ed\u05e3\3\2\2\2")
        buf.write("\u05ed\u05ee\3\2\2\2\u05ee\u05f9\3\2\2\2\u05ef\u05f0\7")
        buf.write("(\2\2\u05f0\u05f1\7 \2\2\u05f1\u05f6\5\u00bc_\2\u05f2")
        buf.write("\u05f3\7\6\2\2\u05f3\u05f5\5\u00bc_\2\u05f4\u05f2\3\2")
        buf.write("\2\2\u05f5\u05f8\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f6\u05f7")
        buf.write("\3\2\2\2\u05f7\u05fa\3\2\2\2\u05f8\u05f6\3\2\2\2\u05f9")
        buf.write("\u05ef\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u0605\3\2\2\2")
        buf.write("\u05fb\u05fc\7M\2\2\u05fc\u05fd\7 \2\2\u05fd\u0602\5\u00bc")
        buf.write("_\2\u05fe\u05ff\7\6\2\2\u05ff\u0601\5\u00bc_\2\u0600\u05fe")
        buf.write("\3\2\2\2\u0601\u0604\3\2\2\2\u0602\u0600\3\2\2\2\u0602")
        buf.write("\u0603\3\2\2\2\u0603\u0606\3\2\2\2\u0604\u0602\3\2\2\2")
        buf.write("\u0605\u05fb\3\2\2\2\u0605\u0606\3\2\2\2\u0606\u0611\3")
        buf.write("\2\2\2\u0607\u0608\7\u00dc\2\2\u0608\u0609\7 \2\2\u0609")
        buf.write("\u060e\5V,\2\u060a\u060b\7\6\2\2\u060b\u060d\5V,\2\u060c")
        buf.write("\u060a\3\2\2\2\u060d\u0610\3\2\2\2\u060e\u060c\3\2\2\2")
        buf.write("\u060e\u060f\3\2\2\2\u060f\u0612\3\2\2\2\u0610\u060e\3")
        buf.write("\2\2\2\u0611\u0607\3\2\2\2\u0611\u0612\3\2\2\2\u0612\u0614")
        buf.write("\3\2\2\2\u0613\u0615\5\u00f0y\2\u0614\u0613\3\2\2\2\u0614")
        buf.write("\u0615\3\2\2\2\u0615\u061b\3\2\2\2\u0616\u0619\7\u0087")
        buf.write("\2\2\u0617\u061a\7\20\2\2\u0618\u061a\5\u00bc_\2\u0619")
        buf.write("\u0617\3\2\2\2\u0619\u0618\3\2\2\2\u061a\u061c\3\2\2\2")
        buf.write("\u061b\u0616\3\2\2\2\u061b\u061c\3\2\2\2\u061cO\3\2\2")
        buf.write("\2\u061d\u061e\5\"\22\2\u061e\u061f\5Z.\2\u061fQ\3\2\2")
        buf.write("\2\u0620\u0621\b*\1\2\u0621\u0622\5T+\2\u0622\u063a\3")
        buf.write("\2\2\2\u0623\u0624\f\5\2\2\u0624\u0625\6*\3\2\u0625\u0627")
        buf.write("\t\17\2\2\u0626\u0628\5\u0086D\2\u0627\u0626\3\2\2\2\u0627")
        buf.write("\u0628\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u0639\5R*\6\u062a")
        buf.write("\u062b\f\4\2\2\u062b\u062c\6*\5\2\u062c\u062e\7z\2\2\u062d")
        buf.write("\u062f\5\u0086D\2\u062e\u062d\3\2\2\2\u062e\u062f\3\2")
        buf.write("\2\2\u062f\u0630\3\2\2\2\u0630\u0639\5R*\5\u0631\u0632")
        buf.write("\f\3\2\2\u0632\u0633\6*\7\2\u0633\u0635\t\20\2\2\u0634")
        buf.write("\u0636\5\u0086D\2\u0635\u0634\3\2\2\2\u0635\u0636\3\2")
        buf.write("\2\2\u0636\u0637\3\2\2\2\u0637\u0639\5R*\4\u0638\u0623")
        buf.write("\3\2\2\2\u0638\u062a\3\2\2\2\u0638\u0631\3\2\2\2\u0639")
        buf.write("\u063c\3\2\2\2\u063a\u0638\3\2\2\2\u063a\u063b\3\2\2\2")
        buf.write("\u063bS\3\2\2\2\u063c\u063a\3\2\2\2\u063d\u0647\5\\/\2")
        buf.write("\u063e\u0647\5X-\2\u063f\u0640\7\u00e5\2\2\u0640\u0647")
        buf.write("\5\u00acW\2\u0641\u0647\5\u00a2R\2\u0642\u0643\7\4\2\2")
        buf.write("\u0643\u0644\5 \21\2\u0644\u0645\7\5\2\2\u0645\u0647\3")
        buf.write("\2\2\2\u0646\u063d\3\2\2\2\u0646\u063e\3\2\2\2\u0646\u063f")
        buf.write("\3\2\2\2\u0646\u0641\3\2\2\2\u0646\u0642\3\2\2\2\u0647")
        buf.write("U\3\2\2\2\u0648\u064a\5\u00bc_\2\u0649\u064b\t\21\2\2")
        buf.write("\u064a\u0649\3\2\2\2\u064a\u064b\3\2\2\2\u064b\u064e\3")
        buf.write("\2\2\2\u064c\u064d\7\u009d\2\2\u064d\u064f\t\22\2\2\u064e")
        buf.write("\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064fW\3\2\2\2\u0650")
        buf.write("\u0652\5x=\2\u0651\u0653\5Z.\2\u0652\u0651\3\2\2\2\u0653")
        buf.write("\u0654\3\2\2\2\u0654\u0652\3\2\2\2\u0654\u0655\3\2\2\2")
        buf.write("\u0655Y\3\2\2\2\u0656\u0658\5^\60\2\u0657\u0659\5p9\2")
        buf.write("\u0658\u0657\3\2\2\2\u0658\u0659\3\2\2\2\u0659\u065a\3")
        buf.write("\2\2\2\u065a\u065b\5N(\2\u065b\u0672\3\2\2\2\u065c\u0660")
        buf.write("\5`\61\2\u065d\u065f\5\u0084C\2\u065e\u065d\3\2\2\2\u065f")
        buf.write("\u0662\3\2\2\2\u0660\u065e\3\2\2\2\u0660\u0661\3\2\2\2")
        buf.write("\u0661\u0664\3\2\2\2\u0662\u0660\3\2\2\2\u0663\u0665\5")
        buf.write("p9\2\u0664\u0663\3\2\2\2\u0664\u0665\3\2\2\2\u0665\u0667")
        buf.write("\3\2\2\2\u0666\u0668\5z>\2\u0667\u0666\3\2\2\2\u0667\u0668")
        buf.write("\3\2\2\2\u0668\u066a\3\2\2\2\u0669\u066b\5r:\2\u066a\u0669")
        buf.write("\3\2\2\2\u066a\u066b\3\2\2\2\u066b\u066d\3\2\2\2\u066c")
        buf.write("\u066e\5\u00f0y\2\u066d\u066c\3\2\2\2\u066d\u066e\3\2")
        buf.write("\2\2\u066e\u066f\3\2\2\2\u066f\u0670\5N(\2\u0670\u0672")
        buf.write("\3\2\2\2\u0671\u0656\3\2\2\2\u0671\u065c\3\2\2\2\u0672")
        buf.write("[\3\2\2\2\u0673\u0675\5^\60\2\u0674\u0676\5x=\2\u0675")
        buf.write("\u0674\3\2\2\2\u0675\u0676\3\2\2\2\u0676\u0678\3\2\2\2")
        buf.write("\u0677\u0679\5p9\2\u0678\u0677\3\2\2\2\u0678\u0679\3\2")
        buf.write("\2\2\u0679\u0691\3\2\2\2\u067a\u067c\5`\61\2\u067b\u067d")
        buf.write("\5x=\2\u067c\u067b\3\2\2\2\u067c\u067d\3\2\2\2\u067d\u0681")
        buf.write("\3\2\2\2\u067e\u0680\5\u0084C\2\u067f\u067e\3\2\2\2\u0680")
        buf.write("\u0683\3\2\2\2\u0681\u067f\3\2\2\2\u0681\u0682\3\2\2\2")
        buf.write("\u0682\u0685\3\2\2\2\u0683\u0681\3\2\2\2\u0684\u0686\5")
        buf.write("p9\2\u0685\u0684\3\2\2\2\u0685\u0686\3\2\2\2\u0686\u0688")
        buf.write("\3\2\2\2\u0687\u0689\5z>\2\u0688\u0687\3\2\2\2\u0688\u0689")
        buf.write("\3\2\2\2\u0689\u068b\3\2\2\2\u068a\u068c\5r:\2\u068b\u068a")
        buf.write("\3\2\2\2\u068b\u068c\3\2\2\2\u068c\u068e\3\2\2\2\u068d")
        buf.write("\u068f\5\u00f0y\2\u068e\u068d\3\2\2\2\u068e\u068f\3\2")
        buf.write("\2\2\u068f\u0691\3\2\2\2\u0690\u0673\3\2\2\2\u0690\u067a")
        buf.write("\3\2\2\2\u0691]\3\2\2\2\u0692\u0693\7\u00d0\2\2\u0693")
        buf.write("\u0694\7\u00f1\2\2\u0694\u0695\7\4\2\2\u0695\u0696\5\u00b4")
        buf.write("[\2\u0696\u0697\7\5\2\2\u0697\u069d\3\2\2\2\u0698\u0699")
        buf.write("\7\u0091\2\2\u0699\u069d\5\u00b4[\2\u069a\u069b\7\u00bd")
        buf.write("\2\2\u069b\u069d\5\u00b4[\2\u069c\u0692\3\2\2\2\u069c")
        buf.write("\u0698\3\2\2\2\u069c\u069a\3\2\2\2\u069d\u069f\3\2\2\2")
        buf.write("\u069e\u06a0\5\u00a8U\2\u069f\u069e\3\2\2\2\u069f\u06a0")
        buf.write("\3\2\2\2\u06a0\u06a3\3\2\2\2\u06a1\u06a2\7\u00bb\2\2\u06a2")
        buf.write("\u06a4\7\u011d\2\2\u06a3\u06a1\3\2\2\2\u06a3\u06a4\3\2")
        buf.write("\2\2\u06a4\u06a5\3\2\2\2\u06a5\u06a6\7\u0101\2\2\u06a6")
        buf.write("\u06b3\7\u011d\2\2\u06a7\u06b1\7\30\2\2\u06a8\u06b2\5")
        buf.write("\u0096L\2\u06a9\u06b2\5\u00e6t\2\u06aa\u06ad\7\4\2\2\u06ab")
        buf.write("\u06ae\5\u0096L\2\u06ac\u06ae\5\u00e6t\2\u06ad\u06ab\3")
        buf.write("\2\2\2\u06ad\u06ac\3\2\2\2\u06ae\u06af\3\2\2\2\u06af\u06b0")
        buf.write("\7\5\2\2\u06b0\u06b2\3\2\2\2\u06b1\u06a8\3\2\2\2\u06b1")
        buf.write("\u06a9\3\2\2\2\u06b1\u06aa\3\2\2\2\u06b2\u06b4\3\2\2\2")
        buf.write("\u06b3\u06a7\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4\u06b6\3")
        buf.write("\2\2\2\u06b5\u06b7\5\u00a8U\2\u06b6\u06b5\3\2\2\2\u06b6")
        buf.write("\u06b7\3\2\2\2\u06b7\u06ba\3\2\2\2\u06b8\u06b9\7\u00ba")
        buf.write("\2\2\u06b9\u06bb\7\u011d\2\2\u06ba\u06b8\3\2\2\2\u06ba")
        buf.write("\u06bb\3\2\2\2\u06bb_\3\2\2\2\u06bc\u06c0\7\u00d0\2\2")
        buf.write("\u06bd\u06bf\5t;\2\u06be\u06bd\3\2\2\2\u06bf\u06c2\3\2")
        buf.write("\2\2\u06c0\u06be\3\2\2\2\u06c0\u06c1\3\2\2\2\u06c1\u06c4")
        buf.write("\3\2\2\2\u06c2\u06c0\3\2\2\2\u06c3\u06c5\5\u0086D\2\u06c4")
        buf.write("\u06c3\3\2\2\2\u06c4\u06c5\3\2\2\2\u06c5\u06c6\3\2\2\2")
        buf.write("\u06c6\u06c7\5\u00b4[\2\u06c7a\3\2\2\2\u06c8\u06c9\7\u00d6")
        buf.write("\2\2\u06c9\u06ca\5l\67\2\u06cac\3\2\2\2\u06cb\u06cc\7")
        buf.write("\u0105\2\2\u06cc\u06cf\7\u0092\2\2\u06cd\u06ce\7\23\2")
        buf.write("\2\u06ce\u06d0\5\u00be`\2\u06cf\u06cd\3\2\2\2\u06cf\u06d0")
        buf.write("\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1\u06d2\7\u00eb\2\2\u06d2")
        buf.write("\u06d3\5h\65\2\u06d3e\3\2\2\2\u06d4\u06d5\7\u0105\2\2")
        buf.write("\u06d5\u06d6\7\u009b\2\2\u06d6\u06d9\7\u0092\2\2\u06d7")
        buf.write("\u06d8\7\23\2\2\u06d8\u06da\5\u00be`\2\u06d9\u06d7\3\2")
        buf.write("\2\2\u06d9\u06da\3\2\2\2\u06da\u06db\3\2\2\2\u06db\u06dc")
        buf.write("\7\u00eb\2\2\u06dc\u06dd\5j\66\2\u06ddg\3\2\2\2\u06de")
        buf.write("\u06e6\7E\2\2\u06df\u06e0\7\u00fe\2\2\u06e0\u06e1\7\u00d6")
        buf.write("\2\2\u06e1\u06e6\7\u0114\2\2\u06e2\u06e3\7\u00fe\2\2\u06e3")
        buf.write("\u06e4\7\u00d6\2\2\u06e4\u06e6\5l\67\2\u06e5\u06de\3\2")
        buf.write("\2\2\u06e5\u06df\3\2\2\2\u06e5\u06e2\3\2\2\2\u06e6i\3")
        buf.write("\2\2\2\u06e7\u06e8\7y\2\2\u06e8\u06fa\7\u0114\2\2\u06e9")
        buf.write("\u06ea\7y\2\2\u06ea\u06eb\7\4\2\2\u06eb\u06ec\5\u00aa")
        buf.write("V\2\u06ec\u06ed\7\5\2\2\u06ed\u06ee\7\u0102\2\2\u06ee")
        buf.write("\u06ef\7\4\2\2\u06ef\u06f4\5\u00bc_\2\u06f0\u06f1\7\6")
        buf.write("\2\2\u06f1\u06f3\5\u00bc_\2\u06f2\u06f0\3\2\2\2\u06f3")
        buf.write("\u06f6\3\2\2\2\u06f4\u06f2\3\2\2\2\u06f4\u06f5\3\2\2\2")
        buf.write("\u06f5\u06f7\3\2\2\2\u06f6\u06f4\3\2\2\2\u06f7\u06f8\7")
        buf.write("\5\2\2\u06f8\u06fa\3\2\2\2\u06f9\u06e7\3\2\2\2\u06f9\u06e9")
        buf.write("\3\2\2\2\u06fak\3\2\2\2\u06fb\u0700\5n8\2\u06fc\u06fd")
        buf.write("\7\6\2\2\u06fd\u06ff\5n8\2\u06fe\u06fc\3\2\2\2\u06ff\u0702")
        buf.write("\3\2\2\2\u0700\u06fe\3\2\2\2\u0700\u0701\3\2\2\2\u0701")
        buf.write("m\3\2\2\2\u0702\u0700\3\2\2\2\u0703\u0704\5\u00acW\2\u0704")
        buf.write("\u0705\7\u010a\2\2\u0705\u0706\5\u00bc_\2\u0706o\3\2\2")
        buf.write("\2\u0707\u0708\7\u0106\2\2\u0708\u0709\5\u00be`\2\u0709")
        buf.write("q\3\2\2\2\u070a\u070b\7n\2\2\u070b\u070c\5\u00be`\2\u070c")
        buf.write("s\3\2\2\2\u070d\u070e\7\b\2\2\u070e\u0715\5v<\2\u070f")
        buf.write("\u0711\7\6\2\2\u0710\u070f\3\2\2\2\u0710\u0711\3\2\2\2")
        buf.write("\u0711\u0712\3\2\2\2\u0712\u0714\5v<\2\u0713\u0710\3\2")
        buf.write("\2\2\u0714\u0717\3\2\2\2\u0715\u0713\3\2\2\2\u0715\u0716")
        buf.write("\3\2\2\2\u0716\u0718\3\2\2\2\u0717\u0715\3\2\2\2\u0718")
        buf.write("\u0719\7\t\2\2\u0719u\3\2\2\2\u071a\u0728\5\u0104\u0083")
        buf.write("\2\u071b\u071c\5\u0104\u0083\2\u071c\u071d\7\4\2\2\u071d")
        buf.write("\u0722\5\u00c4c\2\u071e\u071f\7\6\2\2\u071f\u0721\5\u00c4")
        buf.write("c\2\u0720\u071e\3\2\2\2\u0721\u0724\3\2\2\2\u0722\u0720")
        buf.write("\3\2\2\2\u0722\u0723\3\2\2\2\u0723\u0725\3\2\2\2\u0724")
        buf.write("\u0722\3\2\2\2\u0725\u0726\7\5\2\2\u0726\u0728\3\2\2\2")
        buf.write("\u0727\u071a\3\2\2\2\u0727\u071b\3\2\2\2\u0728w\3\2\2")
        buf.write("\2\u0729\u072a\7f\2\2\u072a\u072f\5\u0088E\2\u072b\u072c")
        buf.write("\7\6\2\2\u072c\u072e\5\u0088E\2\u072d\u072b\3\2\2\2\u072e")
        buf.write("\u0731\3\2\2\2\u072f\u072d\3\2\2\2\u072f\u0730\3\2\2\2")
        buf.write("\u0730\u0735\3\2\2\2\u0731\u072f\3\2\2\2\u0732\u0734\5")
        buf.write("\u0084C\2\u0733\u0732\3\2\2\2\u0734\u0737\3\2\2\2\u0735")
        buf.write("\u0733\3\2\2\2\u0735\u0736\3\2\2\2\u0736\u0739\3\2\2\2")
        buf.write("\u0737\u0735\3\2\2\2\u0738\u073a\5~@\2\u0739\u0738\3\2")
        buf.write("\2\2\u0739\u073a\3\2\2\2\u073ay\3\2\2\2\u073b\u073c\7")
        buf.write("l\2\2\u073c\u073d\7 \2\2\u073d\u0742\5\u00bc_\2\u073e")
        buf.write("\u073f\7\6\2\2\u073f\u0741\5\u00bc_\2\u0740\u073e\3\2")
        buf.write("\2\2\u0741\u0744\3\2\2\2\u0742\u0740\3\2\2\2\u0742\u0743")
        buf.write("\3\2\2\2\u0743\u0756\3\2\2\2\u0744\u0742\3\2\2\2\u0745")
        buf.write("\u0746\7\u0108\2\2\u0746\u0757\7\u00cb\2\2\u0747\u0748")
        buf.write("\7\u0108\2\2\u0748\u0757\79\2\2\u0749\u074a\7m\2\2\u074a")
        buf.write("\u074b\7\u00d8\2\2\u074b\u074c\7\4\2\2\u074c\u0751\5|")
        buf.write("?\2\u074d\u074e\7\6\2\2\u074e\u0750\5|?\2\u074f\u074d")
        buf.write("\3\2\2\2\u0750\u0753\3\2\2\2\u0751\u074f\3\2\2\2\u0751")
        buf.write("\u0752\3\2\2\2\u0752\u0754\3\2\2\2\u0753\u0751\3\2\2\2")
        buf.write("\u0754\u0755\7\5\2\2\u0755\u0757\3\2\2\2\u0756\u0745\3")
        buf.write("\2\2\2\u0756\u0747\3\2\2\2\u0756\u0749\3\2\2\2\u0756\u0757")
        buf.write("\3\2\2\2\u0757\u0768\3\2\2\2\u0758\u0759\7l\2\2\u0759")
        buf.write("\u075a\7 \2\2\u075a\u075b\7m\2\2\u075b\u075c\7\u00d8\2")
        buf.write("\2\u075c\u075d\7\4\2\2\u075d\u0762\5|?\2\u075e\u075f\7")
        buf.write("\6\2\2\u075f\u0761\5|?\2\u0760\u075e\3\2\2\2\u0761\u0764")
        buf.write("\3\2\2\2\u0762\u0760\3\2\2\2\u0762\u0763\3\2\2\2\u0763")
        buf.write("\u0765\3\2\2\2\u0764\u0762\3\2\2\2\u0765\u0766\7\5\2\2")
        buf.write("\u0766\u0768\3\2\2\2\u0767\u073b\3\2\2\2\u0767\u0758\3")
        buf.write("\2\2\2\u0768{\3\2\2\2\u0769\u0772\7\4\2\2\u076a\u076f")
        buf.write("\5\u00bc_\2\u076b\u076c\7\6\2\2\u076c\u076e\5\u00bc_\2")
        buf.write("\u076d\u076b\3\2\2\2\u076e\u0771\3\2\2\2\u076f\u076d\3")
        buf.write("\2\2\2\u076f\u0770\3\2\2\2\u0770\u0773\3\2\2\2\u0771\u076f")
        buf.write("\3\2\2\2\u0772\u076a\3\2\2\2\u0772\u0773\3\2\2\2\u0773")
        buf.write("\u0774\3\2\2\2\u0774\u0777\7\5\2\2\u0775\u0777\5\u00bc")
        buf.write("_\2\u0776\u0769\3\2\2\2\u0776\u0775\3\2\2\2\u0777}\3\2")
        buf.write("\2\2\u0778\u0779\7\u00b0\2\2\u0779\u077a\7\4\2\2\u077a")
        buf.write("\u077b\5\u00b4[\2\u077b\u077c\7b\2\2\u077c\u077d\5\u0080")
        buf.write("A\2\u077d\u077e\7s\2\2\u077e\u077f\7\4\2\2\u077f\u0784")
        buf.write("\5\u0082B\2\u0780\u0781\7\6\2\2\u0781\u0783\5\u0082B\2")
        buf.write("\u0782\u0780\3\2\2\2\u0783\u0786\3\2\2\2\u0784\u0782\3")
        buf.write("\2\2\2\u0784\u0785\3\2\2\2\u0785\u0787\3\2\2\2\u0786\u0784")
        buf.write("\3\2\2\2\u0787\u0788\7\5\2\2\u0788\u0789\7\5\2\2\u0789")
        buf.write("\177\3\2\2\2\u078a\u0797\5\u0104\u0083\2\u078b\u078c\7")
        buf.write("\4\2\2\u078c\u0791\5\u0104\u0083\2\u078d\u078e\7\6\2\2")
        buf.write("\u078e\u0790\5\u0104\u0083\2\u078f\u078d\3\2\2\2\u0790")
        buf.write("\u0793\3\2\2\2\u0791\u078f\3\2\2\2\u0791\u0792\3\2\2\2")
        buf.write("\u0792\u0794\3\2\2\2\u0793\u0791\3\2\2\2\u0794\u0795\7")
        buf.write("\5\2\2\u0795\u0797\3\2\2\2\u0796\u078a\3\2\2\2\u0796\u078b")
        buf.write("\3\2\2\2\u0797\u0081\3\2\2\2\u0798\u079d\5\u00bc_\2\u0799")
        buf.write("\u079b\7\30\2\2\u079a\u0799\3\2\2\2\u079a\u079b\3\2\2")
        buf.write("\2\u079b\u079c\3\2\2\2\u079c\u079e\5\u0104\u0083\2\u079d")
        buf.write("\u079a\3\2\2\2\u079d\u079e\3\2\2\2\u079e\u0083\3\2\2\2")
        buf.write("\u079f\u07a0\7\u0082\2\2\u07a0\u07a2\7\u0103\2\2\u07a1")
        buf.write("\u07a3\7\u00a6\2\2\u07a2\u07a1\3\2\2\2\u07a2\u07a3\3\2")
        buf.write("\2\2\u07a3\u07a4\3\2\2\2\u07a4\u07a5\5\u00fe\u0080\2\u07a5")
        buf.write("\u07ae\7\4\2\2\u07a6\u07ab\5\u00bc_\2\u07a7\u07a8\7\6")
        buf.write("\2\2\u07a8\u07aa\5\u00bc_\2\u07a9\u07a7\3\2\2\2\u07aa")
        buf.write("\u07ad\3\2\2\2\u07ab\u07a9\3\2\2\2\u07ab\u07ac\3\2\2\2")
        buf.write("\u07ac\u07af\3\2\2\2\u07ad\u07ab\3\2\2\2\u07ae\u07a6\3")
        buf.write("\2\2\2\u07ae\u07af\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b1")
        buf.write("\7\5\2\2\u07b1\u07bd\5\u0104\u0083\2\u07b2\u07b4\7\30")
        buf.write("\2\2\u07b3\u07b2\3\2\2\2\u07b3\u07b4\3\2\2\2\u07b4\u07b5")
        buf.write("\3\2\2\2\u07b5\u07ba\5\u0104\u0083\2\u07b6\u07b7\7\6\2")
        buf.write("\2\u07b7\u07b9\5\u0104\u0083\2\u07b8\u07b6\3\2\2\2\u07b9")
        buf.write("\u07bc\3\2\2\2\u07ba\u07b8\3\2\2\2\u07ba\u07bb\3\2\2\2")
        buf.write("\u07bb\u07be\3\2\2\2\u07bc\u07ba\3\2\2\2\u07bd\u07b3\3")
        buf.write("\2\2\2\u07bd\u07be\3\2\2\2\u07be\u0085\3\2\2\2\u07bf\u07c0")
        buf.write("\t\23\2\2\u07c0\u0087\3\2\2\2\u07c1\u07c5\5\u00a0Q\2\u07c2")
        buf.write("\u07c4\5\u008aF\2\u07c3\u07c2\3\2\2\2\u07c4\u07c7\3\2")
        buf.write("\2\2\u07c5\u07c3\3\2\2\2\u07c5\u07c6\3\2\2\2\u07c6\u0089")
        buf.write("\3\2\2\2\u07c7\u07c5\3\2\2\2\u07c8\u07c9\5\u008cG\2\u07c9")
        buf.write("\u07ca\7\177\2\2\u07ca\u07cc\5\u00a0Q\2\u07cb\u07cd\5")
        buf.write("\u008eH\2\u07cc\u07cb\3\2\2\2\u07cc\u07cd\3\2\2\2\u07cd")
        buf.write("\u07d4\3\2\2\2\u07ce\u07cf\7\u0099\2\2\u07cf\u07d0\5\u008c")
        buf.write("G\2\u07d0\u07d1\7\177\2\2\u07d1\u07d2\5\u00a0Q\2\u07d2")
        buf.write("\u07d4\3\2\2\2\u07d3\u07c8\3\2\2\2\u07d3\u07ce\3\2\2\2")
        buf.write("\u07d4\u008b\3\2\2\2\u07d5\u07d7\7v\2\2\u07d6\u07d5\3")
        buf.write("\2\2\2\u07d6\u07d7\3\2\2\2\u07d7\u07ee\3\2\2\2\u07d8\u07ee")
        buf.write("\78\2\2\u07d9\u07db\7\u0085\2\2\u07da\u07dc\7\u00a6\2")
        buf.write("\2\u07db\u07da\3\2\2\2\u07db\u07dc\3\2\2\2\u07dc\u07ee")
        buf.write("\3\2\2\2\u07dd\u07df\7\u0085\2\2\u07de\u07dd\3\2\2\2\u07de")
        buf.write("\u07df\3\2\2\2\u07df\u07e0\3\2\2\2\u07e0\u07ee\7\u00d1")
        buf.write("\2\2\u07e1\u07e3\7\u00c6\2\2\u07e2\u07e4\7\u00a6\2\2\u07e3")
        buf.write("\u07e2\3\2\2\2\u07e3\u07e4\3\2\2\2\u07e4\u07ee\3\2\2\2")
        buf.write("\u07e5\u07e7\7g\2\2\u07e6\u07e8\7\u00a6\2\2\u07e7\u07e6")
        buf.write("\3\2\2\2\u07e7\u07e8\3\2\2\2\u07e8\u07ee\3\2\2\2\u07e9")
        buf.write("\u07eb\7\u0085\2\2\u07ea\u07e9\3\2\2\2\u07ea\u07eb\3\2")
        buf.write("\2\2\u07eb\u07ec\3\2\2\2\u07ec\u07ee\7\24\2\2\u07ed\u07d6")
        buf.write("\3\2\2\2\u07ed\u07d8\3\2\2\2\u07ed\u07d9\3\2\2\2\u07ed")
        buf.write("\u07de\3\2\2\2\u07ed\u07e1\3\2\2\2\u07ed\u07e5\3\2\2\2")
        buf.write("\u07ed\u07ea\3\2\2\2\u07ee\u008d\3\2\2\2\u07ef\u07f0\7")
        buf.write("\u009f\2\2\u07f0\u07f4\5\u00be`\2\u07f1\u07f2\7\u0101")
        buf.write("\2\2\u07f2\u07f4\5\u0094K\2\u07f3\u07ef\3\2\2\2\u07f3")
        buf.write("\u07f1\3\2\2\2\u07f4\u008f\3\2\2\2\u07f5\u07f6\7\u00e7")
        buf.write("\2\2\u07f6\u07f8\7\4\2\2\u07f7\u07f9\5\u0092J\2\u07f8")
        buf.write("\u07f7\3\2\2\2\u07f8\u07f9\3\2\2\2\u07f9\u07fa\3\2\2\2")
        buf.write("\u07fa\u07fb\7\5\2\2\u07fb\u0091\3\2\2\2\u07fc\u07fe\7")
        buf.write("\u0113\2\2\u07fd\u07fc\3\2\2\2\u07fd\u07fe\3\2\2\2\u07fe")
        buf.write("\u07ff\3\2\2\2\u07ff\u0800\t\24\2\2\u0800\u0815\7\u00af")
        buf.write("\2\2\u0801\u0802\5\u00bc_\2\u0802\u0803\7\u00cd\2\2\u0803")
        buf.write("\u0815\3\2\2\2\u0804\u0805\7\36\2\2\u0805\u0806\7\u0121")
        buf.write("\2\2\u0806\u0807\7\u00a5\2\2\u0807\u0808\7\u009e\2\2\u0808")
        buf.write("\u0811\7\u0121\2\2\u0809\u080f\7\u009f\2\2\u080a\u0810")
        buf.write("\5\u0104\u0083\2\u080b\u080c\5\u00fe\u0080\2\u080c\u080d")
        buf.write("\7\4\2\2\u080d\u080e\7\5\2\2\u080e\u0810\3\2\2\2\u080f")
        buf.write("\u080a\3\2\2\2\u080f\u080b\3\2\2\2\u0810\u0812\3\2\2\2")
        buf.write("\u0811\u0809\3\2\2\2\u0811\u0812\3\2\2\2\u0812\u0815\3")
        buf.write("\2\2\2\u0813\u0815\5\u00bc_\2\u0814\u07fd\3\2\2\2\u0814")
        buf.write("\u0801\3\2\2\2\u0814\u0804\3\2\2\2\u0814\u0813\3\2\2\2")
        buf.write("\u0815\u0093\3\2\2\2\u0816\u0817\7\4\2\2\u0817\u0818\5")
        buf.write("\u0096L\2\u0818\u0819\7\5\2\2\u0819\u0095\3\2\2\2\u081a")
        buf.write("\u081f\5\u0100\u0081\2\u081b\u081c\7\6\2\2\u081c\u081e")
        buf.write("\5\u0100\u0081\2\u081d\u081b\3\2\2\2\u081e\u0821\3\2\2")
        buf.write("\2\u081f\u081d\3\2\2\2\u081f\u0820\3\2\2\2\u0820\u0097")
        buf.write("\3\2\2\2\u0821\u081f\3\2\2\2\u0822\u0823\7\4\2\2\u0823")
        buf.write("\u0828\5\u009aN\2\u0824\u0825\7\6\2\2\u0825\u0827\5\u009a")
        buf.write("N\2\u0826\u0824\3\2\2\2\u0827\u082a\3\2\2\2\u0828\u0826")
        buf.write("\3\2\2\2\u0828\u0829\3\2\2\2\u0829\u082b\3\2\2\2\u082a")
        buf.write("\u0828\3\2\2\2\u082b\u082c\7\5\2\2\u082c\u0099\3\2\2\2")
        buf.write("\u082d\u082f\5\u0100\u0081\2\u082e\u0830\t\21\2\2\u082f")
        buf.write("\u082e\3\2\2\2\u082f\u0830\3\2\2\2\u0830\u009b\3\2\2\2")
        buf.write("\u0831\u0832\7\4\2\2\u0832\u0837\5\u009eP\2\u0833\u0834")
        buf.write("\7\6\2\2\u0834\u0836\5\u009eP\2\u0835\u0833\3\2\2\2\u0836")
        buf.write("\u0839\3\2\2\2\u0837\u0835\3\2\2\2\u0837\u0838\3\2\2\2")
        buf.write("\u0838\u083a\3\2\2\2\u0839\u0837\3\2\2\2\u083a\u083b\7")
        buf.write("\5\2\2\u083b\u009d\3\2\2\2\u083c\u083e\5\u0104\u0083\2")
        buf.write("\u083d\u083f\5\36\20\2\u083e\u083d\3\2\2\2\u083e\u083f")
        buf.write("\3\2\2\2\u083f\u009f\3\2\2\2\u0840\u0842\5\u00acW\2\u0841")
        buf.write("\u0843\5\u0090I\2\u0842\u0841\3\2\2\2\u0842\u0843\3\2")
        buf.write("\2\2\u0843\u0844\3\2\2\2\u0844\u0845\5\u00a6T\2\u0845")
        buf.write("\u0857\3\2\2\2\u0846\u0847\7\4\2\2\u0847\u0848\5 \21\2")
        buf.write("\u0848\u084a\7\5\2\2\u0849\u084b\5\u0090I\2\u084a\u0849")
        buf.write("\3\2\2\2\u084a\u084b\3\2\2\2\u084b\u084c\3\2\2\2\u084c")
        buf.write("\u084d\5\u00a6T\2\u084d\u0857\3\2\2\2\u084e\u084f\7\4")
        buf.write("\2\2\u084f\u0850\5\u0088E\2\u0850\u0852\7\5\2\2\u0851")
        buf.write("\u0853\5\u0090I\2\u0852\u0851\3\2\2\2\u0852\u0853\3\2")
        buf.write("\2\2\u0853\u0854\3\2\2\2\u0854\u0855\5\u00a6T\2\u0855")
        buf.write("\u0857\3\2\2\2\u0856\u0840\3\2\2\2\u0856\u0846\3\2\2\2")
        buf.write("\u0856\u084e\3\2\2\2\u0857\u00a1\3\2\2\2\u0858\u0859\7")
        buf.write("\u0102\2\2\u0859\u085e\5\u00bc_\2\u085a\u085b\7\6\2\2")
        buf.write("\u085b\u085d\5\u00bc_\2\u085c\u085a\3\2\2\2\u085d\u0860")
        buf.write("\3\2\2\2\u085e\u085c\3\2\2\2\u085e\u085f\3\2\2\2\u085f")
        buf.write("\u0861\3\2\2\2\u0860\u085e\3\2\2\2\u0861\u0862\5\u00a6")
        buf.write("T\2\u0862\u00a3\3\2\2\2\u0863\u0864\5\u0100\u0081\2\u0864")
        buf.write("\u086d\7\4\2\2\u0865\u086a\5\u00bc_\2\u0866\u0867\7\6")
        buf.write("\2\2\u0867\u0869\5\u00bc_\2\u0868\u0866\3\2\2\2\u0869")
        buf.write("\u086c\3\2\2\2\u086a\u0868\3\2\2\2\u086a\u086b\3\2\2\2")
        buf.write("\u086b\u086e\3\2\2\2\u086c\u086a\3\2\2\2\u086d\u0865\3")
        buf.write("\2\2\2\u086d\u086e\3\2\2\2\u086e\u086f\3\2\2\2\u086f\u0870")
        buf.write("\7\5\2\2\u0870\u0871\5\u00a6T\2\u0871\u00a5\3\2\2\2\u0872")
        buf.write("\u0874\7\30\2\2\u0873\u0872\3\2\2\2\u0873\u0874\3\2\2")
        buf.write("\2\u0874\u0875\3\2\2\2\u0875\u0877\5\u0106\u0084\2\u0876")
        buf.write("\u0878\5\u0094K\2\u0877\u0876\3\2\2\2\u0877\u0878\3\2")
        buf.write("\2\2\u0878\u087a\3\2\2\2\u0879\u0873\3\2\2\2\u0879\u087a")
        buf.write("\3\2\2\2\u087a\u00a7\3\2\2\2\u087b\u087c\7\u00cc\2\2\u087c")
        buf.write("\u087d\7d\2\2\u087d\u087e\7\u00d3\2\2\u087e\u0882\7\u011d")
        buf.write("\2\2\u087f\u0880\7\u0108\2\2\u0880\u0881\7\u00d4\2\2\u0881")
        buf.write("\u0883\58\35\2\u0882\u087f\3\2\2\2\u0882\u0883\3\2\2\2")
        buf.write("\u0883\u08ad\3\2\2\2\u0884\u0885\7\u00cc\2\2\u0885\u0886")
        buf.write("\7d\2\2\u0886\u0890\7F\2\2\u0887\u0888\7]\2\2\u0888\u0889")
        buf.write("\7\u00ea\2\2\u0889\u088a\7 \2\2\u088a\u088e\7\u011d\2")
        buf.write("\2\u088b\u088c\7R\2\2\u088c\u088d\7 \2\2\u088d\u088f\7")
        buf.write("\u011d\2\2\u088e\u088b\3\2\2\2\u088e\u088f\3\2\2\2\u088f")
        buf.write("\u0891\3\2\2\2\u0890\u0887\3\2\2\2\u0890\u0891\3\2\2\2")
        buf.write("\u0891\u0897\3\2\2\2\u0892\u0893\7,\2\2\u0893\u0894\7")
        buf.write("~\2\2\u0894\u0895\7\u00ea\2\2\u0895\u0896\7 \2\2\u0896")
        buf.write("\u0898\7\u011d\2\2\u0897\u0892\3\2\2\2\u0897\u0898\3\2")
        buf.write("\2\2\u0898\u089e\3\2\2\2\u0899\u089a\7\u0091\2\2\u089a")
        buf.write("\u089b\7\u0080\2\2\u089b\u089c\7\u00ea\2\2\u089c\u089d")
        buf.write("\7 \2\2\u089d\u089f\7\u011d\2\2\u089e\u0899\3\2\2\2\u089e")
        buf.write("\u089f\3\2\2\2\u089f\u08a4\3\2\2\2\u08a0\u08a1\7\u0088")
        buf.write("\2\2\u08a1\u08a2\7\u00ea\2\2\u08a2\u08a3\7 \2\2\u08a3")
        buf.write("\u08a5\7\u011d\2\2\u08a4\u08a0\3\2\2\2\u08a4\u08a5\3\2")
        buf.write("\2\2\u08a5\u08aa\3\2\2\2\u08a6\u08a7\7\u009c\2\2\u08a7")
        buf.write("\u08a8\7D\2\2\u08a8\u08a9\7\30\2\2\u08a9\u08ab\7\u011d")
        buf.write("\2\2\u08aa\u08a6\3\2\2\2\u08aa\u08ab\3\2\2\2\u08ab\u08ad")
        buf.write("\3\2\2\2\u08ac\u087b\3\2\2\2\u08ac\u0884\3\2\2\2\u08ad")
        buf.write("\u00a9\3\2\2\2\u08ae\u08b3\5\u00acW\2\u08af\u08b0\7\6")
        buf.write("\2\2\u08b0\u08b2\5\u00acW\2\u08b1\u08af\3\2\2\2\u08b2")
        buf.write("\u08b5\3\2\2\2\u08b3\u08b1\3\2\2\2\u08b3\u08b4\3\2\2\2")
        buf.write("\u08b4\u00ab\3\2\2\2\u08b5\u08b3\3\2\2\2\u08b6\u08bb\5")
        buf.write("\u0100\u0081\2\u08b7\u08b8\7\7\2\2\u08b8\u08ba\5\u0100")
        buf.write("\u0081\2\u08b9\u08b7\3\2\2\2\u08ba\u08bd\3\2\2\2\u08bb")
        buf.write("\u08b9\3\2\2\2\u08bb\u08bc\3\2\2\2\u08bc\u00ad\3\2\2\2")
        buf.write("\u08bd\u08bb\3\2\2\2\u08be\u08bf\5\u0100\u0081\2\u08bf")
        buf.write("\u08c0\7\7\2\2\u08c0\u08c2\3\2\2\2\u08c1\u08be\3\2\2\2")
        buf.write("\u08c1\u08c2\3\2\2\2\u08c2\u08c3\3\2\2\2\u08c3\u08c4\5")
        buf.write("\u0100\u0081\2\u08c4\u00af\3\2\2\2\u08c5\u08c6\5\u0100")
        buf.write("\u0081\2\u08c6\u08c7\7\7\2\2\u08c7\u08c9\3\2\2\2\u08c8")
        buf.write("\u08c5\3\2\2\2\u08c8\u08c9\3\2\2\2\u08c9\u08ca\3\2\2\2")
        buf.write("\u08ca\u08cb\5\u0100\u0081\2\u08cb\u00b1\3\2\2\2\u08cc")
        buf.write("\u08d4\5\u00bc_\2\u08cd\u08cf\7\30\2\2\u08ce\u08cd\3\2")
        buf.write("\2\2\u08ce\u08cf\3\2\2\2\u08cf\u08d2\3\2\2\2\u08d0\u08d3")
        buf.write("\5\u0100\u0081\2\u08d1\u08d3\5\u0094K\2\u08d2\u08d0\3")
        buf.write("\2\2\2\u08d2\u08d1\3\2\2\2\u08d3\u08d5\3\2\2\2\u08d4\u08ce")
        buf.write("\3\2\2\2\u08d4\u08d5\3\2\2\2\u08d5\u00b3\3\2\2\2\u08d6")
        buf.write("\u08db\5\u00b2Z\2\u08d7\u08d8\7\6\2\2\u08d8\u08da\5\u00b2")
        buf.write("Z\2\u08d9\u08d7\3\2\2\2\u08da\u08dd\3\2\2\2\u08db\u08d9")
        buf.write("\3\2\2\2\u08db\u08dc\3\2\2\2\u08dc\u00b5\3\2\2\2\u08dd")
        buf.write("\u08db\3\2\2\2\u08de\u08df\7\4\2\2\u08df\u08e4\5\u00b8")
        buf.write("]\2\u08e0\u08e1\7\6\2\2\u08e1\u08e3\5\u00b8]\2\u08e2\u08e0")
        buf.write("\3\2\2\2\u08e3\u08e6\3\2\2\2\u08e4\u08e2\3\2\2\2\u08e4")
        buf.write("\u08e5\3\2\2\2\u08e5\u08e7\3\2\2\2\u08e6\u08e4\3\2\2\2")
        buf.write("\u08e7\u08e8\7\5\2\2\u08e8\u00b7\3\2\2\2\u08e9\u08f7\5")
        buf.write("\u00fe\u0080\2\u08ea\u08eb\5\u0104\u0083\2\u08eb\u08ec")
        buf.write("\7\4\2\2\u08ec\u08f1\5\u00ba^\2\u08ed\u08ee\7\6\2\2\u08ee")
        buf.write("\u08f0\5\u00ba^\2\u08ef\u08ed\3\2\2\2\u08f0\u08f3\3\2")
        buf.write("\2\2\u08f1\u08ef\3\2\2\2\u08f1\u08f2\3\2\2\2\u08f2\u08f4")
        buf.write("\3\2\2\2\u08f3\u08f1\3\2\2\2\u08f4\u08f5\7\5\2\2\u08f5")
        buf.write("\u08f7\3\2\2\2\u08f6\u08e9\3\2\2\2\u08f6\u08ea\3\2\2\2")
        buf.write("\u08f7\u00b9\3\2\2\2\u08f8\u08fb\5\u00fe\u0080\2\u08f9")
        buf.write("\u08fb\5\u00c6d\2\u08fa\u08f8\3\2\2\2\u08fa\u08f9\3\2")
        buf.write("\2\2\u08fb\u00bb\3\2\2\2\u08fc\u08fd\5\u00be`\2\u08fd")
        buf.write("\u00bd\3\2\2\2\u08fe\u08ff\b`\1\2\u08ff\u0900\7\u009b")
        buf.write("\2\2\u0900\u090b\5\u00be`\7\u0901\u0902\7U\2\2\u0902\u0903")
        buf.write("\7\4\2\2\u0903\u0904\5 \21\2\u0904\u0905\7\5\2\2\u0905")
        buf.write("\u090b\3\2\2\2\u0906\u0908\5\u00c2b\2\u0907\u0909\5\u00c0")
        buf.write("a\2\u0908\u0907\3\2\2\2\u0908\u0909\3\2\2\2\u0909\u090b")
        buf.write("\3\2\2\2\u090a\u08fe\3\2\2\2\u090a\u0901\3\2\2\2\u090a")
        buf.write("\u0906\3\2\2\2\u090b\u0914\3\2\2\2\u090c\u090d\f\4\2\2")
        buf.write("\u090d\u090e\7\23\2\2\u090e\u0913\5\u00be`\5\u090f\u0910")
        buf.write("\f\3\2\2\u0910\u0911\7\u00a3\2\2\u0911\u0913\5\u00be`")
        buf.write("\4\u0912\u090c\3\2\2\2\u0912\u090f\3\2\2\2\u0913\u0916")
        buf.write("\3\2\2\2\u0914\u0912\3\2\2\2\u0914\u0915\3\2\2\2\u0915")
        buf.write("\u00bf\3\2\2\2\u0916\u0914\3\2\2\2\u0917\u0919\7\u009b")
        buf.write("\2\2\u0918\u0917\3\2\2\2\u0918\u0919\3\2\2\2\u0919\u091a")
        buf.write("\3\2\2\2\u091a\u091b\7\34\2\2\u091b\u091c\5\u00c2b\2\u091c")
        buf.write("\u091d\7\23\2\2\u091d\u091e\5\u00c2b\2\u091e\u096a\3\2")
        buf.write("\2\2\u091f\u0921\7\u009b\2\2\u0920\u091f\3\2\2\2\u0920")
        buf.write("\u0921\3\2\2\2\u0921\u0922\3\2\2\2\u0922\u0923\7s\2\2")
        buf.write("\u0923\u0924\7\4\2\2\u0924\u0929\5\u00bc_\2\u0925\u0926")
        buf.write("\7\6\2\2\u0926\u0928\5\u00bc_\2\u0927\u0925\3\2\2\2\u0928")
        buf.write("\u092b\3\2\2\2\u0929\u0927\3\2\2\2\u0929\u092a\3\2\2\2")
        buf.write("\u092a\u092c\3\2\2\2\u092b\u0929\3\2\2\2\u092c\u092d\7")
        buf.write("\5\2\2\u092d\u096a\3\2\2\2\u092e\u0930\7\u009b\2\2\u092f")
        buf.write("\u092e\3\2\2\2\u092f\u0930\3\2\2\2\u0930\u0931\3\2\2\2")
        buf.write("\u0931\u0932\7s\2\2\u0932\u0933\7\4\2\2\u0933\u0934\5")
        buf.write(" \21\2\u0934\u0935\7\5\2\2\u0935\u096a\3\2\2\2\u0936\u0938")
        buf.write("\7\u009b\2\2\u0937\u0936\3\2\2\2\u0937\u0938\3\2\2\2\u0938")
        buf.write("\u0939\3\2\2\2\u0939\u093a\7\u00c7\2\2\u093a\u096a\5\u00c2")
        buf.write("b\2\u093b\u093d\7\u009b\2\2\u093c\u093b\3\2\2\2\u093c")
        buf.write("\u093d\3\2\2\2\u093d\u093e\3\2\2\2\u093e\u093f\7\u0086")
        buf.write("\2\2\u093f\u094d\t\25\2\2\u0940\u0941\7\4\2\2\u0941\u094e")
        buf.write("\7\5\2\2\u0942\u0943\7\4\2\2\u0943\u0948\5\u00bc_\2\u0944")
        buf.write("\u0945\7\6\2\2\u0945\u0947\5\u00bc_\2\u0946\u0944\3\2")
        buf.write("\2\2\u0947\u094a\3\2\2\2\u0948\u0946\3\2\2\2\u0948\u0949")
        buf.write("\3\2\2\2\u0949\u094b\3\2\2\2\u094a\u0948\3\2\2\2\u094b")
        buf.write("\u094c\7\5\2\2\u094c\u094e\3\2\2\2\u094d\u0940\3\2\2\2")
        buf.write("\u094d\u0942\3\2\2\2\u094e\u096a\3\2\2\2\u094f\u0951\7")
        buf.write("\u009b\2\2\u0950\u094f\3\2\2\2\u0950\u0951\3\2\2\2\u0951")
        buf.write("\u0952\3\2\2\2\u0952\u0953\7\u0086\2\2\u0953\u0956\5\u00c2")
        buf.write("b\2\u0954\u0955\7Q\2\2\u0955\u0957\7\u011d\2\2\u0956\u0954")
        buf.write("\3\2\2\2\u0956\u0957\3\2\2\2\u0957\u096a\3\2\2\2\u0958")
        buf.write("\u095a\7}\2\2\u0959\u095b\7\u009b\2\2\u095a\u0959\3\2")
        buf.write("\2\2\u095a\u095b\3\2\2\2\u095b\u095c\3\2\2\2\u095c\u096a")
        buf.write("\7\u009c\2\2\u095d\u095f\7}\2\2\u095e\u0960\7\u009b\2")
        buf.write("\2\u095f\u095e\3\2\2\2\u095f\u0960\3\2\2\2\u0960\u0961")
        buf.write("\3\2\2\2\u0961\u096a\t\26\2\2\u0962\u0964\7}\2\2\u0963")
        buf.write("\u0965\7\u009b\2\2\u0964\u0963\3\2\2\2\u0964\u0965\3\2")
        buf.write("\2\2\u0965\u0966\3\2\2\2\u0966\u0967\7L\2\2\u0967\u0968")
        buf.write("\7f\2\2\u0968\u096a\5\u00c2b\2\u0969\u0918\3\2\2\2\u0969")
        buf.write("\u0920\3\2\2\2\u0969\u092f\3\2\2\2\u0969\u0937\3\2\2\2")
        buf.write("\u0969\u093c\3\2\2\2\u0969\u0950\3\2\2\2\u0969\u0958\3")
        buf.write("\2\2\2\u0969\u095d\3\2\2\2\u0969\u0962\3\2\2\2\u096a\u00c1")
        buf.write("\3\2\2\2\u096b\u096c\bb\1\2\u096c\u0970\5\u00c4c\2\u096d")
        buf.write("\u096e\t\27\2\2\u096e\u0970\5\u00c2b\t\u096f\u096b\3\2")
        buf.write("\2\2\u096f\u096d\3\2\2\2\u0970\u0986\3\2\2\2\u0971\u0972")
        buf.write("\f\b\2\2\u0972\u0973\t\30\2\2\u0973\u0985\5\u00c2b\t\u0974")
        buf.write("\u0975\f\7\2\2\u0975\u0976\t\31\2\2\u0976\u0985\5\u00c2")
        buf.write("b\b\u0977\u0978\f\6\2\2\u0978\u0979\7\u0119\2\2\u0979")
        buf.write("\u0985\5\u00c2b\7\u097a\u097b\f\5\2\2\u097b\u097c\7\u011c")
        buf.write("\2\2\u097c\u0985\5\u00c2b\6\u097d\u097e\f\4\2\2\u097e")
        buf.write("\u097f\7\u011a\2\2\u097f\u0985\5\u00c2b\5\u0980\u0981")
        buf.write("\f\3\2\2\u0981\u0982\5\u00c8e\2\u0982\u0983\5\u00c2b\4")
        buf.write("\u0983\u0985\3\2\2\2\u0984\u0971\3\2\2\2\u0984\u0974\3")
        buf.write("\2\2\2\u0984\u0977\3\2\2\2\u0984\u097a\3\2\2\2\u0984\u097d")
        buf.write("\3\2\2\2\u0984\u0980\3\2\2\2\u0985\u0988\3\2\2\2\u0986")
        buf.write("\u0984\3\2\2\2\u0986\u0987\3\2\2\2\u0987\u00c3\3\2\2\2")
        buf.write("\u0988\u0986\3\2\2\2\u0989\u098a\bc\1\2\u098a\u0a42\t")
        buf.write("\32\2\2\u098b\u098d\7#\2\2\u098c\u098e\5\u00eex\2\u098d")
        buf.write("\u098c\3\2\2\2\u098e\u098f\3\2\2\2\u098f\u098d\3\2\2\2")
        buf.write("\u098f\u0990\3\2\2\2\u0990\u0993\3\2\2\2\u0991\u0992\7")
        buf.write("O\2\2\u0992\u0994\5\u00bc_\2\u0993\u0991\3\2\2\2\u0993")
        buf.write("\u0994\3\2\2\2\u0994\u0995\3\2\2\2\u0995\u0996\7P\2\2")
        buf.write("\u0996\u0a42\3\2\2\2\u0997\u0998\7#\2\2\u0998\u099a\5")
        buf.write("\u00bc_\2\u0999\u099b\5\u00eex\2\u099a\u0999\3\2\2\2\u099b")
        buf.write("\u099c\3\2\2\2\u099c\u099a\3\2\2\2\u099c\u099d\3\2\2\2")
        buf.write("\u099d\u09a0\3\2\2\2\u099e\u099f\7O\2\2\u099f\u09a1\5")
        buf.write("\u00bc_\2\u09a0\u099e\3\2\2\2\u09a0\u09a1\3\2\2\2\u09a1")
        buf.write("\u09a2\3\2\2\2\u09a2\u09a3\7P\2\2\u09a3\u0a42\3\2\2\2")
        buf.write("\u09a4\u09a5\7$\2\2\u09a5\u09a6\7\4\2\2\u09a6\u09a7\5")
        buf.write("\u00bc_\2\u09a7\u09a8\7\30\2\2\u09a8\u09a9\5\u00e0q\2")
        buf.write("\u09a9\u09aa\7\5\2\2\u09aa\u0a42\3\2\2\2\u09ab\u09ac\7")
        buf.write("\u00e2\2\2\u09ac\u09b5\7\4\2\2\u09ad\u09b2\5\u00b2Z\2")
        buf.write("\u09ae\u09af\7\6\2\2\u09af\u09b1\5\u00b2Z\2\u09b0\u09ae")
        buf.write("\3\2\2\2\u09b1\u09b4\3\2\2\2\u09b2\u09b0\3\2\2\2\u09b2")
        buf.write("\u09b3\3\2\2\2\u09b3\u09b6\3\2\2\2\u09b4\u09b2\3\2\2\2")
        buf.write("\u09b5\u09ad\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09b7\3")
        buf.write("\2\2\2\u09b7\u0a42\7\5\2\2\u09b8\u09b9\7`\2\2\u09b9\u09ba")
        buf.write("\7\4\2\2\u09ba\u09bd\5\u00bc_\2\u09bb\u09bc\7q\2\2\u09bc")
        buf.write("\u09be\7\u009d\2\2\u09bd\u09bb\3\2\2\2\u09bd\u09be\3\2")
        buf.write("\2\2\u09be\u09bf\3\2\2\2\u09bf\u09c0\7\5\2\2\u09c0\u0a42")
        buf.write("\3\2\2\2\u09c1\u09c2\7\u0081\2\2\u09c2\u09c3\7\4\2\2\u09c3")
        buf.write("\u09c6\5\u00bc_\2\u09c4\u09c5\7q\2\2\u09c5\u09c7\7\u009d")
        buf.write("\2\2\u09c6\u09c4\3\2\2\2\u09c6\u09c7\3\2\2\2\u09c7\u09c8")
        buf.write("\3\2\2\2\u09c8\u09c9\7\5\2\2\u09c9\u0a42\3\2\2\2\u09ca")
        buf.write("\u09cb\7\u00b2\2\2\u09cb\u09cc\7\4\2\2\u09cc\u09cd\5\u00c2")
        buf.write("b\2\u09cd\u09ce\7s\2\2\u09ce\u09cf\5\u00c2b\2\u09cf\u09d0")
        buf.write("\7\5\2\2\u09d0\u0a42\3\2\2\2\u09d1\u0a42\5\u00c6d\2\u09d2")
        buf.write("\u0a42\7\u0114\2\2\u09d3\u09d4\5\u00fe\u0080\2\u09d4\u09d5")
        buf.write("\7\7\2\2\u09d5\u09d6\7\u0114\2\2\u09d6\u0a42\3\2\2\2\u09d7")
        buf.write("\u09d8\7\4\2\2\u09d8\u09db\5\u00b2Z\2\u09d9\u09da\7\6")
        buf.write("\2\2\u09da\u09dc\5\u00b2Z\2\u09db\u09d9\3\2\2\2\u09dc")
        buf.write("\u09dd\3\2\2\2\u09dd\u09db\3\2\2\2\u09dd\u09de\3\2\2\2")
        buf.write("\u09de\u09df\3\2\2\2\u09df\u09e0\7\5\2\2\u09e0\u0a42\3")
        buf.write("\2\2\2\u09e1\u09e2\7\4\2\2\u09e2\u09e3\5 \21\2\u09e3\u09e4")
        buf.write("\7\5\2\2\u09e4\u0a42\3\2\2\2\u09e5\u09e6\5\u00fc\177\2")
        buf.write("\u09e6\u09f2\7\4\2\2\u09e7\u09e9\5\u0086D\2\u09e8\u09e7")
        buf.write("\3\2\2\2\u09e8\u09e9\3\2\2\2\u09e9\u09ea\3\2\2\2\u09ea")
        buf.write("\u09ef\5\u00bc_\2\u09eb\u09ec\7\6\2\2\u09ec\u09ee\5\u00bc")
        buf.write("_\2\u09ed\u09eb\3\2\2\2\u09ee\u09f1\3\2\2\2\u09ef\u09ed")
        buf.write("\3\2\2\2\u09ef\u09f0\3\2\2\2\u09f0\u09f3\3\2\2\2\u09f1")
        buf.write("\u09ef\3\2\2\2\u09f2\u09e8\3\2\2\2\u09f2\u09f3\3\2\2\2")
        buf.write("\u09f3\u09f4\3\2\2\2\u09f4\u09fb\7\5\2\2\u09f5\u09f6\7")
        buf.write("^\2\2\u09f6\u09f7\7\4\2\2\u09f7\u09f8\7\u0106\2\2\u09f8")
        buf.write("\u09f9\5\u00be`\2\u09f9\u09fa\7\5\2\2\u09fa\u09fc\3\2")
        buf.write("\2\2\u09fb\u09f5\3\2\2\2\u09fb\u09fc\3\2\2\2\u09fc\u09ff")
        buf.write("\3\2\2\2\u09fd\u09fe\7\u00a8\2\2\u09fe\u0a00\5\u00f4{")
        buf.write("\2\u09ff\u09fd\3\2\2\2\u09ff\u0a00\3\2\2\2\u0a00\u0a42")
        buf.write("\3\2\2\2\u0a01\u0a02\5\u0104\u0083\2\u0a02\u0a03\7\n\2")
        buf.write("\2\u0a03\u0a04\5\u00bc_\2\u0a04\u0a42\3\2\2\2\u0a05\u0a06")
        buf.write("\7\4\2\2\u0a06\u0a09\5\u0104\u0083\2\u0a07\u0a08\7\6\2")
        buf.write("\2\u0a08\u0a0a\5\u0104\u0083\2\u0a09\u0a07\3\2\2\2\u0a0a")
        buf.write("\u0a0b\3\2\2\2\u0a0b\u0a09\3\2\2\2\u0a0b\u0a0c\3\2\2\2")
        buf.write("\u0a0c\u0a0d\3\2\2\2\u0a0d\u0a0e\7\5\2\2\u0a0e\u0a0f\7")
        buf.write("\n\2\2\u0a0f\u0a10\5\u00bc_\2\u0a10\u0a42\3\2\2\2\u0a11")
        buf.write("\u0a42\5\u0104\u0083\2\u0a12\u0a13\7\4\2\2\u0a13\u0a14")
        buf.write("\5\u00bc_\2\u0a14\u0a15\7\5\2\2\u0a15\u0a42\3\2\2\2\u0a16")
        buf.write("\u0a17\7Z\2\2\u0a17\u0a18\7\4\2\2\u0a18\u0a19\5\u0104")
        buf.write("\u0083\2\u0a19\u0a1a\7f\2\2\u0a1a\u0a1b\5\u00c2b\2\u0a1b")
        buf.write("\u0a1c\7\5\2\2\u0a1c\u0a42\3\2\2\2\u0a1d\u0a1e\t\33\2")
        buf.write("\2\u0a1e\u0a1f\7\4\2\2\u0a1f\u0a20\5\u00c2b\2\u0a20\u0a21")
        buf.write("\t\34\2\2\u0a21\u0a24\5\u00c2b\2\u0a22\u0a23\t\35\2\2")
        buf.write("\u0a23\u0a25\5\u00c2b\2\u0a24\u0a22\3\2\2\2\u0a24\u0a25")
        buf.write("\3\2\2\2\u0a25\u0a26\3\2\2\2\u0a26\u0a27\7\5\2\2\u0a27")
        buf.write("\u0a42\3\2\2\2\u0a28\u0a29\7\u00f2\2\2\u0a29\u0a2b\7\4")
        buf.write("\2\2\u0a2a\u0a2c\t\36\2\2\u0a2b\u0a2a\3\2\2\2\u0a2b\u0a2c")
        buf.write("\3\2\2\2\u0a2c\u0a2e\3\2\2\2\u0a2d\u0a2f\5\u00c2b\2\u0a2e")
        buf.write("\u0a2d\3\2\2\2\u0a2e\u0a2f\3\2\2\2\u0a2f\u0a30\3\2\2\2")
        buf.write("\u0a30\u0a31\7f\2\2\u0a31\u0a32\5\u00c2b\2\u0a32\u0a33")
        buf.write("\7\5\2\2\u0a33\u0a42\3\2\2\2\u0a34\u0a35\7\u00aa\2\2\u0a35")
        buf.write("\u0a36\7\4\2\2\u0a36\u0a37\5\u00c2b\2\u0a37\u0a38\7\u00b1")
        buf.write("\2\2\u0a38\u0a39\5\u00c2b\2\u0a39\u0a3a\7f\2\2\u0a3a\u0a3d")
        buf.write("\5\u00c2b\2\u0a3b\u0a3c\7b\2\2\u0a3c\u0a3e\5\u00c2b\2")
        buf.write("\u0a3d\u0a3b\3\2\2\2\u0a3d\u0a3e\3\2\2\2\u0a3e\u0a3f\3")
        buf.write("\2\2\2\u0a3f\u0a40\7\5\2\2\u0a40\u0a42\3\2\2\2\u0a41\u0989")
        buf.write("\3\2\2\2\u0a41\u098b\3\2\2\2\u0a41\u0997\3\2\2\2\u0a41")
        buf.write("\u09a4\3\2\2\2\u0a41\u09ab\3\2\2\2\u0a41\u09b8\3\2\2\2")
        buf.write("\u0a41\u09c1\3\2\2\2\u0a41\u09ca\3\2\2\2\u0a41\u09d1\3")
        buf.write("\2\2\2\u0a41\u09d2\3\2\2\2\u0a41\u09d3\3\2\2\2\u0a41\u09d7")
        buf.write("\3\2\2\2\u0a41\u09e1\3\2\2\2\u0a41\u09e5\3\2\2\2\u0a41")
        buf.write("\u0a01\3\2\2\2\u0a41\u0a05\3\2\2\2\u0a41\u0a11\3\2\2\2")
        buf.write("\u0a41\u0a12\3\2\2\2\u0a41\u0a16\3\2\2\2\u0a41\u0a1d\3")
        buf.write("\2\2\2\u0a41\u0a28\3\2\2\2\u0a41\u0a34\3\2\2\2\u0a42\u0a4d")
        buf.write("\3\2\2\2\u0a43\u0a44\f\n\2\2\u0a44\u0a45\7\13\2\2\u0a45")
        buf.write("\u0a46\5\u00c2b\2\u0a46\u0a47\7\f\2\2\u0a47\u0a4c\3\2")
        buf.write("\2\2\u0a48\u0a49\f\b\2\2\u0a49\u0a4a\7\7\2\2\u0a4a\u0a4c")
        buf.write("\5\u0104\u0083\2\u0a4b\u0a43\3\2\2\2\u0a4b\u0a48\3\2\2")
        buf.write("\2\u0a4c\u0a4f\3\2\2\2\u0a4d\u0a4b\3\2\2\2\u0a4d\u0a4e")
        buf.write("\3\2\2\2\u0a4e\u00c5\3\2\2\2\u0a4f\u0a4d\3\2\2\2\u0a50")
        buf.write("\u0a5d\7\u009c\2\2\u0a51\u0a5d\5\u00d0i\2\u0a52\u0a53")
        buf.write("\5\u0104\u0083\2\u0a53\u0a54\7\u011d\2\2\u0a54\u0a5d\3")
        buf.write("\2\2\2\u0a55\u0a5d\5\u010a\u0086\2\u0a56\u0a5d\5\u00ce")
        buf.write("h\2\u0a57\u0a59\7\u011d\2\2\u0a58\u0a57\3\2\2\2\u0a59")
        buf.write("\u0a5a\3\2\2\2\u0a5a\u0a58\3\2\2\2\u0a5a\u0a5b\3\2\2\2")
        buf.write("\u0a5b\u0a5d\3\2\2\2\u0a5c\u0a50\3\2\2\2\u0a5c\u0a51\3")
        buf.write("\2\2\2\u0a5c\u0a52\3\2\2\2\u0a5c\u0a55\3\2\2\2\u0a5c\u0a56")
        buf.write("\3\2\2\2\u0a5c\u0a58\3\2\2\2\u0a5d\u00c7\3\2\2\2\u0a5e")
        buf.write("\u0a5f\t\37\2\2\u0a5f\u00c9\3\2\2\2\u0a60\u0a61\t \2\2")
        buf.write("\u0a61\u00cb\3\2\2\2\u0a62\u0a63\t!\2\2\u0a63\u00cd\3")
        buf.write("\2\2\2\u0a64\u0a65\t\"\2\2\u0a65\u00cf\3\2\2\2\u0a66\u0a69")
        buf.write("\7{\2\2\u0a67\u0a6a\5\u00d2j\2\u0a68\u0a6a\5\u00d6l\2")
        buf.write("\u0a69\u0a67\3\2\2\2\u0a69\u0a68\3\2\2\2\u0a69\u0a6a\3")
        buf.write("\2\2\2\u0a6a\u00d1\3\2\2\2\u0a6b\u0a6d\5\u00d4k\2\u0a6c")
        buf.write("\u0a6e\5\u00d8m\2\u0a6d\u0a6c\3\2\2\2\u0a6d\u0a6e\3\2")
        buf.write("\2\2\u0a6e\u00d3\3\2\2\2\u0a6f\u0a70\5\u00dan\2\u0a70")
        buf.write("\u0a71\5\u00dco\2\u0a71\u0a73\3\2\2\2\u0a72\u0a6f\3\2")
        buf.write("\2\2\u0a73\u0a74\3\2\2\2\u0a74\u0a72\3\2\2\2\u0a74\u0a75")
        buf.write("\3\2\2\2\u0a75\u00d5\3\2\2\2\u0a76\u0a79\5\u00d8m\2\u0a77")
        buf.write("\u0a7a\5\u00d4k\2\u0a78\u0a7a\5\u00d8m\2\u0a79\u0a77\3")
        buf.write("\2\2\2\u0a79\u0a78\3\2\2\2\u0a79\u0a7a\3\2\2\2\u0a7a\u00d7")
        buf.write("\3\2\2\2\u0a7b\u0a7c\5\u00dan\2\u0a7c\u0a7d\5\u00dco\2")
        buf.write("\u0a7d\u0a7e\7\u00ec\2\2\u0a7e\u0a7f\5\u00dco\2\u0a7f")
        buf.write("\u00d9\3\2\2\2\u0a80\u0a82\t#\2\2\u0a81\u0a80\3\2\2\2")
        buf.write("\u0a81\u0a82\3\2\2\2\u0a82\u0a83\3\2\2\2\u0a83\u0a86\t")
        buf.write("\24\2\2\u0a84\u0a86\7\u011d\2\2\u0a85\u0a81\3\2\2\2\u0a85")
        buf.write("\u0a84\3\2\2\2\u0a86\u00db\3\2\2\2\u0a87\u0a8f\7B\2\2")
        buf.write("\u0a88\u0a8f\7o\2\2\u0a89\u0a8f\7\u0094\2\2\u0a8a\u0a8f")
        buf.write("\7\u0095\2\2\u0a8b\u0a8f\7\u00cf\2\2\u0a8c\u0a8f\7\u0109")
        buf.write("\2\2\u0a8d\u0a8f\5\u0104\u0083\2\u0a8e\u0a87\3\2\2\2\u0a8e")
        buf.write("\u0a88\3\2\2\2\u0a8e\u0a89\3\2\2\2\u0a8e\u0a8a\3\2\2\2")
        buf.write("\u0a8e\u0a8b\3\2\2\2\u0a8e\u0a8c\3\2\2\2\u0a8e\u0a8d\3")
        buf.write("\2\2\2\u0a8f\u00dd\3\2\2\2\u0a90\u0a94\7`\2\2\u0a91\u0a92")
        buf.write("\7\17\2\2\u0a92\u0a94\5\u0100\u0081\2\u0a93\u0a90\3\2")
        buf.write("\2\2\u0a93\u0a91\3\2\2\2\u0a94\u00df\3\2\2\2\u0a95\u0a96")
        buf.write("\7\27\2\2\u0a96\u0a97\7\u010e\2\2\u0a97\u0a98\5\u00e0")
        buf.write("q\2\u0a98\u0a99\7\u0110\2\2\u0a99\u0ab8\3\2\2\2\u0a9a")
        buf.write("\u0a9b\7\u0091\2\2\u0a9b\u0a9c\7\u010e\2\2\u0a9c\u0a9d")
        buf.write("\5\u00e0q\2\u0a9d\u0a9e\7\6\2\2\u0a9e\u0a9f\5\u00e0q\2")
        buf.write("\u0a9f\u0aa0\7\u0110\2\2\u0aa0\u0ab8\3\2\2\2\u0aa1\u0aa8")
        buf.write("\7\u00e2\2\2\u0aa2\u0aa4\7\u010e\2\2\u0aa3\u0aa5\5\u00ea")
        buf.write("v\2\u0aa4\u0aa3\3\2\2\2\u0aa4\u0aa5\3\2\2\2\u0aa5\u0aa6")
        buf.write("\3\2\2\2\u0aa6\u0aa9\7\u0110\2\2\u0aa7\u0aa9\7\u010c\2")
        buf.write("\2\u0aa8\u0aa2\3\2\2\2\u0aa8\u0aa7\3\2\2\2\u0aa9\u0ab8")
        buf.write("\3\2\2\2\u0aaa\u0ab5\5\u0104\u0083\2\u0aab\u0aac\7\4\2")
        buf.write("\2\u0aac\u0ab1\7\u0121\2\2\u0aad\u0aae\7\6\2\2\u0aae\u0ab0")
        buf.write("\7\u0121\2\2\u0aaf\u0aad\3\2\2\2\u0ab0\u0ab3\3\2\2\2\u0ab1")
        buf.write("\u0aaf\3\2\2\2\u0ab1\u0ab2\3\2\2\2\u0ab2\u0ab4\3\2\2\2")
        buf.write("\u0ab3\u0ab1\3\2\2\2\u0ab4\u0ab6\7\5\2\2\u0ab5\u0aab\3")
        buf.write("\2\2\2\u0ab5\u0ab6\3\2\2\2\u0ab6\u0ab8\3\2\2\2\u0ab7\u0a95")
        buf.write("\3\2\2\2\u0ab7\u0a9a\3\2\2\2\u0ab7\u0aa1\3\2\2\2\u0ab7")
        buf.write("\u0aaa\3\2\2\2\u0ab8\u00e1\3\2\2\2\u0ab9\u0abe\5\u00e4")
        buf.write("s\2\u0aba\u0abb\7\6\2\2\u0abb\u0abd\5\u00e4s\2\u0abc\u0aba")
        buf.write("\3\2\2\2\u0abd\u0ac0\3\2\2\2\u0abe\u0abc\3\2\2\2\u0abe")
        buf.write("\u0abf\3\2\2\2\u0abf\u00e3\3\2\2\2\u0ac0\u0abe\3\2\2\2")
        buf.write("\u0ac1\u0ac2\5\u00acW\2\u0ac2\u0ac5\5\u00e0q\2\u0ac3\u0ac4")
        buf.write("\7\u009b\2\2\u0ac4\u0ac6\7\u009c\2\2\u0ac5\u0ac3\3\2\2")
        buf.write("\2\u0ac5\u0ac6\3\2\2\2\u0ac6\u0ac8\3\2\2\2\u0ac7\u0ac9")
        buf.write("\5\36\20\2\u0ac8\u0ac7\3\2\2\2\u0ac8\u0ac9\3\2\2\2\u0ac9")
        buf.write("\u0acb\3\2\2\2\u0aca\u0acc\5\u00dep\2\u0acb\u0aca\3\2")
        buf.write("\2\2\u0acb\u0acc\3\2\2\2\u0acc\u00e5\3\2\2\2\u0acd\u0ad2")
        buf.write("\5\u00e8u\2\u0ace\u0acf\7\6\2\2\u0acf\u0ad1\5\u00e8u\2")
        buf.write("\u0ad0\u0ace\3\2\2\2\u0ad1\u0ad4\3\2\2\2\u0ad2\u0ad0\3")
        buf.write("\2\2\2\u0ad2\u0ad3\3\2\2\2\u0ad3\u00e7\3\2\2\2\u0ad4\u0ad2")
        buf.write("\3\2\2\2\u0ad5\u0ad6\5\u0100\u0081\2\u0ad6\u0ad9\5\u00e0")
        buf.write("q\2\u0ad7\u0ad8\7\u009b\2\2\u0ad8\u0ada\7\u009c\2\2\u0ad9")
        buf.write("\u0ad7\3\2\2\2\u0ad9\u0ada\3\2\2\2\u0ada\u0adc\3\2\2\2")
        buf.write("\u0adb\u0add\5\36\20\2\u0adc\u0adb\3\2\2\2\u0adc\u0add")
        buf.write("\3\2\2\2\u0add\u00e9\3\2\2\2\u0ade\u0ae3\5\u00ecw\2\u0adf")
        buf.write("\u0ae0\7\6\2\2\u0ae0\u0ae2\5\u00ecw\2\u0ae1\u0adf\3\2")
        buf.write("\2\2\u0ae2\u0ae5\3\2\2\2\u0ae3\u0ae1\3\2\2\2\u0ae3\u0ae4")
        buf.write("\3\2\2\2\u0ae4\u00eb\3\2\2\2\u0ae5\u0ae3\3\2\2\2\u0ae6")
        buf.write("\u0ae7\5\u0104\u0083\2\u0ae7\u0ae8\7\r\2\2\u0ae8\u0aeb")
        buf.write("\5\u00e0q\2\u0ae9\u0aea\7\u009b\2\2\u0aea\u0aec\7\u009c")
        buf.write("\2\2\u0aeb\u0ae9\3\2\2\2\u0aeb\u0aec\3\2\2\2\u0aec\u0aee")
        buf.write("\3\2\2\2\u0aed\u0aef\5\36\20\2\u0aee\u0aed\3\2\2\2\u0aee")
        buf.write("\u0aef\3\2\2\2\u0aef\u00ed\3\2\2\2\u0af0\u0af1\7\u0105")
        buf.write("\2\2\u0af1\u0af2\5\u00bc_\2\u0af2\u0af3\7\u00eb\2\2\u0af3")
        buf.write("\u0af4\5\u00bc_\2\u0af4\u00ef\3\2\2\2\u0af5\u0af6\7\u0107")
        buf.write("\2\2\u0af6\u0afb\5\u00f2z\2\u0af7\u0af8\7\6\2\2\u0af8")
        buf.write("\u0afa\5\u00f2z\2\u0af9\u0af7\3\2\2\2\u0afa\u0afd\3\2")
        buf.write("\2\2\u0afb\u0af9\3\2\2\2\u0afb\u0afc\3\2\2\2\u0afc\u00f1")
        buf.write("\3\2\2\2\u0afd\u0afb\3\2\2\2\u0afe\u0aff\5\u0100\u0081")
        buf.write("\2\u0aff\u0b00\7\30\2\2\u0b00\u0b01\5\u00f4{\2\u0b01\u00f3")
        buf.write("\3\2\2\2\u0b02\u0b31\5\u0100\u0081\2\u0b03\u0b04\7\4\2")
        buf.write("\2\u0b04\u0b05\5\u0100\u0081\2\u0b05\u0b06\7\5\2\2\u0b06")
        buf.write("\u0b31\3\2\2\2\u0b07\u0b2a\7\4\2\2\u0b08\u0b09\7(\2\2")
        buf.write("\u0b09\u0b0a\7 \2\2\u0b0a\u0b0f\5\u00bc_\2\u0b0b\u0b0c")
        buf.write("\7\6\2\2\u0b0c\u0b0e\5\u00bc_\2\u0b0d\u0b0b\3\2\2\2\u0b0e")
        buf.write("\u0b11\3\2\2\2\u0b0f\u0b0d\3\2\2\2\u0b0f\u0b10\3\2\2\2")
        buf.write("\u0b10\u0b2b\3\2\2\2\u0b11\u0b0f\3\2\2\2\u0b12\u0b13\t")
        buf.write("$\2\2\u0b13\u0b14\7 \2\2\u0b14\u0b19\5\u00bc_\2\u0b15")
        buf.write("\u0b16\7\6\2\2\u0b16\u0b18\5\u00bc_\2\u0b17\u0b15\3\2")
        buf.write("\2\2\u0b18\u0b1b\3\2\2\2\u0b19\u0b17\3\2\2\2\u0b19\u0b1a")
        buf.write("\3\2\2\2\u0b1a\u0b1d\3\2\2\2\u0b1b\u0b19\3\2\2\2\u0b1c")
        buf.write("\u0b12\3\2\2\2\u0b1c\u0b1d\3\2\2\2\u0b1d\u0b28\3\2\2\2")
        buf.write("\u0b1e\u0b1f\t%\2\2\u0b1f\u0b20\7 \2\2\u0b20\u0b25\5V")
        buf.write(",\2\u0b21\u0b22\7\6\2\2\u0b22\u0b24\5V,\2\u0b23\u0b21")
        buf.write("\3\2\2\2\u0b24\u0b27\3\2\2\2\u0b25\u0b23\3\2\2\2\u0b25")
        buf.write("\u0b26\3\2\2\2\u0b26\u0b29\3\2\2\2\u0b27\u0b25\3\2\2\2")
        buf.write("\u0b28\u0b1e\3\2\2\2\u0b28\u0b29\3\2\2\2\u0b29\u0b2b\3")
        buf.write("\2\2\2\u0b2a\u0b08\3\2\2\2\u0b2a\u0b1c\3\2\2\2\u0b2b\u0b2d")
        buf.write("\3\2\2\2\u0b2c\u0b2e\5\u00f6|\2\u0b2d\u0b2c\3\2\2\2\u0b2d")
        buf.write("\u0b2e\3\2\2\2\u0b2e\u0b2f\3\2\2\2\u0b2f\u0b31\7\5\2\2")
        buf.write("\u0b30\u0b02\3\2\2\2\u0b30\u0b03\3\2\2\2\u0b30\u0b07\3")
        buf.write("\2\2\2\u0b31\u00f5\3\2\2\2\u0b32\u0b33\7\u00b9\2\2\u0b33")
        buf.write("\u0b43\5\u00f8}\2\u0b34\u0b35\7\u00cd\2\2\u0b35\u0b43")
        buf.write("\5\u00f8}\2\u0b36\u0b37\7\u00b9\2\2\u0b37\u0b38\7\34\2")
        buf.write("\2\u0b38\u0b39\5\u00f8}\2\u0b39\u0b3a\7\23\2\2\u0b3a\u0b3b")
        buf.write("\5\u00f8}\2\u0b3b\u0b43\3\2\2\2\u0b3c\u0b3d\7\u00cd\2")
        buf.write("\2\u0b3d\u0b3e\7\34\2\2\u0b3e\u0b3f\5\u00f8}\2\u0b3f\u0b40")
        buf.write("\7\23\2\2\u0b40\u0b41\5\u00f8}\2\u0b41\u0b43\3\2\2\2\u0b42")
        buf.write("\u0b32\3\2\2\2\u0b42\u0b34\3\2\2\2\u0b42\u0b36\3\2\2\2")
        buf.write("\u0b42\u0b3c\3\2\2\2\u0b43\u00f7\3\2\2\2\u0b44\u0b45\7")
        buf.write("\u00f7\2\2\u0b45\u0b4c\t&\2\2\u0b46\u0b47\7:\2\2\u0b47")
        buf.write("\u0b4c\7\u00cc\2\2\u0b48\u0b49\5\u00bc_\2\u0b49\u0b4a")
        buf.write("\t&\2\2\u0b4a\u0b4c\3\2\2\2\u0b4b\u0b44\3\2\2\2\u0b4b")
        buf.write("\u0b46\3\2\2\2\u0b4b\u0b48\3\2\2\2\u0b4c\u00f9\3\2\2\2")
        buf.write("\u0b4d\u0b52\5\u00fe\u0080\2\u0b4e\u0b4f\7\6\2\2\u0b4f")
        buf.write("\u0b51\5\u00fe\u0080\2\u0b50\u0b4e\3\2\2\2\u0b51\u0b54")
        buf.write("\3\2\2\2\u0b52\u0b50\3\2\2\2\u0b52\u0b53\3\2\2\2\u0b53")
        buf.write("\u00fb\3\2\2\2\u0b54\u0b52\3\2\2\2\u0b55\u0b5a\5\u00fe")
        buf.write("\u0080\2\u0b56\u0b5a\7^\2\2\u0b57\u0b5a\7\u0085\2\2\u0b58")
        buf.write("\u0b5a\7\u00c6\2\2\u0b59\u0b55\3\2\2\2\u0b59\u0b56\3\2")
        buf.write("\2\2\u0b59\u0b57\3\2\2\2\u0b59\u0b58\3\2\2\2\u0b5a\u00fd")
        buf.write("\3\2\2\2\u0b5b\u0b60\5\u0104\u0083\2\u0b5c\u0b5d\7\7\2")
        buf.write("\2\u0b5d\u0b5f\5\u0104\u0083\2\u0b5e\u0b5c\3\2\2\2\u0b5f")
        buf.write("\u0b62\3\2\2\2\u0b60\u0b5e\3\2\2\2\u0b60\u0b61\3\2\2\2")
        buf.write("\u0b61\u00ff\3\2\2\2\u0b62\u0b60\3\2\2\2\u0b63\u0b64\5")
        buf.write("\u0104\u0083\2\u0b64\u0b65\5\u0102\u0082\2\u0b65\u0101")
        buf.write("\3\2\2\2\u0b66\u0b67\7\u0113\2\2\u0b67\u0b69\5\u0104\u0083")
        buf.write("\2\u0b68\u0b66\3\2\2\2\u0b69\u0b6a\3\2\2\2\u0b6a\u0b68")
        buf.write("\3\2\2\2\u0b6a\u0b6b\3\2\2\2\u0b6b\u0b6e\3\2\2\2\u0b6c")
        buf.write("\u0b6e\3\2\2\2\u0b6d\u0b68\3\2\2\2\u0b6d\u0b6c\3\2\2\2")
        buf.write("\u0b6e\u0103\3\2\2\2\u0b6f\u0b73\5\u0106\u0084\2\u0b70")
        buf.write("\u0b71\6\u0083\22\2\u0b71\u0b73\5\u0110\u0089\2\u0b72")
        buf.write("\u0b6f\3\2\2\2\u0b72\u0b70\3\2\2\2\u0b73\u0105\3\2\2\2")
        buf.write("\u0b74\u0b7b\7\u0126\2\2\u0b75\u0b7b\5\u0108\u0085\2\u0b76")
        buf.write("\u0b77\6\u0084\23\2\u0b77\u0b7b\5\u010e\u0088\2\u0b78")
        buf.write("\u0b79\6\u0084\24\2\u0b79\u0b7b\5\u0112\u008a\2\u0b7a")
        buf.write("\u0b74\3\2\2\2\u0b7a\u0b75\3\2\2\2\u0b7a\u0b76\3\2\2\2")
        buf.write("\u0b7a\u0b78\3\2\2\2\u0b7b\u0107\3\2\2\2\u0b7c\u0b7d\7")
        buf.write("\u0127\2\2\u0b7d\u0109\3\2\2\2\u0b7e\u0b80\6\u0086\25")
        buf.write("\2\u0b7f\u0b81\7\u0113\2\2\u0b80\u0b7f\3\2\2\2\u0b80\u0b81")
        buf.write("\3\2\2\2\u0b81\u0b82\3\2\2\2\u0b82\u0ba6\7\u0122\2\2\u0b83")
        buf.write("\u0b85\6\u0086\26\2\u0b84\u0b86\7\u0113\2\2\u0b85\u0b84")
        buf.write("\3\2\2\2\u0b85\u0b86\3\2\2\2\u0b86\u0b87\3\2\2\2\u0b87")
        buf.write("\u0ba6\7\u0123\2\2\u0b88\u0b8a\6\u0086\27\2\u0b89\u0b8b")
        buf.write("\7\u0113\2\2\u0b8a\u0b89\3\2\2\2\u0b8a\u0b8b\3\2\2\2\u0b8b")
        buf.write("\u0b8c\3\2\2\2\u0b8c\u0ba6\t\'\2\2\u0b8d\u0b8f\7\u0113")
        buf.write("\2\2\u0b8e\u0b8d\3\2\2\2\u0b8e\u0b8f\3\2\2\2\u0b8f\u0b90")
        buf.write("\3\2\2\2\u0b90\u0ba6\7\u0121\2\2\u0b91\u0b93\7\u0113\2")
        buf.write("\2\u0b92\u0b91\3\2\2\2\u0b92\u0b93\3\2\2\2\u0b93\u0b94")
        buf.write("\3\2\2\2\u0b94\u0ba6\7\u011e\2\2\u0b95\u0b97\7\u0113\2")
        buf.write("\2\u0b96\u0b95\3\2\2\2\u0b96\u0b97\3\2\2\2\u0b97\u0b98")
        buf.write("\3\2\2\2\u0b98\u0ba6\7\u011f\2\2\u0b99\u0b9b\7\u0113\2")
        buf.write("\2\u0b9a\u0b99\3\2\2\2\u0b9a\u0b9b\3\2\2\2\u0b9b\u0b9c")
        buf.write("\3\2\2\2\u0b9c\u0ba6\7\u0120\2\2\u0b9d\u0b9f\7\u0113\2")
        buf.write("\2\u0b9e\u0b9d\3\2\2\2\u0b9e\u0b9f\3\2\2\2\u0b9f\u0ba0")
        buf.write("\3\2\2\2\u0ba0\u0ba6\7\u0124\2\2\u0ba1\u0ba3\7\u0113\2")
        buf.write("\2\u0ba2\u0ba1\3\2\2\2\u0ba2\u0ba3\3\2\2\2\u0ba3\u0ba4")
        buf.write("\3\2\2\2\u0ba4\u0ba6\7\u0125\2\2\u0ba5\u0b7e\3\2\2\2\u0ba5")
        buf.write("\u0b83\3\2\2\2\u0ba5\u0b88\3\2\2\2\u0ba5\u0b8e\3\2\2\2")
        buf.write("\u0ba5\u0b92\3\2\2\2\u0ba5\u0b96\3\2\2\2\u0ba5\u0b9a\3")
        buf.write("\2\2\2\u0ba5\u0b9e\3\2\2\2\u0ba5\u0ba2\3\2\2\2\u0ba6\u010b")
        buf.write("\3\2\2\2\u0ba7\u0ba8\7\u00f5\2\2\u0ba8\u0baf\5\u00e0q")
        buf.write("\2\u0ba9\u0baf\5\36\20\2\u0baa\u0baf\5\u00dep\2\u0bab")
        buf.write("\u0bac\t(\2\2\u0bac\u0bad\7\u009b\2\2\u0bad\u0baf\7\u009c")
        buf.write("\2\2\u0bae\u0ba7\3\2\2\2\u0bae\u0ba9\3\2\2\2\u0bae\u0baa")
        buf.write("\3\2\2\2\u0bae\u0bab\3\2\2\2\u0baf\u010d\3\2\2\2\u0bb0")
        buf.write("\u0bb1\t)\2\2\u0bb1\u010f\3\2\2\2\u0bb2\u0bb3\t*\2\2\u0bb3")
        buf.write("\u0111\3\2\2\2\u0bb4\u0bb5\t+\2\2\u0bb5\u0113\3\2\2\2")
        buf.write("\u0188\u0118\u0131\u0136\u013e\u0146\u0148\u015c\u0160")
        buf.write("\u0166\u0169\u016c\u0173\u0178\u017b\u0182\u018e\u0197")
        buf.write("\u0199\u019d\u01a0\u01a7\u01b2\u01b4\u01bc\u01c1\u01c4")
        buf.write("\u01ca\u01d5\u0215\u021e\u0222\u0228\u022c\u0231\u0237")
        buf.write("\u0243\u024b\u0251\u025e\u0263\u0273\u027a\u027e\u0284")
        buf.write("\u0293\u0297\u029d\u02a3\u02a6\u02a9\u02af\u02b3\u02bb")
        buf.write("\u02bd\u02c6\u02c9\u02d2\u02d7\u02dd\u02e4\u02e7\u02ed")
        buf.write("\u02f8\u02fb\u02ff\u0304\u0309\u0310\u0313\u0316\u031d")
        buf.write("\u0322\u032b\u0333\u0339\u033c\u033f\u0345\u0349\u034d")
        buf.write("\u0351\u0353\u035b\u0363\u0369\u036f\u0372\u0376\u0379")
        buf.write("\u037d\u0396\u0399\u039d\u03a3\u03a6\u03a9\u03af\u03b7")
        buf.write("\u03bc\u03c2\u03c8\u03d4\u03d7\u03de\u03e5\u03ed\u03f0")
        buf.write("\u03f8\u03fc\u0403\u0477\u047f\u0487\u0490\u049a\u049e")
        buf.write("\u04a1\u04a7\u04ad\u04b9\u04c5\u04ca\u04d3\u04db\u04e2")
        buf.write("\u04e4\u04e9\u04ed\u04f2\u04f7\u04fc\u04ff\u0504\u0508")
        buf.write("\u050d\u050f\u0513\u051c\u0524\u052d\u0534\u053d\u0542")
        buf.write("\u0545\u0558\u055a\u0563\u056a\u056d\u0574\u0578\u057e")
        buf.write("\u0586\u0591\u059c\u05a3\u05a9\u05b6\u05bd\u05c4\u05d0")
        buf.write("\u05d8\u05de\u05e1\u05ea\u05ed\u05f6\u05f9\u0602\u0605")
        buf.write("\u060e\u0611\u0614\u0619\u061b\u0627\u062e\u0635\u0638")
        buf.write("\u063a\u0646\u064a\u064e\u0654\u0658\u0660\u0664\u0667")
        buf.write("\u066a\u066d\u0671\u0675\u0678\u067c\u0681\u0685\u0688")
        buf.write("\u068b\u068e\u0690\u069c\u069f\u06a3\u06ad\u06b1\u06b3")
        buf.write("\u06b6\u06ba\u06c0\u06c4\u06cf\u06d9\u06e5\u06f4\u06f9")
        buf.write("\u0700\u0710\u0715\u0722\u0727\u072f\u0735\u0739\u0742")
        buf.write("\u0751\u0756\u0762\u0767\u076f\u0772\u0776\u0784\u0791")
        buf.write("\u0796\u079a\u079d\u07a2\u07ab\u07ae\u07b3\u07ba\u07bd")
        buf.write("\u07c5\u07cc\u07d3\u07d6\u07db\u07de\u07e3\u07e7\u07ea")
        buf.write("\u07ed\u07f3\u07f8\u07fd\u080f\u0811\u0814\u081f\u0828")
        buf.write("\u082f\u0837\u083e\u0842\u084a\u0852\u0856\u085e\u086a")
        buf.write("\u086d\u0873\u0877\u0879\u0882\u088e\u0890\u0897\u089e")
        buf.write("\u08a4\u08aa\u08ac\u08b3\u08bb\u08c1\u08c8\u08ce\u08d2")
        buf.write("\u08d4\u08db\u08e4\u08f1\u08f6\u08fa\u0908\u090a\u0912")
        buf.write("\u0914\u0918\u0920\u0929\u092f\u0937\u093c\u0948\u094d")
        buf.write("\u0950\u0956\u095a\u095f\u0964\u0969\u096f\u0984\u0986")
        buf.write("\u098f\u0993\u099c\u09a0\u09b2\u09b5\u09bd\u09c6\u09dd")
        buf.write("\u09e8\u09ef\u09f2\u09fb\u09ff\u0a0b\u0a24\u0a2b\u0a2e")
        buf.write("\u0a3d\u0a41\u0a4b\u0a4d\u0a5a\u0a5c\u0a69\u0a6d\u0a74")
        buf.write("\u0a79\u0a81\u0a85\u0a8e\u0a93\u0aa4\u0aa8\u0ab1\u0ab5")
        buf.write("\u0ab7\u0abe\u0ac5\u0ac8\u0acb\u0ad2\u0ad9\u0adc\u0ae3")
        buf.write("\u0aeb\u0aee\u0afb\u0b0f\u0b19\u0b1c\u0b25\u0b28\u0b2a")
        buf.write("\u0b2d\u0b30\u0b42\u0b4b\u0b52\u0b59\u0b60\u0b6a\u0b6d")
        buf.write("\u0b72\u0b7a\u0b80\u0b85\u0b8a\u0b8e\u0b92\u0b96\u0b9a")
        buf.write("\u0b9e\u0ba2\u0ba5\u0bae")
        return buf.getvalue()


class sqlParser ( Parser ):

    grammarFileName = "sql.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "';'", "'('", "')'", "','", "'.'", "'/*+'", 
                     "'*/'", "'->'", "'['", "']'", "':'", "'ADD'", "'AFTER'", 
                     "'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", "'ANTI'", 
                     "'ANY'", "'ARCHIVE'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", 
                     "'AUTHORIZATION'", "'BETWEEN'", "'BOTH'", "'BUCKET'", 
                     "'BUCKETS'", "'BY'", "'CACHE'", "'CASCADE'", "'CASE'", 
                     "'CAST'", "'CHANGE'", "'CHECK'", "'CLEAR'", "'CLUSTER'", 
                     "'CLUSTERED'", "'CODEGEN'", "'COLLATE'", "'COLLECTION'", 
                     "'COLUMN'", "'COLUMNS'", "'COMMENT'", "'COMMIT'", "'COMPACT'", 
                     "'COMPACTIONS'", "'COMPUTE'", "'CONCATENATE'", "'CONSTRAINT'", 
                     "'COST'", "'CREATE'", "'CROSS'", "'CUBE'", "'CURRENT'", 
                     "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", 
                     "'CURRENT_USER'", "'DATA'", "'DATABASE'", "<INVALID>", 
                     "'DAY'", "'DBPROPERTIES'", "'DEFINED'", "'DELETE'", 
                     "'DELIMITED'", "'DESC'", "'DESCRIBE'", "'DFS'", "'DIRECTORIES'", 
                     "'DIRECTORY'", "'DISTINCT'", "'DISTRIBUTE'", "'DROP'", 
                     "'ELSE'", "'END'", "'ESCAPE'", "'ESCAPED'", "'EXCEPT'", 
                     "'EXCHANGE'", "'EXISTS'", "'EXPLAIN'", "'EXPORT'", 
                     "'EXTENDED'", "'EXTERNAL'", "'EXTRACT'", "'FALSE'", 
                     "'FETCH'", "'FIELDS'", "'FILTER'", "'FILEFORMAT'", 
                     "'FIRST'", "'FOLLOWING'", "'FOR'", "'FOREIGN'", "'FORMAT'", 
                     "'FORMATTED'", "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", 
                     "'GLOBAL'", "'GRANT'", "'GROUP'", "'GROUPING'", "'HAVING'", 
                     "'HOUR'", "'IF'", "'IGNORE'", "'IMPORT'", "'IN'", "'INDEX'", 
                     "'INDEXES'", "'INNER'", "'INPATH'", "'INPUTFORMAT'", 
                     "'INSERT'", "'INTERSECT'", "'INTERVAL'", "'INTO'", 
                     "'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", "'LAST'", "'LATERAL'", 
                     "'LAZY'", "'LEADING'", "'LEFT'", "'LIKE'", "'LIMIT'", 
                     "'LINES'", "'LIST'", "'LOAD'", "'LOCAL'", "'LOCATION'", 
                     "'LOCK'", "'LOCKS'", "'LOGICAL'", "'MACRO'", "'MAP'", 
                     "'MATCHED'", "'MERGE'", "'MINUTE'", "'MONTH'", "'MSCK'", 
                     "'NAMESPACE'", "'NAMESPACES'", "'NATURAL'", "'NO'", 
                     "<INVALID>", "'NULL'", "'NULLS'", "'OF'", "'ON'", "'ONLY'", 
                     "'OPTION'", "'OPTIONS'", "'OR'", "'ORDER'", "'OUT'", 
                     "'OUTER'", "'OUTPUTFORMAT'", "'OVER'", "'OVERLAPS'", 
                     "'OVERLAY'", "'OVERWRITE'", "'PARTITION'", "'PARTITIONED'", 
                     "'PARTITIONS'", "'PERCENT'", "'PIVOT'", "'PLACING'", 
                     "'POSITION'", "'PRECEDING'", "'PRIMARY'", "'PRINCIPALS'", 
                     "'PROPERTIES'", "'PURGE'", "'QUERY'", "'RANGE'", "'RECORDREADER'", 
                     "'RECORDWRITER'", "'RECOVER'", "'REDUCE'", "'REFERENCES'", 
                     "'REFRESH'", "'RENAME'", "'REPAIR'", "'REPLACE'", "'RESET'", 
                     "'RESTRICT'", "'REVOKE'", "'RIGHT'", "<INVALID>", "'ROLE'", 
                     "'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", 
                     "'SCHEMA'", "'SECOND'", "'SELECT'", "'SEMI'", "'SEPARATED'", 
                     "'SERDE'", "'SERDEPROPERTIES'", "'SESSION_USER'", "'SET'", 
                     "'MINUS'", "'SETS'", "'SHOW'", "'SKEWED'", "'SOME'", 
                     "'SORT'", "'SORTED'", "'START'", "'STATISTICS'", "'STORED'", 
                     "'STRATIFY'", "'STRUCT'", "'SUBSTR'", "'SUBSTRING'", 
                     "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TBLPROPERTIES'", 
                     "<INVALID>", "'TERMINATED'", "'THEN'", "'TO'", "'TOUCH'", 
                     "'TRAILING'", "'TRANSACTION'", "'TRANSACTIONS'", "'TRANSFORM'", 
                     "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TYPE'", "'UNARCHIVE'", 
                     "'UNBOUNDED'", "'UNCACHE'", "'UNION'", "'UNIQUE'", 
                     "'UNKNOWN'", "'UNLOCK'", "'UNSET'", "'UPDATE'", "'USE'", 
                     "'USER'", "'USING'", "'VALUES'", "'VIEW'", "'VIEWS'", 
                     "'WHEN'", "'WHERE'", "'WINDOW'", "'WITH'", "'YEAR'", 
                     "<INVALID>", "'<=>'", "'<>'", "'!='", "'<'", "<INVALID>", 
                     "'>'", "<INVALID>", "'+'", "'-'", "'*'", "'/'", "'%'", 
                     "'DIV'", "'~'", "'&'", "'|'", "'||'", "'^'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", 
                      "ANTI", "ANY", "ARCHIVE", "ARRAY", "AS", "ASC", "AT", 
                      "AUTHORIZATION", "BETWEEN", "BOTH", "BUCKET", "BUCKETS", 
                      "BY", "CACHE", "CASCADE", "CASE", "CAST", "CHANGE", 
                      "CHECK", "CLEAR", "CLUSTER", "CLUSTERED", "CODEGEN", 
                      "COLLATE", "COLLECTION", "COLUMN", "COLUMNS", "COMMENT", 
                      "COMMIT", "COMPACT", "COMPACTIONS", "COMPUTE", "CONCATENATE", 
                      "CONSTRAINT", "COST", "CREATE", "CROSS", "CUBE", "CURRENT", 
                      "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", 
                      "CURRENT_USER", "DATA", "DATABASE", "DATABASES", "DAY", 
                      "DBPROPERTIES", "DEFINED", "DELETE", "DELIMITED", 
                      "DESC", "DESCRIBE", "DFS", "DIRECTORIES", "DIRECTORY", 
                      "DISTINCT", "DISTRIBUTE", "DROP", "ELSE", "END", "ESCAPE", 
                      "ESCAPED", "EXCEPT", "EXCHANGE", "EXISTS", "EXPLAIN", 
                      "EXPORT", "EXTENDED", "EXTERNAL", "EXTRACT", "FALSE", 
                      "FETCH", "FIELDS", "FILTER", "FILEFORMAT", "FIRST", 
                      "FOLLOWING", "FOR", "FOREIGN", "FORMAT", "FORMATTED", 
                      "FROM", "FULL", "FUNCTION", "FUNCTIONS", "GLOBAL", 
                      "GRANT", "GROUP", "GROUPING", "HAVING", "HOUR", "IF", 
                      "IGNORE", "IMPORT", "IN", "INDEX", "INDEXES", "INNER", 
                      "INPATH", "INPUTFORMAT", "INSERT", "INTERSECT", "INTERVAL", 
                      "INTO", "IS", "ITEMS", "JOIN", "KEYS", "LAST", "LATERAL", 
                      "LAZY", "LEADING", "LEFT", "LIKE", "LIMIT", "LINES", 
                      "LIST", "LOAD", "LOCAL", "LOCATION", "LOCK", "LOCKS", 
                      "LOGICAL", "MACRO", "MAP", "MATCHED", "MERGE", "MINUTE", 
                      "MONTH", "MSCK", "NAMESPACE", "NAMESPACES", "NATURAL", 
                      "NO", "NOT", "NULL", "NULLS", "OF", "ON", "ONLY", 
                      "OPTION", "OPTIONS", "OR", "ORDER", "OUT", "OUTER", 
                      "OUTPUTFORMAT", "OVER", "OVERLAPS", "OVERLAY", "OVERWRITE", 
                      "PARTITION", "PARTITIONED", "PARTITIONS", "PERCENTLIT", 
                      "PIVOT", "PLACING", "POSITION", "PRECEDING", "PRIMARY", 
                      "PRINCIPALS", "PROPERTIES", "PURGE", "QUERY", "RANGE", 
                      "RECORDREADER", "RECORDWRITER", "RECOVER", "REDUCE", 
                      "REFERENCES", "REFRESH", "RENAME", "REPAIR", "REPLACE", 
                      "RESET", "RESTRICT", "REVOKE", "RIGHT", "RLIKE", "ROLE", 
                      "ROLES", "ROLLBACK", "ROLLUP", "ROW", "ROWS", "SCHEMA", 
                      "SECOND", "SELECT", "SEMI", "SEPARATED", "SERDE", 
                      "SERDEPROPERTIES", "SESSION_USER", "SET", "SETMINUS", 
                      "SETS", "SHOW", "SKEWED", "SOME", "SORT", "SORTED", 
                      "START", "STATISTICS", "STORED", "STRATIFY", "STRUCT", 
                      "SUBSTR", "SUBSTRING", "TABLE", "TABLES", "TABLESAMPLE", 
                      "TBLPROPERTIES", "TEMPORARY", "TERMINATED", "THEN", 
                      "TO", "TOUCH", "TRAILING", "TRANSACTION", "TRANSACTIONS", 
                      "TRANSFORM", "TRIM", "TRUE", "TRUNCATE", "TYPE", "UNARCHIVE", 
                      "UNBOUNDED", "UNCACHE", "UNION", "UNIQUE", "UNKNOWN", 
                      "UNLOCK", "UNSET", "UPDATE", "USE", "USER", "USING", 
                      "VALUES", "VIEW", "VIEWS", "WHEN", "WHERE", "WINDOW", 
                      "WITH", "YEAR", "EQ", "NSEQ", "NEQ", "NEQJ", "LT", 
                      "LTE", "GT", "GTE", "PLUS", "MINUS", "ASTERISK", "SLASH", 
                      "PERCENT", "DIV", "TILDE", "AMPERSAND", "PIPE", "CONCAT_PIPE", 
                      "HAT", "STRING", "BIGINT_LITERAL", "SMALLINT_LITERAL", 
                      "TINYINT_LITERAL", "INTEGER_VALUE", "EXPONENT_VALUE", 
                      "DECIMAL_VALUE", "DOUBLE_LITERAL", "BIGDECIMAL_LITERAL", 
                      "IDENTIFIER", "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", 
                      "BRACKETED_COMMENT", "WS", "UNRECOGNIZED" ]

    RULE_singleStatement = 0
    RULE_singleExpression = 1
    RULE_singleTableIdentifier = 2
    RULE_singleMultipartIdentifier = 3
    RULE_singleFunctionIdentifier = 4
    RULE_singleDataType = 5
    RULE_singleTableSchema = 6
    RULE_statement = 7
    RULE_unsupportedHiveNativeCommands = 8
    RULE_createTableHeader = 9
    RULE_replaceTableHeader = 10
    RULE_bucketSpec = 11
    RULE_skewSpec = 12
    RULE_locationSpec = 13
    RULE_commentSpec = 14
    RULE_query = 15
    RULE_insertInto = 16
    RULE_partitionSpecLocation = 17
    RULE_partitionSpec = 18
    RULE_partitionVal = 19
    RULE_namespace = 20
    RULE_describeFuncName = 21
    RULE_describeColName = 22
    RULE_ctes = 23
    RULE_namedQuery = 24
    RULE_tableProvider = 25
    RULE_createTableClauses = 26
    RULE_tablePropertyList = 27
    RULE_tableProperty = 28
    RULE_tablePropertyKey = 29
    RULE_tablePropertyValue = 30
    RULE_constantList = 31
    RULE_nestedConstantList = 32
    RULE_createFileFormat = 33
    RULE_fileFormat = 34
    RULE_storageHandler = 35
    RULE_resource = 36
    RULE_dmlStatementNoWith = 37
    RULE_queryOrganization = 38
    RULE_multiInsertQueryBody = 39
    RULE_queryTerm = 40
    RULE_queryPrimary = 41
    RULE_sortItem = 42
    RULE_fromStatement = 43
    RULE_fromStatementBody = 44
    RULE_querySpecification = 45
    RULE_transformClause = 46
    RULE_selectClause = 47
    RULE_setClause = 48
    RULE_matchedClause = 49
    RULE_notMatchedClause = 50
    RULE_matchedAction = 51
    RULE_notMatchedAction = 52
    RULE_assignmentList = 53
    RULE_assignment = 54
    RULE_whereClause = 55
    RULE_havingClause = 56
    RULE_hint = 57
    RULE_hintStatement = 58
    RULE_fromClause = 59
    RULE_aggregationClause = 60
    RULE_groupingSet = 61
    RULE_pivotClause = 62
    RULE_pivotColumn = 63
    RULE_pivotValue = 64
    RULE_lateralView = 65
    RULE_setQuantifier = 66
    RULE_relation = 67
    RULE_joinRelation = 68
    RULE_joinType = 69
    RULE_joinCriteria = 70
    RULE_sample = 71
    RULE_sampleMethod = 72
    RULE_identifierList = 73
    RULE_identifierSeq = 74
    RULE_orderedIdentifierList = 75
    RULE_orderedIdentifier = 76
    RULE_identifierCommentList = 77
    RULE_identifierComment = 78
    RULE_relationPrimary = 79
    RULE_inlineTable = 80
    RULE_functionTable = 81
    RULE_tableAlias = 82
    RULE_rowFormat = 83
    RULE_multipartIdentifierList = 84
    RULE_multipartIdentifier = 85
    RULE_tableIdentifier = 86
    RULE_functionIdentifier = 87
    RULE_namedExpression = 88
    RULE_namedExpressionSeq = 89
    RULE_transformList = 90
    RULE_transform = 91
    RULE_transformArgument = 92
    RULE_expression = 93
    RULE_booleanExpression = 94
    RULE_predicate = 95
    RULE_valueExpression = 96
    RULE_primaryExpression = 97
    RULE_constant = 98
    RULE_comparisonOperator = 99
    RULE_arithmeticOperator = 100
    RULE_predicateOperator = 101
    RULE_booleanValue = 102
    RULE_interval = 103
    RULE_errorCapturingMultiUnitsInterval = 104
    RULE_multiUnitsInterval = 105
    RULE_errorCapturingUnitToUnitInterval = 106
    RULE_unitToUnitInterval = 107
    RULE_intervalValue = 108
    RULE_intervalUnit = 109
    RULE_colPosition = 110
    RULE_dataType = 111
    RULE_qualifiedColTypeWithPositionList = 112
    RULE_qualifiedColTypeWithPosition = 113
    RULE_colTypeList = 114
    RULE_colType = 115
    RULE_complexColTypeList = 116
    RULE_complexColType = 117
    RULE_whenClause = 118
    RULE_windowClause = 119
    RULE_namedWindow = 120
    RULE_windowSpec = 121
    RULE_windowFrame = 122
    RULE_frameBound = 123
    RULE_qualifiedNameList = 124
    RULE_functionName = 125
    RULE_qualifiedName = 126
    RULE_errorCapturingIdentifier = 127
    RULE_errorCapturingIdentifierExtra = 128
    RULE_identifier = 129
    RULE_strictIdentifier = 130
    RULE_quotedIdentifier = 131
    RULE_number = 132
    RULE_alterColumnAction = 133
    RULE_ansiNonReserved = 134
    RULE_strictNonReserved = 135
    RULE_nonReserved = 136

    ruleNames =  [ "singleStatement", "singleExpression", "singleTableIdentifier", 
                   "singleMultipartIdentifier", "singleFunctionIdentifier", 
                   "singleDataType", "singleTableSchema", "statement", "unsupportedHiveNativeCommands", 
                   "createTableHeader", "replaceTableHeader", "bucketSpec", 
                   "skewSpec", "locationSpec", "commentSpec", "query", "insertInto", 
                   "partitionSpecLocation", "partitionSpec", "partitionVal", 
                   "namespace", "describeFuncName", "describeColName", "ctes", 
                   "namedQuery", "tableProvider", "createTableClauses", 
                   "tablePropertyList", "tableProperty", "tablePropertyKey", 
                   "tablePropertyValue", "constantList", "nestedConstantList", 
                   "createFileFormat", "fileFormat", "storageHandler", "resource", 
                   "dmlStatementNoWith", "queryOrganization", "multiInsertQueryBody", 
                   "queryTerm", "queryPrimary", "sortItem", "fromStatement", 
                   "fromStatementBody", "querySpecification", "transformClause", 
                   "selectClause", "setClause", "matchedClause", "notMatchedClause", 
                   "matchedAction", "notMatchedAction", "assignmentList", 
                   "assignment", "whereClause", "havingClause", "hint", 
                   "hintStatement", "fromClause", "aggregationClause", "groupingSet", 
                   "pivotClause", "pivotColumn", "pivotValue", "lateralView", 
                   "setQuantifier", "relation", "joinRelation", "joinType", 
                   "joinCriteria", "sample", "sampleMethod", "identifierList", 
                   "identifierSeq", "orderedIdentifierList", "orderedIdentifier", 
                   "identifierCommentList", "identifierComment", "relationPrimary", 
                   "inlineTable", "functionTable", "tableAlias", "rowFormat", 
                   "multipartIdentifierList", "multipartIdentifier", "tableIdentifier", 
                   "functionIdentifier", "namedExpression", "namedExpressionSeq", 
                   "transformList", "transform", "transformArgument", "expression", 
                   "booleanExpression", "predicate", "valueExpression", 
                   "primaryExpression", "constant", "comparisonOperator", 
                   "arithmeticOperator", "predicateOperator", "booleanValue", 
                   "interval", "errorCapturingMultiUnitsInterval", "multiUnitsInterval", 
                   "errorCapturingUnitToUnitInterval", "unitToUnitInterval", 
                   "intervalValue", "intervalUnit", "colPosition", "dataType", 
                   "qualifiedColTypeWithPositionList", "qualifiedColTypeWithPosition", 
                   "colTypeList", "colType", "complexColTypeList", "complexColType", 
                   "whenClause", "windowClause", "namedWindow", "windowSpec", 
                   "windowFrame", "frameBound", "qualifiedNameList", "functionName", 
                   "qualifiedName", "errorCapturingIdentifier", "errorCapturingIdentifierExtra", 
                   "identifier", "strictIdentifier", "quotedIdentifier", 
                   "number", "alterColumnAction", "ansiNonReserved", "strictNonReserved", 
                   "nonReserved" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    ADD=12
    AFTER=13
    ALL=14
    ALTER=15
    ANALYZE=16
    AND=17
    ANTI=18
    ANY=19
    ARCHIVE=20
    ARRAY=21
    AS=22
    ASC=23
    AT=24
    AUTHORIZATION=25
    BETWEEN=26
    BOTH=27
    BUCKET=28
    BUCKETS=29
    BY=30
    CACHE=31
    CASCADE=32
    CASE=33
    CAST=34
    CHANGE=35
    CHECK=36
    CLEAR=37
    CLUSTER=38
    CLUSTERED=39
    CODEGEN=40
    COLLATE=41
    COLLECTION=42
    COLUMN=43
    COLUMNS=44
    COMMENT=45
    COMMIT=46
    COMPACT=47
    COMPACTIONS=48
    COMPUTE=49
    CONCATENATE=50
    CONSTRAINT=51
    COST=52
    CREATE=53
    CROSS=54
    CUBE=55
    CURRENT=56
    CURRENT_DATE=57
    CURRENT_TIME=58
    CURRENT_TIMESTAMP=59
    CURRENT_USER=60
    DATA=61
    DATABASE=62
    DATABASES=63
    DAY=64
    DBPROPERTIES=65
    DEFINED=66
    DELETE=67
    DELIMITED=68
    DESC=69
    DESCRIBE=70
    DFS=71
    DIRECTORIES=72
    DIRECTORY=73
    DISTINCT=74
    DISTRIBUTE=75
    DROP=76
    ELSE=77
    END=78
    ESCAPE=79
    ESCAPED=80
    EXCEPT=81
    EXCHANGE=82
    EXISTS=83
    EXPLAIN=84
    EXPORT=85
    EXTENDED=86
    EXTERNAL=87
    EXTRACT=88
    FALSE=89
    FETCH=90
    FIELDS=91
    FILTER=92
    FILEFORMAT=93
    FIRST=94
    FOLLOWING=95
    FOR=96
    FOREIGN=97
    FORMAT=98
    FORMATTED=99
    FROM=100
    FULL=101
    FUNCTION=102
    FUNCTIONS=103
    GLOBAL=104
    GRANT=105
    GROUP=106
    GROUPING=107
    HAVING=108
    HOUR=109
    IF=110
    IGNORE=111
    IMPORT=112
    IN=113
    INDEX=114
    INDEXES=115
    INNER=116
    INPATH=117
    INPUTFORMAT=118
    INSERT=119
    INTERSECT=120
    INTERVAL=121
    INTO=122
    IS=123
    ITEMS=124
    JOIN=125
    KEYS=126
    LAST=127
    LATERAL=128
    LAZY=129
    LEADING=130
    LEFT=131
    LIKE=132
    LIMIT=133
    LINES=134
    LIST=135
    LOAD=136
    LOCAL=137
    LOCATION=138
    LOCK=139
    LOCKS=140
    LOGICAL=141
    MACRO=142
    MAP=143
    MATCHED=144
    MERGE=145
    MINUTE=146
    MONTH=147
    MSCK=148
    NAMESPACE=149
    NAMESPACES=150
    NATURAL=151
    NO=152
    NOT=153
    NULL=154
    NULLS=155
    OF=156
    ON=157
    ONLY=158
    OPTION=159
    OPTIONS=160
    OR=161
    ORDER=162
    OUT=163
    OUTER=164
    OUTPUTFORMAT=165
    OVER=166
    OVERLAPS=167
    OVERLAY=168
    OVERWRITE=169
    PARTITION=170
    PARTITIONED=171
    PARTITIONS=172
    PERCENTLIT=173
    PIVOT=174
    PLACING=175
    POSITION=176
    PRECEDING=177
    PRIMARY=178
    PRINCIPALS=179
    PROPERTIES=180
    PURGE=181
    QUERY=182
    RANGE=183
    RECORDREADER=184
    RECORDWRITER=185
    RECOVER=186
    REDUCE=187
    REFERENCES=188
    REFRESH=189
    RENAME=190
    REPAIR=191
    REPLACE=192
    RESET=193
    RESTRICT=194
    REVOKE=195
    RIGHT=196
    RLIKE=197
    ROLE=198
    ROLES=199
    ROLLBACK=200
    ROLLUP=201
    ROW=202
    ROWS=203
    SCHEMA=204
    SECOND=205
    SELECT=206
    SEMI=207
    SEPARATED=208
    SERDE=209
    SERDEPROPERTIES=210
    SESSION_USER=211
    SET=212
    SETMINUS=213
    SETS=214
    SHOW=215
    SKEWED=216
    SOME=217
    SORT=218
    SORTED=219
    START=220
    STATISTICS=221
    STORED=222
    STRATIFY=223
    STRUCT=224
    SUBSTR=225
    SUBSTRING=226
    TABLE=227
    TABLES=228
    TABLESAMPLE=229
    TBLPROPERTIES=230
    TEMPORARY=231
    TERMINATED=232
    THEN=233
    TO=234
    TOUCH=235
    TRAILING=236
    TRANSACTION=237
    TRANSACTIONS=238
    TRANSFORM=239
    TRIM=240
    TRUE=241
    TRUNCATE=242
    TYPE=243
    UNARCHIVE=244
    UNBOUNDED=245
    UNCACHE=246
    UNION=247
    UNIQUE=248
    UNKNOWN=249
    UNLOCK=250
    UNSET=251
    UPDATE=252
    USE=253
    USER=254
    USING=255
    VALUES=256
    VIEW=257
    VIEWS=258
    WHEN=259
    WHERE=260
    WINDOW=261
    WITH=262
    YEAR=263
    EQ=264
    NSEQ=265
    NEQ=266
    NEQJ=267
    LT=268
    LTE=269
    GT=270
    GTE=271
    PLUS=272
    MINUS=273
    ASTERISK=274
    SLASH=275
    PERCENT=276
    DIV=277
    TILDE=278
    AMPERSAND=279
    PIPE=280
    CONCAT_PIPE=281
    HAT=282
    STRING=283
    BIGINT_LITERAL=284
    SMALLINT_LITERAL=285
    TINYINT_LITERAL=286
    INTEGER_VALUE=287
    EXPONENT_VALUE=288
    DECIMAL_VALUE=289
    DOUBLE_LITERAL=290
    BIGDECIMAL_LITERAL=291
    IDENTIFIER=292
    BACKQUOTED_IDENTIFIER=293
    SIMPLE_COMMENT=294
    BRACKETED_COMMENT=295
    WS=296
    UNRECOGNIZED=297

    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



    # When false, INTERSECT is given the greater precedence over the other set
    # operations (UNION, EXCEPT and MINUS) as per the SQL standard.
    @property
    def legacy_setops_precedence_enbled(self):
        return False

    # When false, a literal with an exponent would be converted into
    # double type rather than decimal type.
    @property
    def legacy_exponent_literal_as_decimal_enabled(self):
        return False

    # Verify whether current token is a valid decimal token (which contains dot).
    # Returns true if the character that follows the token is not a digit or letter or underscore.

    #  For example:
    # For char stream "2.3", "2." is not a valid decimal token, because it is followed by digit '3'.
    # For char stream "2.3_", "2.3" is not a valid decimal token, because it is followed by '_'.
    # For char stream "2.3W", "2.3" is not a valid decimal token, because it is followed by 'W'.
    # For char stream "12.0D 34.E2+0.12 "  12.0D is a valid decimal token because it is followed
    # by a space. 34.E2 is a valid decimal token because it is followed by symbol '+'
    # which is not a digit or letter or underscore.
    @property
    def isValidDecimal(self):
        return True  # TODO: remove this
        nextChar = self._input.LA(1);
        if (nextChar >= 'A' and nextChar <= 'Z') or (nextChar >= '0' and nextChar <= '9') or nextChar == '_':
            return False
        else:
            return True

    # When true, the behavior of keywords follows ANSI SQL standard.
    @property
    def SQL_standard_keyword_behavior(self):
        if "_ansi_sql" in self.__dict__:
            return self._ansi_sql
        return False

    # This method will be called when we see '/ *' and try to match it as a bracketed comment.
    # If the next character is '+', it should be parsed as hint later, and we cannot match
    # it as a bracketed comment.

    # Returns true if the next character is '+'.
    def isHint(self):
        return False  # TODO: remove this
        nextChar = self._input.LA(1);
        if nextChar == '+':
            return True
        else:
            return False


    @property
    def allUpperCase(self):
        if "_all_upper_case" in self.__dict__:
            return self._all_upper_case
        return False





    class SingleStatementContext(ParserRuleContext):

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

        def statement(self):
            return self.getTypedRuleContext(sqlParser.StatementContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_singleStatement

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




    def singleStatement(self):

        localctx = sqlParser.SingleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_singleStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 274
            self.statement()
            self.state = 278
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__0:
                self.state = 275
                self.match(sqlParser.T__0)
                self.state = 280
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class SingleExpressionContext(ParserRuleContext):

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

        def namedExpression(self):
            return self.getTypedRuleContext(sqlParser.NamedExpressionContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_singleExpression

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




    def singleExpression(self):

        localctx = sqlParser.SingleExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_singleExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 283
            self.namedExpression()
            self.state = 284
            self.match(sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleTableIdentifierContext(ParserRuleContext):

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

        def tableIdentifier(self):
            return self.getTypedRuleContext(sqlParser.TableIdentifierContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_singleTableIdentifier

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




    def singleTableIdentifier(self):

        localctx = sqlParser.SingleTableIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_singleTableIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 286
            self.tableIdentifier()
            self.state = 287
            self.match(sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleMultipartIdentifierContext(ParserRuleContext):

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

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_singleMultipartIdentifier

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




    def singleMultipartIdentifier(self):

        localctx = sqlParser.SingleMultipartIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_singleMultipartIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 289
            self.multipartIdentifier()
            self.state = 290
            self.match(sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleFunctionIdentifierContext(ParserRuleContext):

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

        def functionIdentifier(self):
            return self.getTypedRuleContext(sqlParser.FunctionIdentifierContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_singleFunctionIdentifier

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




    def singleFunctionIdentifier(self):

        localctx = sqlParser.SingleFunctionIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_singleFunctionIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 292
            self.functionIdentifier()
            self.state = 293
            self.match(sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleDataTypeContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return sqlParser.RULE_singleDataType

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




    def singleDataType(self):

        localctx = sqlParser.SingleDataTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_singleDataType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 295
            self.dataType()
            self.state = 296
            self.match(sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleTableSchemaContext(ParserRuleContext):

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

        def colTypeList(self):
            return self.getTypedRuleContext(sqlParser.ColTypeListContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_singleTableSchema

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




    def singleTableSchema(self):

        localctx = sqlParser.SingleTableSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_singleTableSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self.colTypeList()
            self.state = 299
            self.match(sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_statement

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



    class ExplainContext(StatementContext):

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

        def EXPLAIN(self):
            return self.getToken(sqlParser.EXPLAIN, 0)
        def statement(self):
            return self.getTypedRuleContext(sqlParser.StatementContext,0)

        def LOGICAL(self):
            return self.getToken(sqlParser.LOGICAL, 0)
        def FORMATTED(self):
            return self.getToken(sqlParser.FORMATTED, 0)
        def EXTENDED(self):
            return self.getToken(sqlParser.EXTENDED, 0)
        def CODEGEN(self):
            return self.getToken(sqlParser.CODEGEN, 0)
        def COST(self):
            return self.getToken(sqlParser.COST, 0)

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


    class ResetConfigurationContext(StatementContext):

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

        def RESET(self):
            return self.getToken(sqlParser.RESET, 0)

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


    class AlterViewQueryContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

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

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


    class UseContext(StatementContext):

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

        def USE(self):
            return self.getToken(sqlParser.USE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def NAMESPACE(self):
            return self.getToken(sqlParser.NAMESPACE, 0)

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


    class DropNamespaceContext(StatementContext):

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

        def DROP(self):
            return self.getToken(sqlParser.DROP, 0)
        def namespace(self):
            return self.getTypedRuleContext(sqlParser.NamespaceContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def RESTRICT(self):
            return self.getToken(sqlParser.RESTRICT, 0)
        def CASCADE(self):
            return self.getToken(sqlParser.CASCADE, 0)

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


    class CreateTempViewUsingContext(StatementContext):

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

        def CREATE(self):
            return self.getToken(sqlParser.CREATE, 0)
        def TEMPORARY(self):
            return self.getToken(sqlParser.TEMPORARY, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)
        def tableIdentifier(self):
            return self.getTypedRuleContext(sqlParser.TableIdentifierContext,0)

        def tableProvider(self):
            return self.getTypedRuleContext(sqlParser.TableProviderContext,0)

        def OR(self):
            return self.getToken(sqlParser.OR, 0)
        def REPLACE(self):
            return self.getToken(sqlParser.REPLACE, 0)
        def GLOBAL(self):
            return self.getToken(sqlParser.GLOBAL, 0)
        def colTypeList(self):
            return self.getTypedRuleContext(sqlParser.ColTypeListContext,0)

        def OPTIONS(self):
            return self.getToken(sqlParser.OPTIONS, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)


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


    class RenameTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.qpdfrom = None # MultipartIdentifierContext
            self.to = None # MultipartIdentifierContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def RENAME(self):
            return self.getToken(sqlParser.RENAME, 0)
        def TO(self):
            return self.getToken(sqlParser.TO, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,i)


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


    class FailNativeCommandContext(StatementContext):

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

        def SET(self):
            return self.getToken(sqlParser.SET, 0)
        def ROLE(self):
            return self.getToken(sqlParser.ROLE, 0)
        def unsupportedHiveNativeCommands(self):
            return self.getTypedRuleContext(sqlParser.UnsupportedHiveNativeCommandsContext,0)


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


    class ClearCacheContext(StatementContext):

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

        def CLEAR(self):
            return self.getToken(sqlParser.CLEAR, 0)
        def CACHE(self):
            return self.getToken(sqlParser.CACHE, 0)

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


    class DropViewContext(StatementContext):

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

        def DROP(self):
            return self.getToken(sqlParser.DROP, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

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


    class ShowTablesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def TABLES(self):
            return self.getToken(sqlParser.TABLES, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(sqlParser.IN, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)

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


    class RecoverPartitionsContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def RECOVER(self):
            return self.getToken(sqlParser.RECOVER, 0)
        def PARTITIONS(self):
            return self.getToken(sqlParser.PARTITIONS, 0)

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


    class ShowCurrentNamespaceContext(StatementContext):

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

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def CURRENT(self):
            return self.getToken(sqlParser.CURRENT, 0)
        def NAMESPACE(self):
            return self.getToken(sqlParser.NAMESPACE, 0)

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


    class RenameTablePartitionContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.qpdfrom = None # PartitionSpecContext
            self.to = None # PartitionSpecContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def RENAME(self):
            return self.getToken(sqlParser.RENAME, 0)
        def TO(self):
            return self.getToken(sqlParser.TO, 0)
        def partitionSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.PartitionSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.PartitionSpecContext,i)


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


    class RepairTableContext(StatementContext):

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

        def MSCK(self):
            return self.getToken(sqlParser.MSCK, 0)
        def REPAIR(self):
            return self.getToken(sqlParser.REPAIR, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


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


    class RefreshResourceContext(StatementContext):

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

        def REFRESH(self):
            return self.getToken(sqlParser.REFRESH, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)

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


    class ShowCreateTableContext(StatementContext):

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

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def CREATE(self):
            return self.getToken(sqlParser.CREATE, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def AS(self):
            return self.getToken(sqlParser.AS, 0)
        def SERDE(self):
            return self.getToken(sqlParser.SERDE, 0)

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


    class ShowNamespacesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def DATABASES(self):
            return self.getToken(sqlParser.DATABASES, 0)
        def NAMESPACES(self):
            return self.getToken(sqlParser.NAMESPACES, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(sqlParser.IN, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)

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


    class ShowColumnsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.ns = None # MultipartIdentifierContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def COLUMNS(self):
            return self.getToken(sqlParser.COLUMNS, 0)
        def FROM(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.FROM)
            else:
                return self.getToken(sqlParser.FROM, i)
        def IN(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.IN)
            else:
                return self.getToken(sqlParser.IN, i)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,i)


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


    class ReplaceTableContext(StatementContext):

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

        def replaceTableHeader(self):
            return self.getTypedRuleContext(sqlParser.ReplaceTableHeaderContext,0)

        def tableProvider(self):
            return self.getTypedRuleContext(sqlParser.TableProviderContext,0)

        def createTableClauses(self):
            return self.getTypedRuleContext(sqlParser.CreateTableClausesContext,0)

        def colTypeList(self):
            return self.getTypedRuleContext(sqlParser.ColTypeListContext,0)

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

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

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


    class AddTablePartitionContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def ADD(self):
            return self.getToken(sqlParser.ADD, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)
        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def partitionSpecLocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.PartitionSpecLocationContext)
            else:
                return self.getTypedRuleContext(sqlParser.PartitionSpecLocationContext,i)


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


    class SetNamespaceLocationContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def namespace(self):
            return self.getTypedRuleContext(sqlParser.NamespaceContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def SET(self):
            return self.getToken(sqlParser.SET, 0)
        def locationSpec(self):
            return self.getTypedRuleContext(sqlParser.LocationSpecContext,0)


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


    class RefreshTableContext(StatementContext):

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

        def REFRESH(self):
            return self.getToken(sqlParser.REFRESH, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


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


    class SetNamespacePropertiesContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def namespace(self):
            return self.getTypedRuleContext(sqlParser.NamespaceContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def SET(self):
            return self.getToken(sqlParser.SET, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)

        def DBPROPERTIES(self):
            return self.getToken(sqlParser.DBPROPERTIES, 0)
        def PROPERTIES(self):
            return self.getToken(sqlParser.PROPERTIES, 0)

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


    class ManageResourceContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)

        def ADD(self):
            return self.getToken(sqlParser.ADD, 0)
        def LIST(self):
            return self.getToken(sqlParser.LIST, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)

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


    class AnalyzeContext(StatementContext):

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

        def ANALYZE(self):
            return self.getToken(sqlParser.ANALYZE, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def COMPUTE(self):
            return self.getToken(sqlParser.COMPUTE, 0)
        def STATISTICS(self):
            return self.getToken(sqlParser.STATISTICS, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)

        def FOR(self):
            return self.getToken(sqlParser.FOR, 0)
        def COLUMNS(self):
            return self.getToken(sqlParser.COLUMNS, 0)
        def identifierSeq(self):
            return self.getTypedRuleContext(sqlParser.IdentifierSeqContext,0)

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

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


    class CreateHiveTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.columns = None # ColTypeListContext
            self.partitionColumns = None # ColTypeListContext
            self.partitionColumnNames = None # IdentifierListContext
            self.tableProps = None # TablePropertyListContext
            self.copyFrom(ctx)

        def createTableHeader(self):
            return self.getTypedRuleContext(sqlParser.CreateTableHeaderContext,0)

        def commentSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.CommentSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.CommentSpecContext,i)

        def bucketSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.BucketSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.BucketSpecContext,i)

        def skewSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.SkewSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.SkewSpecContext,i)

        def rowFormat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.RowFormatContext)
            else:
                return self.getTypedRuleContext(sqlParser.RowFormatContext,i)

        def createFileFormat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.CreateFileFormatContext)
            else:
                return self.getTypedRuleContext(sqlParser.CreateFileFormatContext,i)

        def locationSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.LocationSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.LocationSpecContext,i)

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

        def colTypeList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ColTypeListContext)
            else:
                return self.getTypedRuleContext(sqlParser.ColTypeListContext,i)

        def PARTITIONED(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.PARTITIONED)
            else:
                return self.getToken(sqlParser.PARTITIONED, i)
        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.BY)
            else:
                return self.getToken(sqlParser.BY, i)
        def TBLPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.TBLPROPERTIES)
            else:
                return self.getToken(sqlParser.TBLPROPERTIES, i)
        def identifierList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierListContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierListContext,i)

        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(sqlParser.TablePropertyListContext,i)

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

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


    class CreateFunctionContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.className = None # Token
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(sqlParser.CREATE, 0)
        def FUNCTION(self):
            return self.getToken(sqlParser.FUNCTION, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def AS(self):
            return self.getToken(sqlParser.AS, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def OR(self):
            return self.getToken(sqlParser.OR, 0)
        def REPLACE(self):
            return self.getToken(sqlParser.REPLACE, 0)
        def TEMPORARY(self):
            return self.getToken(sqlParser.TEMPORARY, 0)
        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def USING(self):
            return self.getToken(sqlParser.USING, 0)
        def resource(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ResourceContext)
            else:
                return self.getTypedRuleContext(sqlParser.ResourceContext,i)


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


    class ShowTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.ns = None # MultipartIdentifierContext
            self.pattern = None # Token
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def EXTENDED(self):
            return self.getToken(sqlParser.EXTENDED, 0)
        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)

        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(sqlParser.IN, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


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


    class HiveReplaceColumnsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.columns = None # QualifiedColTypeWithPositionListContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def REPLACE(self):
            return self.getToken(sqlParser.REPLACE, 0)
        def COLUMNS(self):
            return self.getToken(sqlParser.COLUMNS, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def qualifiedColTypeWithPositionList(self):
            return self.getTypedRuleContext(sqlParser.QualifiedColTypeWithPositionListContext,0)

        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)


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


    class CommentNamespaceContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.comment = None # Token
            self.copyFrom(ctx)

        def COMMENT(self):
            return self.getToken(sqlParser.COMMENT, 0)
        def ON(self):
            return self.getToken(sqlParser.ON, 0)
        def namespace(self):
            return self.getTypedRuleContext(sqlParser.NamespaceContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def IS(self):
            return self.getToken(sqlParser.IS, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

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


    class CreateTableContext(StatementContext):

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

        def createTableHeader(self):
            return self.getTypedRuleContext(sqlParser.CreateTableHeaderContext,0)

        def tableProvider(self):
            return self.getTypedRuleContext(sqlParser.TableProviderContext,0)

        def createTableClauses(self):
            return self.getTypedRuleContext(sqlParser.CreateTableClausesContext,0)

        def colTypeList(self):
            return self.getTypedRuleContext(sqlParser.ColTypeListContext,0)

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

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

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


    class DmlStatementContext(StatementContext):

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

        def dmlStatementNoWith(self):
            return self.getTypedRuleContext(sqlParser.DmlStatementNoWithContext,0)

        def ctes(self):
            return self.getTypedRuleContext(sqlParser.CtesContext,0)


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


    class CreateTableLikeContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.target = None # TableIdentifierContext
            self.source = None # TableIdentifierContext
            self.tableProps = None # TablePropertyListContext
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(sqlParser.CREATE, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)
        def tableIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TableIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.TableIdentifierContext,i)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def tableProvider(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TableProviderContext)
            else:
                return self.getTypedRuleContext(sqlParser.TableProviderContext,i)

        def rowFormat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.RowFormatContext)
            else:
                return self.getTypedRuleContext(sqlParser.RowFormatContext,i)

        def createFileFormat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.CreateFileFormatContext)
            else:
                return self.getTypedRuleContext(sqlParser.CreateFileFormatContext,i)

        def locationSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.LocationSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.LocationSpecContext,i)

        def TBLPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.TBLPROPERTIES)
            else:
                return self.getToken(sqlParser.TBLPROPERTIES, i)
        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(sqlParser.TablePropertyListContext,i)


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


    class UncacheTableContext(StatementContext):

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

        def UNCACHE(self):
            return self.getToken(sqlParser.UNCACHE, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

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


    class DropFunctionContext(StatementContext):

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

        def DROP(self):
            return self.getToken(sqlParser.DROP, 0)
        def FUNCTION(self):
            return self.getToken(sqlParser.FUNCTION, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def TEMPORARY(self):
            return self.getToken(sqlParser.TEMPORARY, 0)
        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

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


    class DescribeRelationContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.option = None # Token
            self.copyFrom(ctx)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def DESC(self):
            return self.getToken(sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(sqlParser.DESCRIBE, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)

        def describeColName(self):
            return self.getTypedRuleContext(sqlParser.DescribeColNameContext,0)

        def EXTENDED(self):
            return self.getToken(sqlParser.EXTENDED, 0)
        def FORMATTED(self):
            return self.getToken(sqlParser.FORMATTED, 0)

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


    class LoadDataContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.path = None # Token
            self.copyFrom(ctx)

        def LOAD(self):
            return self.getToken(sqlParser.LOAD, 0)
        def DATA(self):
            return self.getToken(sqlParser.DATA, 0)
        def INPATH(self):
            return self.getToken(sqlParser.INPATH, 0)
        def INTO(self):
            return self.getToken(sqlParser.INTO, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def LOCAL(self):
            return self.getToken(sqlParser.LOCAL, 0)
        def OVERWRITE(self):
            return self.getToken(sqlParser.OVERWRITE, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)


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


    class ShowPartitionsContext(StatementContext):

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

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def PARTITIONS(self):
            return self.getToken(sqlParser.PARTITIONS, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)


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


    class DescribeFunctionContext(StatementContext):

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

        def FUNCTION(self):
            return self.getToken(sqlParser.FUNCTION, 0)
        def describeFuncName(self):
            return self.getTypedRuleContext(sqlParser.DescribeFuncNameContext,0)

        def DESC(self):
            return self.getToken(sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(sqlParser.DESCRIBE, 0)
        def EXTENDED(self):
            return self.getToken(sqlParser.EXTENDED, 0)

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


    class RenameTableColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.qpdfrom = None # MultipartIdentifierContext
            self.to = None # ErrorCapturingIdentifierContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def RENAME(self):
            return self.getToken(sqlParser.RENAME, 0)
        def COLUMN(self):
            return self.getToken(sqlParser.COLUMN, 0)
        def TO(self):
            return self.getToken(sqlParser.TO, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,i)

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


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


    class StatementDefaultContext(StatementContext):

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

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)


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


    class HiveChangeColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.colName = None # MultipartIdentifierContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def CHANGE(self):
            return self.getToken(sqlParser.CHANGE, 0)
        def colType(self):
            return self.getTypedRuleContext(sqlParser.ColTypeContext,0)

        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,i)

        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)

        def COLUMN(self):
            return self.getToken(sqlParser.COLUMN, 0)
        def colPosition(self):
            return self.getTypedRuleContext(sqlParser.ColPositionContext,0)


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


    class DescribeQueryContext(StatementContext):

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

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

        def DESC(self):
            return self.getToken(sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(sqlParser.DESCRIBE, 0)
        def QUERY(self):
            return self.getToken(sqlParser.QUERY, 0)

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


    class TruncateTableContext(StatementContext):

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

        def TRUNCATE(self):
            return self.getToken(sqlParser.TRUNCATE, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)


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


    class SetTableSerDeContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def SET(self):
            return self.getToken(sqlParser.SET, 0)
        def SERDE(self):
            return self.getToken(sqlParser.SERDE, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)

        def WITH(self):
            return self.getToken(sqlParser.WITH, 0)
        def SERDEPROPERTIES(self):
            return self.getToken(sqlParser.SERDEPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)


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


    class CreateViewContext(StatementContext):

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

        def CREATE(self):
            return self.getToken(sqlParser.CREATE, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def AS(self):
            return self.getToken(sqlParser.AS, 0)
        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

        def OR(self):
            return self.getToken(sqlParser.OR, 0)
        def REPLACE(self):
            return self.getToken(sqlParser.REPLACE, 0)
        def TEMPORARY(self):
            return self.getToken(sqlParser.TEMPORARY, 0)
        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def identifierCommentList(self):
            return self.getTypedRuleContext(sqlParser.IdentifierCommentListContext,0)

        def commentSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.CommentSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.CommentSpecContext,i)

        def PARTITIONED(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.PARTITIONED)
            else:
                return self.getToken(sqlParser.PARTITIONED, i)
        def ON(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.ON)
            else:
                return self.getToken(sqlParser.ON, i)
        def identifierList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierListContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierListContext,i)

        def TBLPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.TBLPROPERTIES)
            else:
                return self.getToken(sqlParser.TBLPROPERTIES, i)
        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(sqlParser.TablePropertyListContext,i)

        def GLOBAL(self):
            return self.getToken(sqlParser.GLOBAL, 0)

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


    class DropTablePartitionsContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def DROP(self):
            return self.getToken(sqlParser.DROP, 0)
        def partitionSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.PartitionSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.PartitionSpecContext,i)

        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)
        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def PURGE(self):
            return self.getToken(sqlParser.PURGE, 0)

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


    class SetConfigurationContext(StatementContext):

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

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

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


    class DropTableContext(StatementContext):

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

        def DROP(self):
            return self.getToken(sqlParser.DROP, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def PURGE(self):
            return self.getToken(sqlParser.PURGE, 0)

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


    class DescribeNamespaceContext(StatementContext):

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

        def namespace(self):
            return self.getTypedRuleContext(sqlParser.NamespaceContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def DESC(self):
            return self.getToken(sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(sqlParser.DESCRIBE, 0)
        def EXTENDED(self):
            return self.getToken(sqlParser.EXTENDED, 0)

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


    class AlterTableAlterColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.column = None # MultipartIdentifierContext
            self.copyFrom(ctx)

        def ALTER(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.ALTER)
            else:
                return self.getToken(sqlParser.ALTER, i)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,i)

        def CHANGE(self):
            return self.getToken(sqlParser.CHANGE, 0)
        def COLUMN(self):
            return self.getToken(sqlParser.COLUMN, 0)
        def alterColumnAction(self):
            return self.getTypedRuleContext(sqlParser.AlterColumnActionContext,0)


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


    class CommentTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.comment = None # Token
            self.copyFrom(ctx)

        def COMMENT(self):
            return self.getToken(sqlParser.COMMENT, 0)
        def ON(self):
            return self.getToken(sqlParser.ON, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def IS(self):
            return self.getToken(sqlParser.IS, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

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


    class CreateNamespaceContext(StatementContext):

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

        def CREATE(self):
            return self.getToken(sqlParser.CREATE, 0)
        def namespace(self):
            return self.getTypedRuleContext(sqlParser.NamespaceContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def commentSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.CommentSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.CommentSpecContext,i)

        def locationSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.LocationSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.LocationSpecContext,i)

        def WITH(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.WITH)
            else:
                return self.getToken(sqlParser.WITH, i)
        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(sqlParser.TablePropertyListContext,i)

        def DBPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.DBPROPERTIES)
            else:
                return self.getToken(sqlParser.DBPROPERTIES, i)
        def PROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.PROPERTIES)
            else:
                return self.getToken(sqlParser.PROPERTIES, i)

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


    class ShowTblPropertiesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.key = None # TablePropertyKeyContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def TBLPROPERTIES(self):
            return self.getToken(sqlParser.TBLPROPERTIES, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def tablePropertyKey(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyKeyContext,0)


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


    class UnsetTablePropertiesContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def UNSET(self):
            return self.getToken(sqlParser.UNSET, 0)
        def TBLPROPERTIES(self):
            return self.getToken(sqlParser.TBLPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)

        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)
        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

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


    class SetTableLocationContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def SET(self):
            return self.getToken(sqlParser.SET, 0)
        def locationSpec(self):
            return self.getTypedRuleContext(sqlParser.LocationSpecContext,0)

        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)


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


    class DropTableColumnsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.columns = None # MultipartIdentifierListContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def DROP(self):
            return self.getToken(sqlParser.DROP, 0)
        def COLUMN(self):
            return self.getToken(sqlParser.COLUMN, 0)
        def COLUMNS(self):
            return self.getToken(sqlParser.COLUMNS, 0)
        def multipartIdentifierList(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierListContext,0)


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


    class ShowViewsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def VIEWS(self):
            return self.getToken(sqlParser.VIEWS, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(sqlParser.IN, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)

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


    class ShowFunctionsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)
        def FUNCTIONS(self):
            return self.getToken(sqlParser.FUNCTIONS, 0)
        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)

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


    class CacheTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.options = None # TablePropertyListContext
            self.copyFrom(ctx)

        def CACHE(self):
            return self.getToken(sqlParser.CACHE, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def LAZY(self):
            return self.getToken(sqlParser.LAZY, 0)
        def OPTIONS(self):
            return self.getToken(sqlParser.OPTIONS, 0)
        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)

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

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


    class AddTableColumnsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.StatementContext
            super().__init__(parser)
            self.columns = None # QualifiedColTypeWithPositionListContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def ADD(self):
            return self.getToken(sqlParser.ADD, 0)
        def COLUMN(self):
            return self.getToken(sqlParser.COLUMN, 0)
        def COLUMNS(self):
            return self.getToken(sqlParser.COLUMNS, 0)
        def qualifiedColTypeWithPositionList(self):
            return self.getTypedRuleContext(sqlParser.QualifiedColTypeWithPositionListContext,0)


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


    class SetTablePropertiesContext(StatementContext):

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def SET(self):
            return self.getToken(sqlParser.SET, 0)
        def TBLPROPERTIES(self):
            return self.getToken(sqlParser.TBLPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)

        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)

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



    def statement(self):

        localctx = sqlParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 1006
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                localctx = sqlParser.StatementDefaultContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 301
                self.query()
                pass

            elif la_ == 2:
                localctx = sqlParser.DmlStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 303
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.WITH:
                    self.state = 302
                    self.ctes()


                self.state = 305
                self.dmlStatementNoWith()
                pass

            elif la_ == 3:
                localctx = sqlParser.UseContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 306
                self.match(sqlParser.USE)
                self.state = 308
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
                if la_ == 1:
                    self.state = 307
                    self.match(sqlParser.NAMESPACE)


                self.state = 310
                self.multipartIdentifier()
                pass

            elif la_ == 4:
                localctx = sqlParser.CreateNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 311
                self.match(sqlParser.CREATE)
                self.state = 312
                self.namespace()
                self.state = 316
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
                if la_ == 1:
                    self.state = 313
                    self.match(sqlParser.IF)
                    self.state = 314
                    self.match(sqlParser.NOT)
                    self.state = 315
                    self.match(sqlParser.EXISTS)


                self.state = 318
                self.multipartIdentifier()
                self.state = 326
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.COMMENT or _la==sqlParser.LOCATION or _la==sqlParser.WITH:
                    self.state = 324
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [sqlParser.COMMENT]:
                        self.state = 319
                        self.commentSpec()
                        pass
                    elif token in [sqlParser.LOCATION]:
                        self.state = 320
                        self.locationSpec()
                        pass
                    elif token in [sqlParser.WITH]:
                        self.state = 321
                        self.match(sqlParser.WITH)
                        self.state = 322
                        _la = self._input.LA(1)
                        if not(_la==sqlParser.DBPROPERTIES or _la==sqlParser.PROPERTIES):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 323
                        self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

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

                pass

            elif la_ == 5:
                localctx = sqlParser.SetNamespacePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 329
                self.match(sqlParser.ALTER)
                self.state = 330
                self.namespace()
                self.state = 331
                self.multipartIdentifier()
                self.state = 332
                self.match(sqlParser.SET)
                self.state = 333
                _la = self._input.LA(1)
                if not(_la==sqlParser.DBPROPERTIES or _la==sqlParser.PROPERTIES):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 334
                self.tablePropertyList()
                pass

            elif la_ == 6:
                localctx = sqlParser.SetNamespaceLocationContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 336
                self.match(sqlParser.ALTER)
                self.state = 337
                self.namespace()
                self.state = 338
                self.multipartIdentifier()
                self.state = 339
                self.match(sqlParser.SET)
                self.state = 340
                self.locationSpec()
                pass

            elif la_ == 7:
                localctx = sqlParser.DropNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 342
                self.match(sqlParser.DROP)
                self.state = 343
                self.namespace()
                self.state = 346
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
                if la_ == 1:
                    self.state = 344
                    self.match(sqlParser.IF)
                    self.state = 345
                    self.match(sqlParser.EXISTS)


                self.state = 348
                self.multipartIdentifier()
                self.state = 350
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.CASCADE or _la==sqlParser.RESTRICT:
                    self.state = 349
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.CASCADE or _la==sqlParser.RESTRICT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                pass

            elif la_ == 8:
                localctx = sqlParser.ShowNamespacesContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 352
                self.match(sqlParser.SHOW)
                self.state = 353
                _la = self._input.LA(1)
                if not(_la==sqlParser.DATABASES or _la==sqlParser.NAMESPACES):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 356
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.FROM or _la==sqlParser.IN:
                    self.state = 354
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.FROM or _la==sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 355
                    self.multipartIdentifier()


                self.state = 362
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LIKE or _la==sqlParser.STRING:
                    self.state = 359
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.LIKE:
                        self.state = 358
                        self.match(sqlParser.LIKE)


                    self.state = 361
                    localctx.pattern = self.match(sqlParser.STRING)


                pass

            elif la_ == 9:
                localctx = sqlParser.CreateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 364
                self.createTableHeader()
                self.state = 369
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1:
                    self.state = 365
                    self.match(sqlParser.T__1)
                    self.state = 366
                    self.colTypeList()
                    self.state = 367
                    self.match(sqlParser.T__2)


                self.state = 371
                self.tableProvider()
                self.state = 372
                self.createTableClauses()
                self.state = 377
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1 or _la==sqlParser.AS or _la==sqlParser.FROM or _la==sqlParser.MAP or ((((_la - 187)) & ~0x3f) == 0 and ((1 << (_la - 187)) & ((1 << (sqlParser.REDUCE - 187)) | (1 << (sqlParser.SELECT - 187)) | (1 << (sqlParser.TABLE - 187)))) != 0) or _la==sqlParser.VALUES or _la==sqlParser.WITH:
                    self.state = 374
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.AS:
                        self.state = 373
                        self.match(sqlParser.AS)


                    self.state = 376
                    self.query()


                pass

            elif la_ == 10:
                localctx = sqlParser.CreateHiveTableContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 379
                self.createTableHeader()
                self.state = 384
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
                if la_ == 1:
                    self.state = 380
                    self.match(sqlParser.T__1)
                    self.state = 381
                    localctx.columns = self.colTypeList()
                    self.state = 382
                    self.match(sqlParser.T__2)


                self.state = 407
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.CLUSTERED or _la==sqlParser.COMMENT or _la==sqlParser.LOCATION or _la==sqlParser.PARTITIONED or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & ((1 << (sqlParser.ROW - 202)) | (1 << (sqlParser.SKEWED - 202)) | (1 << (sqlParser.STORED - 202)) | (1 << (sqlParser.TBLPROPERTIES - 202)))) != 0):
                    self.state = 405
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [sqlParser.COMMENT]:
                        self.state = 386
                        self.commentSpec()
                        pass
                    elif token in [sqlParser.PARTITIONED]:
                        self.state = 396
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
                        if la_ == 1:
                            self.state = 387
                            self.match(sqlParser.PARTITIONED)
                            self.state = 388
                            self.match(sqlParser.BY)
                            self.state = 389
                            self.match(sqlParser.T__1)
                            self.state = 390
                            localctx.partitionColumns = self.colTypeList()
                            self.state = 391
                            self.match(sqlParser.T__2)
                            pass

                        elif la_ == 2:
                            self.state = 393
                            self.match(sqlParser.PARTITIONED)
                            self.state = 394
                            self.match(sqlParser.BY)
                            self.state = 395
                            localctx.partitionColumnNames = self.identifierList()
                            pass


                        pass
                    elif token in [sqlParser.CLUSTERED]:
                        self.state = 398
                        self.bucketSpec()
                        pass
                    elif token in [sqlParser.SKEWED]:
                        self.state = 399
                        self.skewSpec()
                        pass
                    elif token in [sqlParser.ROW]:
                        self.state = 400
                        self.rowFormat()
                        pass
                    elif token in [sqlParser.STORED]:
                        self.state = 401
                        self.createFileFormat()
                        pass
                    elif token in [sqlParser.LOCATION]:
                        self.state = 402
                        self.locationSpec()
                        pass
                    elif token in [sqlParser.TBLPROPERTIES]:
                        self.state = 403
                        self.match(sqlParser.TBLPROPERTIES)
                        self.state = 404
                        localctx.tableProps = self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

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

                self.state = 414
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1 or _la==sqlParser.AS or _la==sqlParser.FROM or _la==sqlParser.MAP or ((((_la - 187)) & ~0x3f) == 0 and ((1 << (_la - 187)) & ((1 << (sqlParser.REDUCE - 187)) | (1 << (sqlParser.SELECT - 187)) | (1 << (sqlParser.TABLE - 187)))) != 0) or _la==sqlParser.VALUES or _la==sqlParser.WITH:
                    self.state = 411
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.AS:
                        self.state = 410
                        self.match(sqlParser.AS)


                    self.state = 413
                    self.query()


                pass

            elif la_ == 11:
                localctx = sqlParser.CreateTableLikeContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 416
                self.match(sqlParser.CREATE)
                self.state = 417
                self.match(sqlParser.TABLE)
                self.state = 421
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
                if la_ == 1:
                    self.state = 418
                    self.match(sqlParser.IF)
                    self.state = 419
                    self.match(sqlParser.NOT)
                    self.state = 420
                    self.match(sqlParser.EXISTS)


                self.state = 423
                localctx.target = self.tableIdentifier()
                self.state = 424
                self.match(sqlParser.LIKE)
                self.state = 425
                localctx.source = self.tableIdentifier()
                self.state = 434
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.LOCATION or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & ((1 << (sqlParser.ROW - 202)) | (1 << (sqlParser.STORED - 202)) | (1 << (sqlParser.TBLPROPERTIES - 202)) | (1 << (sqlParser.USING - 202)))) != 0):
                    self.state = 432
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [sqlParser.USING]:
                        self.state = 426
                        self.tableProvider()
                        pass
                    elif token in [sqlParser.ROW]:
                        self.state = 427
                        self.rowFormat()
                        pass
                    elif token in [sqlParser.STORED]:
                        self.state = 428
                        self.createFileFormat()
                        pass
                    elif token in [sqlParser.LOCATION]:
                        self.state = 429
                        self.locationSpec()
                        pass
                    elif token in [sqlParser.TBLPROPERTIES]:
                        self.state = 430
                        self.match(sqlParser.TBLPROPERTIES)
                        self.state = 431
                        localctx.tableProps = self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

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

                pass

            elif la_ == 12:
                localctx = sqlParser.ReplaceTableContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 437
                self.replaceTableHeader()
                self.state = 442
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1:
                    self.state = 438
                    self.match(sqlParser.T__1)
                    self.state = 439
                    self.colTypeList()
                    self.state = 440
                    self.match(sqlParser.T__2)


                self.state = 444
                self.tableProvider()
                self.state = 445
                self.createTableClauses()
                self.state = 450
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1 or _la==sqlParser.AS or _la==sqlParser.FROM or _la==sqlParser.MAP or ((((_la - 187)) & ~0x3f) == 0 and ((1 << (_la - 187)) & ((1 << (sqlParser.REDUCE - 187)) | (1 << (sqlParser.SELECT - 187)) | (1 << (sqlParser.TABLE - 187)))) != 0) or _la==sqlParser.VALUES or _la==sqlParser.WITH:
                    self.state = 447
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.AS:
                        self.state = 446
                        self.match(sqlParser.AS)


                    self.state = 449
                    self.query()


                pass

            elif la_ == 13:
                localctx = sqlParser.AnalyzeContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 452
                self.match(sqlParser.ANALYZE)
                self.state = 453
                self.match(sqlParser.TABLE)
                self.state = 454
                self.multipartIdentifier()
                self.state = 456
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 455
                    self.partitionSpec()


                self.state = 458
                self.match(sqlParser.COMPUTE)
                self.state = 459
                self.match(sqlParser.STATISTICS)
                self.state = 467
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
                if la_ == 1:
                    self.state = 460
                    self.identifier()

                elif la_ == 2:
                    self.state = 461
                    self.match(sqlParser.FOR)
                    self.state = 462
                    self.match(sqlParser.COLUMNS)
                    self.state = 463
                    self.identifierSeq()

                elif la_ == 3:
                    self.state = 464
                    self.match(sqlParser.FOR)
                    self.state = 465
                    self.match(sqlParser.ALL)
                    self.state = 466
                    self.match(sqlParser.COLUMNS)


                pass

            elif la_ == 14:
                localctx = sqlParser.AddTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 469
                self.match(sqlParser.ALTER)
                self.state = 470
                self.match(sqlParser.TABLE)
                self.state = 471
                self.multipartIdentifier()
                self.state = 472
                self.match(sqlParser.ADD)
                self.state = 473
                _la = self._input.LA(1)
                if not(_la==sqlParser.COLUMN or _la==sqlParser.COLUMNS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 474
                localctx.columns = self.qualifiedColTypeWithPositionList()
                pass

            elif la_ == 15:
                localctx = sqlParser.AddTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 476
                self.match(sqlParser.ALTER)
                self.state = 477
                self.match(sqlParser.TABLE)
                self.state = 478
                self.multipartIdentifier()
                self.state = 479
                self.match(sqlParser.ADD)
                self.state = 480
                _la = self._input.LA(1)
                if not(_la==sqlParser.COLUMN or _la==sqlParser.COLUMNS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 481
                self.match(sqlParser.T__1)
                self.state = 482
                localctx.columns = self.qualifiedColTypeWithPositionList()
                self.state = 483
                self.match(sqlParser.T__2)
                pass

            elif la_ == 16:
                localctx = sqlParser.RenameTableColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 485
                self.match(sqlParser.ALTER)
                self.state = 486
                self.match(sqlParser.TABLE)
                self.state = 487
                localctx.table = self.multipartIdentifier()
                self.state = 488
                self.match(sqlParser.RENAME)
                self.state = 489
                self.match(sqlParser.COLUMN)
                self.state = 490
                localctx.qpdfrom = self.multipartIdentifier()
                self.state = 491
                self.match(sqlParser.TO)
                self.state = 492
                localctx.to = self.errorCapturingIdentifier()
                pass

            elif la_ == 17:
                localctx = sqlParser.DropTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 494
                self.match(sqlParser.ALTER)
                self.state = 495
                self.match(sqlParser.TABLE)
                self.state = 496
                self.multipartIdentifier()
                self.state = 497
                self.match(sqlParser.DROP)
                self.state = 498
                _la = self._input.LA(1)
                if not(_la==sqlParser.COLUMN or _la==sqlParser.COLUMNS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 499
                self.match(sqlParser.T__1)
                self.state = 500
                localctx.columns = self.multipartIdentifierList()
                self.state = 501
                self.match(sqlParser.T__2)
                pass

            elif la_ == 18:
                localctx = sqlParser.DropTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 503
                self.match(sqlParser.ALTER)
                self.state = 504
                self.match(sqlParser.TABLE)
                self.state = 505
                self.multipartIdentifier()
                self.state = 506
                self.match(sqlParser.DROP)
                self.state = 507
                _la = self._input.LA(1)
                if not(_la==sqlParser.COLUMN or _la==sqlParser.COLUMNS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 508
                localctx.columns = self.multipartIdentifierList()
                pass

            elif la_ == 19:
                localctx = sqlParser.RenameTableContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 510
                self.match(sqlParser.ALTER)
                self.state = 511
                _la = self._input.LA(1)
                if not(_la==sqlParser.TABLE or _la==sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 512
                localctx.qpdfrom = self.multipartIdentifier()
                self.state = 513
                self.match(sqlParser.RENAME)
                self.state = 514
                self.match(sqlParser.TO)
                self.state = 515
                localctx.to = self.multipartIdentifier()
                pass

            elif la_ == 20:
                localctx = sqlParser.SetTablePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 517
                self.match(sqlParser.ALTER)
                self.state = 518
                _la = self._input.LA(1)
                if not(_la==sqlParser.TABLE or _la==sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 519
                self.multipartIdentifier()
                self.state = 520
                self.match(sqlParser.SET)
                self.state = 521
                self.match(sqlParser.TBLPROPERTIES)
                self.state = 522
                self.tablePropertyList()
                pass

            elif la_ == 21:
                localctx = sqlParser.UnsetTablePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 524
                self.match(sqlParser.ALTER)
                self.state = 525
                _la = self._input.LA(1)
                if not(_la==sqlParser.TABLE or _la==sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 526
                self.multipartIdentifier()
                self.state = 527
                self.match(sqlParser.UNSET)
                self.state = 528
                self.match(sqlParser.TBLPROPERTIES)
                self.state = 531
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.IF:
                    self.state = 529
                    self.match(sqlParser.IF)
                    self.state = 530
                    self.match(sqlParser.EXISTS)


                self.state = 533
                self.tablePropertyList()
                pass

            elif la_ == 22:
                localctx = sqlParser.AlterTableAlterColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 22)
                self.state = 535
                self.match(sqlParser.ALTER)
                self.state = 536
                self.match(sqlParser.TABLE)
                self.state = 537
                localctx.table = self.multipartIdentifier()
                self.state = 538
                _la = self._input.LA(1)
                if not(_la==sqlParser.ALTER or _la==sqlParser.CHANGE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 540
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
                if la_ == 1:
                    self.state = 539
                    self.match(sqlParser.COLUMN)


                self.state = 542
                localctx.column = self.multipartIdentifier()
                self.state = 544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.AFTER or _la==sqlParser.COMMENT or _la==sqlParser.DROP or _la==sqlParser.FIRST or _la==sqlParser.SET or _la==sqlParser.TYPE:
                    self.state = 543
                    self.alterColumnAction()


                pass

            elif la_ == 23:
                localctx = sqlParser.HiveChangeColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 23)
                self.state = 546
                self.match(sqlParser.ALTER)
                self.state = 547
                self.match(sqlParser.TABLE)
                self.state = 548
                localctx.table = self.multipartIdentifier()
                self.state = 550
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 549
                    self.partitionSpec()


                self.state = 552
                self.match(sqlParser.CHANGE)
                self.state = 554
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
                if la_ == 1:
                    self.state = 553
                    self.match(sqlParser.COLUMN)


                self.state = 556
                localctx.colName = self.multipartIdentifier()
                self.state = 557
                self.colType()
                self.state = 559
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.AFTER or _la==sqlParser.FIRST:
                    self.state = 558
                    self.colPosition()


                pass

            elif la_ == 24:
                localctx = sqlParser.HiveReplaceColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 24)
                self.state = 561
                self.match(sqlParser.ALTER)
                self.state = 562
                self.match(sqlParser.TABLE)
                self.state = 563
                localctx.table = self.multipartIdentifier()
                self.state = 565
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 564
                    self.partitionSpec()


                self.state = 567
                self.match(sqlParser.REPLACE)
                self.state = 568
                self.match(sqlParser.COLUMNS)
                self.state = 569
                self.match(sqlParser.T__1)
                self.state = 570
                localctx.columns = self.qualifiedColTypeWithPositionList()
                self.state = 571
                self.match(sqlParser.T__2)
                pass

            elif la_ == 25:
                localctx = sqlParser.SetTableSerDeContext(self, localctx)
                self.enterOuterAlt(localctx, 25)
                self.state = 573
                self.match(sqlParser.ALTER)
                self.state = 574
                self.match(sqlParser.TABLE)
                self.state = 575
                self.multipartIdentifier()
                self.state = 577
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 576
                    self.partitionSpec()


                self.state = 579
                self.match(sqlParser.SET)
                self.state = 580
                self.match(sqlParser.SERDE)
                self.state = 581
                self.match(sqlParser.STRING)
                self.state = 585
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.WITH:
                    self.state = 582
                    self.match(sqlParser.WITH)
                    self.state = 583
                    self.match(sqlParser.SERDEPROPERTIES)
                    self.state = 584
                    self.tablePropertyList()


                pass

            elif la_ == 26:
                localctx = sqlParser.SetTableSerDeContext(self, localctx)
                self.enterOuterAlt(localctx, 26)
                self.state = 587
                self.match(sqlParser.ALTER)
                self.state = 588
                self.match(sqlParser.TABLE)
                self.state = 589
                self.multipartIdentifier()
                self.state = 591
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 590
                    self.partitionSpec()


                self.state = 593
                self.match(sqlParser.SET)
                self.state = 594
                self.match(sqlParser.SERDEPROPERTIES)
                self.state = 595
                self.tablePropertyList()
                pass

            elif la_ == 27:
                localctx = sqlParser.AddTablePartitionContext(self, localctx)
                self.enterOuterAlt(localctx, 27)
                self.state = 597
                self.match(sqlParser.ALTER)
                self.state = 598
                _la = self._input.LA(1)
                if not(_la==sqlParser.TABLE or _la==sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 599
                self.multipartIdentifier()
                self.state = 600
                self.match(sqlParser.ADD)
                self.state = 604
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.IF:
                    self.state = 601
                    self.match(sqlParser.IF)
                    self.state = 602
                    self.match(sqlParser.NOT)
                    self.state = 603
                    self.match(sqlParser.EXISTS)


                self.state = 607 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 606
                    self.partitionSpecLocation()
                    self.state = 609 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==sqlParser.PARTITION):
                        break

                pass

            elif la_ == 28:
                localctx = sqlParser.RenameTablePartitionContext(self, localctx)
                self.enterOuterAlt(localctx, 28)
                self.state = 611
                self.match(sqlParser.ALTER)
                self.state = 612
                self.match(sqlParser.TABLE)
                self.state = 613
                self.multipartIdentifier()
                self.state = 614
                localctx.qpdfrom = self.partitionSpec()
                self.state = 615
                self.match(sqlParser.RENAME)
                self.state = 616
                self.match(sqlParser.TO)
                self.state = 617
                localctx.to = self.partitionSpec()
                pass

            elif la_ == 29:
                localctx = sqlParser.DropTablePartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 29)
                self.state = 619
                self.match(sqlParser.ALTER)
                self.state = 620
                _la = self._input.LA(1)
                if not(_la==sqlParser.TABLE or _la==sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 621
                self.multipartIdentifier()
                self.state = 622
                self.match(sqlParser.DROP)
                self.state = 625
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.IF:
                    self.state = 623
                    self.match(sqlParser.IF)
                    self.state = 624
                    self.match(sqlParser.EXISTS)


                self.state = 627
                self.partitionSpec()
                self.state = 632
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 628
                    self.match(sqlParser.T__3)
                    self.state = 629
                    self.partitionSpec()
                    self.state = 634
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 636
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PURGE:
                    self.state = 635
                    self.match(sqlParser.PURGE)


                pass

            elif la_ == 30:
                localctx = sqlParser.SetTableLocationContext(self, localctx)
                self.enterOuterAlt(localctx, 30)
                self.state = 638
                self.match(sqlParser.ALTER)
                self.state = 639
                self.match(sqlParser.TABLE)
                self.state = 640
                self.multipartIdentifier()
                self.state = 642
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 641
                    self.partitionSpec()


                self.state = 644
                self.match(sqlParser.SET)
                self.state = 645
                self.locationSpec()
                pass

            elif la_ == 31:
                localctx = sqlParser.RecoverPartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 31)
                self.state = 647
                self.match(sqlParser.ALTER)
                self.state = 648
                self.match(sqlParser.TABLE)
                self.state = 649
                self.multipartIdentifier()
                self.state = 650
                self.match(sqlParser.RECOVER)
                self.state = 651
                self.match(sqlParser.PARTITIONS)
                pass

            elif la_ == 32:
                localctx = sqlParser.DropTableContext(self, localctx)
                self.enterOuterAlt(localctx, 32)
                self.state = 653
                self.match(sqlParser.DROP)
                self.state = 654
                self.match(sqlParser.TABLE)
                self.state = 657
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
                if la_ == 1:
                    self.state = 655
                    self.match(sqlParser.IF)
                    self.state = 656
                    self.match(sqlParser.EXISTS)


                self.state = 659
                self.multipartIdentifier()
                self.state = 661
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PURGE:
                    self.state = 660
                    self.match(sqlParser.PURGE)


                pass

            elif la_ == 33:
                localctx = sqlParser.DropViewContext(self, localctx)
                self.enterOuterAlt(localctx, 33)
                self.state = 663
                self.match(sqlParser.DROP)
                self.state = 664
                self.match(sqlParser.VIEW)
                self.state = 667
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
                if la_ == 1:
                    self.state = 665
                    self.match(sqlParser.IF)
                    self.state = 666
                    self.match(sqlParser.EXISTS)


                self.state = 669
                self.multipartIdentifier()
                pass

            elif la_ == 34:
                localctx = sqlParser.CreateViewContext(self, localctx)
                self.enterOuterAlt(localctx, 34)
                self.state = 670
                self.match(sqlParser.CREATE)
                self.state = 673
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OR:
                    self.state = 671
                    self.match(sqlParser.OR)
                    self.state = 672
                    self.match(sqlParser.REPLACE)


                self.state = 679
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.GLOBAL or _la==sqlParser.TEMPORARY:
                    self.state = 676
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.GLOBAL:
                        self.state = 675
                        self.match(sqlParser.GLOBAL)


                    self.state = 678
                    self.match(sqlParser.TEMPORARY)


                self.state = 681
                self.match(sqlParser.VIEW)
                self.state = 685
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
                if la_ == 1:
                    self.state = 682
                    self.match(sqlParser.IF)
                    self.state = 683
                    self.match(sqlParser.NOT)
                    self.state = 684
                    self.match(sqlParser.EXISTS)


                self.state = 687
                self.multipartIdentifier()
                self.state = 689
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1:
                    self.state = 688
                    self.identifierCommentList()


                self.state = 699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.COMMENT or _la==sqlParser.PARTITIONED or _la==sqlParser.TBLPROPERTIES:
                    self.state = 697
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [sqlParser.COMMENT]:
                        self.state = 691
                        self.commentSpec()
                        pass
                    elif token in [sqlParser.PARTITIONED]:
                        self.state = 692
                        self.match(sqlParser.PARTITIONED)
                        self.state = 693
                        self.match(sqlParser.ON)
                        self.state = 694
                        self.identifierList()
                        pass
                    elif token in [sqlParser.TBLPROPERTIES]:
                        self.state = 695
                        self.match(sqlParser.TBLPROPERTIES)
                        self.state = 696
                        self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

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

                self.state = 702
                self.match(sqlParser.AS)
                self.state = 703
                self.query()
                pass

            elif la_ == 35:
                localctx = sqlParser.CreateTempViewUsingContext(self, localctx)
                self.enterOuterAlt(localctx, 35)
                self.state = 705
                self.match(sqlParser.CREATE)
                self.state = 708
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OR:
                    self.state = 706
                    self.match(sqlParser.OR)
                    self.state = 707
                    self.match(sqlParser.REPLACE)


                self.state = 711
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.GLOBAL:
                    self.state = 710
                    self.match(sqlParser.GLOBAL)


                self.state = 713
                self.match(sqlParser.TEMPORARY)
                self.state = 714
                self.match(sqlParser.VIEW)
                self.state = 715
                self.tableIdentifier()
                self.state = 720
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1:
                    self.state = 716
                    self.match(sqlParser.T__1)
                    self.state = 717
                    self.colTypeList()
                    self.state = 718
                    self.match(sqlParser.T__2)


                self.state = 722
                self.tableProvider()
                self.state = 725
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OPTIONS:
                    self.state = 723
                    self.match(sqlParser.OPTIONS)
                    self.state = 724
                    self.tablePropertyList()


                pass

            elif la_ == 36:
                localctx = sqlParser.AlterViewQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 36)
                self.state = 727
                self.match(sqlParser.ALTER)
                self.state = 728
                self.match(sqlParser.VIEW)
                self.state = 729
                self.multipartIdentifier()
                self.state = 731
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.AS:
                    self.state = 730
                    self.match(sqlParser.AS)


                self.state = 733
                self.query()
                pass

            elif la_ == 37:
                localctx = sqlParser.CreateFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 37)
                self.state = 735
                self.match(sqlParser.CREATE)
                self.state = 738
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OR:
                    self.state = 736
                    self.match(sqlParser.OR)
                    self.state = 737
                    self.match(sqlParser.REPLACE)


                self.state = 741
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.TEMPORARY:
                    self.state = 740
                    self.match(sqlParser.TEMPORARY)


                self.state = 743
                self.match(sqlParser.FUNCTION)
                self.state = 747
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
                if la_ == 1:
                    self.state = 744
                    self.match(sqlParser.IF)
                    self.state = 745
                    self.match(sqlParser.NOT)
                    self.state = 746
                    self.match(sqlParser.EXISTS)


                self.state = 749
                self.multipartIdentifier()
                self.state = 750
                self.match(sqlParser.AS)
                self.state = 751
                localctx.className = self.match(sqlParser.STRING)
                self.state = 761
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.USING:
                    self.state = 752
                    self.match(sqlParser.USING)
                    self.state = 753
                    self.resource()
                    self.state = 758
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==sqlParser.T__3:
                        self.state = 754
                        self.match(sqlParser.T__3)
                        self.state = 755
                        self.resource()
                        self.state = 760
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                pass

            elif la_ == 38:
                localctx = sqlParser.DropFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 38)
                self.state = 763
                self.match(sqlParser.DROP)
                self.state = 765
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.TEMPORARY:
                    self.state = 764
                    self.match(sqlParser.TEMPORARY)


                self.state = 767
                self.match(sqlParser.FUNCTION)
                self.state = 770
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
                if la_ == 1:
                    self.state = 768
                    self.match(sqlParser.IF)
                    self.state = 769
                    self.match(sqlParser.EXISTS)


                self.state = 772
                self.multipartIdentifier()
                pass

            elif la_ == 39:
                localctx = sqlParser.ExplainContext(self, localctx)
                self.enterOuterAlt(localctx, 39)
                self.state = 773
                self.match(sqlParser.EXPLAIN)
                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.CODEGEN or _la==sqlParser.COST or ((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & ((1 << (sqlParser.EXTENDED - 86)) | (1 << (sqlParser.FORMATTED - 86)) | (1 << (sqlParser.LOGICAL - 86)))) != 0):
                    self.state = 774
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.CODEGEN or _la==sqlParser.COST or ((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & ((1 << (sqlParser.EXTENDED - 86)) | (1 << (sqlParser.FORMATTED - 86)) | (1 << (sqlParser.LOGICAL - 86)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 777
                self.statement()
                pass

            elif la_ == 40:
                localctx = sqlParser.ShowTablesContext(self, localctx)
                self.enterOuterAlt(localctx, 40)
                self.state = 778
                self.match(sqlParser.SHOW)
                self.state = 779
                self.match(sqlParser.TABLES)
                self.state = 782
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.FROM or _la==sqlParser.IN:
                    self.state = 780
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.FROM or _la==sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 781
                    self.multipartIdentifier()


                self.state = 788
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LIKE or _la==sqlParser.STRING:
                    self.state = 785
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.LIKE:
                        self.state = 784
                        self.match(sqlParser.LIKE)


                    self.state = 787
                    localctx.pattern = self.match(sqlParser.STRING)


                pass

            elif la_ == 41:
                localctx = sqlParser.ShowTableContext(self, localctx)
                self.enterOuterAlt(localctx, 41)
                self.state = 790
                self.match(sqlParser.SHOW)
                self.state = 791
                self.match(sqlParser.TABLE)
                self.state = 792
                self.match(sqlParser.EXTENDED)
                self.state = 795
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.FROM or _la==sqlParser.IN:
                    self.state = 793
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.FROM or _la==sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 794
                    localctx.ns = self.multipartIdentifier()


                self.state = 797
                self.match(sqlParser.LIKE)
                self.state = 798
                localctx.pattern = self.match(sqlParser.STRING)
                self.state = 800
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 799
                    self.partitionSpec()


                pass

            elif la_ == 42:
                localctx = sqlParser.ShowTblPropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 42)
                self.state = 802
                self.match(sqlParser.SHOW)
                self.state = 803
                self.match(sqlParser.TBLPROPERTIES)
                self.state = 804
                localctx.table = self.multipartIdentifier()
                self.state = 809
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1:
                    self.state = 805
                    self.match(sqlParser.T__1)
                    self.state = 806
                    localctx.key = self.tablePropertyKey()
                    self.state = 807
                    self.match(sqlParser.T__2)


                pass

            elif la_ == 43:
                localctx = sqlParser.ShowColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 43)
                self.state = 811
                self.match(sqlParser.SHOW)
                self.state = 812
                self.match(sqlParser.COLUMNS)
                self.state = 813
                _la = self._input.LA(1)
                if not(_la==sqlParser.FROM or _la==sqlParser.IN):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 814
                localctx.table = self.multipartIdentifier()
                self.state = 817
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.FROM or _la==sqlParser.IN:
                    self.state = 815
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.FROM or _la==sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 816
                    localctx.ns = self.multipartIdentifier()


                pass

            elif la_ == 44:
                localctx = sqlParser.ShowViewsContext(self, localctx)
                self.enterOuterAlt(localctx, 44)
                self.state = 819
                self.match(sqlParser.SHOW)
                self.state = 820
                self.match(sqlParser.VIEWS)
                self.state = 823
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.FROM or _la==sqlParser.IN:
                    self.state = 821
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.FROM or _la==sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 822
                    self.multipartIdentifier()


                self.state = 829
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LIKE or _la==sqlParser.STRING:
                    self.state = 826
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.LIKE:
                        self.state = 825
                        self.match(sqlParser.LIKE)


                    self.state = 828
                    localctx.pattern = self.match(sqlParser.STRING)


                pass

            elif la_ == 45:
                localctx = sqlParser.ShowPartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 45)
                self.state = 831
                self.match(sqlParser.SHOW)
                self.state = 832
                self.match(sqlParser.PARTITIONS)
                self.state = 833
                self.multipartIdentifier()
                self.state = 835
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 834
                    self.partitionSpec()


                pass

            elif la_ == 46:
                localctx = sqlParser.ShowFunctionsContext(self, localctx)
                self.enterOuterAlt(localctx, 46)
                self.state = 837
                self.match(sqlParser.SHOW)
                self.state = 839
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
                if la_ == 1:
                    self.state = 838
                    self.identifier()


                self.state = 841
                self.match(sqlParser.FUNCTIONS)
                self.state = 849
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
                if la_ == 1:
                    self.state = 843
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
                    if la_ == 1:
                        self.state = 842
                        self.match(sqlParser.LIKE)


                    self.state = 847
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
                    if la_ == 1:
                        self.state = 845
                        self.multipartIdentifier()
                        pass

                    elif la_ == 2:
                        self.state = 846
                        localctx.pattern = self.match(sqlParser.STRING)
                        pass




                pass

            elif la_ == 47:
                localctx = sqlParser.ShowCreateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 47)
                self.state = 851
                self.match(sqlParser.SHOW)
                self.state = 852
                self.match(sqlParser.CREATE)
                self.state = 853
                self.match(sqlParser.TABLE)
                self.state = 854
                self.multipartIdentifier()
                self.state = 857
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.AS:
                    self.state = 855
                    self.match(sqlParser.AS)
                    self.state = 856
                    self.match(sqlParser.SERDE)


                pass

            elif la_ == 48:
                localctx = sqlParser.ShowCurrentNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 48)
                self.state = 859
                self.match(sqlParser.SHOW)
                self.state = 860
                self.match(sqlParser.CURRENT)
                self.state = 861
                self.match(sqlParser.NAMESPACE)
                pass

            elif la_ == 49:
                localctx = sqlParser.DescribeFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 49)
                self.state = 862
                _la = self._input.LA(1)
                if not(_la==sqlParser.DESC or _la==sqlParser.DESCRIBE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 863
                self.match(sqlParser.FUNCTION)
                self.state = 865
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
                if la_ == 1:
                    self.state = 864
                    self.match(sqlParser.EXTENDED)


                self.state = 867
                self.describeFuncName()
                pass

            elif la_ == 50:
                localctx = sqlParser.DescribeNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 50)
                self.state = 868
                _la = self._input.LA(1)
                if not(_la==sqlParser.DESC or _la==sqlParser.DESCRIBE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 869
                self.namespace()
                self.state = 871
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
                if la_ == 1:
                    self.state = 870
                    self.match(sqlParser.EXTENDED)


                self.state = 873
                self.multipartIdentifier()
                pass

            elif la_ == 51:
                localctx = sqlParser.DescribeRelationContext(self, localctx)
                self.enterOuterAlt(localctx, 51)
                self.state = 875
                _la = self._input.LA(1)
                if not(_la==sqlParser.DESC or _la==sqlParser.DESCRIBE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 877
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
                if la_ == 1:
                    self.state = 876
                    self.match(sqlParser.TABLE)


                self.state = 880
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
                if la_ == 1:
                    self.state = 879
                    localctx.option = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.EXTENDED or _la==sqlParser.FORMATTED):
                        localctx.option = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 882
                self.multipartIdentifier()
                self.state = 884
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
                if la_ == 1:
                    self.state = 883
                    self.partitionSpec()


                self.state = 887
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
                if la_ == 1:
                    self.state = 886
                    self.describeColName()


                pass

            elif la_ == 52:
                localctx = sqlParser.DescribeQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 52)
                self.state = 889
                _la = self._input.LA(1)
                if not(_la==sqlParser.DESC or _la==sqlParser.DESCRIBE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 891
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.QUERY:
                    self.state = 890
                    self.match(sqlParser.QUERY)


                self.state = 893
                self.query()
                pass

            elif la_ == 53:
                localctx = sqlParser.CommentNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 53)
                self.state = 894
                self.match(sqlParser.COMMENT)
                self.state = 895
                self.match(sqlParser.ON)
                self.state = 896
                self.namespace()
                self.state = 897
                self.multipartIdentifier()
                self.state = 898
                self.match(sqlParser.IS)
                self.state = 899
                localctx.comment = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.NULL or _la==sqlParser.STRING):
                    localctx.comment = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 54:
                localctx = sqlParser.CommentTableContext(self, localctx)
                self.enterOuterAlt(localctx, 54)
                self.state = 901
                self.match(sqlParser.COMMENT)
                self.state = 902
                self.match(sqlParser.ON)
                self.state = 903
                self.match(sqlParser.TABLE)
                self.state = 904
                self.multipartIdentifier()
                self.state = 905
                self.match(sqlParser.IS)
                self.state = 906
                localctx.comment = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.NULL or _la==sqlParser.STRING):
                    localctx.comment = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 55:
                localctx = sqlParser.RefreshTableContext(self, localctx)
                self.enterOuterAlt(localctx, 55)
                self.state = 908
                self.match(sqlParser.REFRESH)
                self.state = 909
                self.match(sqlParser.TABLE)
                self.state = 910
                self.multipartIdentifier()
                pass

            elif la_ == 56:
                localctx = sqlParser.RefreshResourceContext(self, localctx)
                self.enterOuterAlt(localctx, 56)
                self.state = 911
                self.match(sqlParser.REFRESH)
                self.state = 919
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,91,self._ctx)
                if la_ == 1:
                    self.state = 912
                    self.match(sqlParser.STRING)
                    pass

                elif la_ == 2:
                    self.state = 916
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,90,self._ctx)
                    while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1+1:
                            self.state = 913
                            self.matchWildcard() 
                        self.state = 918
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,90,self._ctx)

                    pass


                pass

            elif la_ == 57:
                localctx = sqlParser.CacheTableContext(self, localctx)
                self.enterOuterAlt(localctx, 57)
                self.state = 921
                self.match(sqlParser.CACHE)
                self.state = 923
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LAZY:
                    self.state = 922
                    self.match(sqlParser.LAZY)


                self.state = 925
                self.match(sqlParser.TABLE)
                self.state = 926
                self.multipartIdentifier()
                self.state = 929
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OPTIONS:
                    self.state = 927
                    self.match(sqlParser.OPTIONS)
                    self.state = 928
                    localctx.options = self.tablePropertyList()


                self.state = 935
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__1 or _la==sqlParser.AS or _la==sqlParser.FROM or _la==sqlParser.MAP or ((((_la - 187)) & ~0x3f) == 0 and ((1 << (_la - 187)) & ((1 << (sqlParser.REDUCE - 187)) | (1 << (sqlParser.SELECT - 187)) | (1 << (sqlParser.TABLE - 187)))) != 0) or _la==sqlParser.VALUES or _la==sqlParser.WITH:
                    self.state = 932
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.AS:
                        self.state = 931
                        self.match(sqlParser.AS)


                    self.state = 934
                    self.query()


                pass

            elif la_ == 58:
                localctx = sqlParser.UncacheTableContext(self, localctx)
                self.enterOuterAlt(localctx, 58)
                self.state = 937
                self.match(sqlParser.UNCACHE)
                self.state = 938
                self.match(sqlParser.TABLE)
                self.state = 941
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
                if la_ == 1:
                    self.state = 939
                    self.match(sqlParser.IF)
                    self.state = 940
                    self.match(sqlParser.EXISTS)


                self.state = 943
                self.multipartIdentifier()
                pass

            elif la_ == 59:
                localctx = sqlParser.ClearCacheContext(self, localctx)
                self.enterOuterAlt(localctx, 59)
                self.state = 944
                self.match(sqlParser.CLEAR)
                self.state = 945
                self.match(sqlParser.CACHE)
                pass

            elif la_ == 60:
                localctx = sqlParser.LoadDataContext(self, localctx)
                self.enterOuterAlt(localctx, 60)
                self.state = 946
                self.match(sqlParser.LOAD)
                self.state = 947
                self.match(sqlParser.DATA)
                self.state = 949
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LOCAL:
                    self.state = 948
                    self.match(sqlParser.LOCAL)


                self.state = 951
                self.match(sqlParser.INPATH)
                self.state = 952
                localctx.path = self.match(sqlParser.STRING)
                self.state = 954
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OVERWRITE:
                    self.state = 953
                    self.match(sqlParser.OVERWRITE)


                self.state = 956
                self.match(sqlParser.INTO)
                self.state = 957
                self.match(sqlParser.TABLE)
                self.state = 958
                self.multipartIdentifier()
                self.state = 960
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 959
                    self.partitionSpec()


                pass

            elif la_ == 61:
                localctx = sqlParser.TruncateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 61)
                self.state = 962
                self.match(sqlParser.TRUNCATE)
                self.state = 963
                self.match(sqlParser.TABLE)
                self.state = 964
                self.multipartIdentifier()
                self.state = 966
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 965
                    self.partitionSpec()


                pass

            elif la_ == 62:
                localctx = sqlParser.RepairTableContext(self, localctx)
                self.enterOuterAlt(localctx, 62)
                self.state = 968
                self.match(sqlParser.MSCK)
                self.state = 969
                self.match(sqlParser.REPAIR)
                self.state = 970
                self.match(sqlParser.TABLE)
                self.state = 971
                self.multipartIdentifier()
                pass

            elif la_ == 63:
                localctx = sqlParser.ManageResourceContext(self, localctx)
                self.enterOuterAlt(localctx, 63)
                self.state = 972
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.ADD or _la==sqlParser.LIST):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 973
                self.identifier()
                self.state = 981
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
                if la_ == 1:
                    self.state = 974
                    self.match(sqlParser.STRING)
                    pass

                elif la_ == 2:
                    self.state = 978
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
                    while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1+1:
                            self.state = 975
                            self.matchWildcard() 
                        self.state = 980
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,101,self._ctx)

                    pass


                pass

            elif la_ == 64:
                localctx = sqlParser.FailNativeCommandContext(self, localctx)
                self.enterOuterAlt(localctx, 64)
                self.state = 983
                self.match(sqlParser.SET)
                self.state = 984
                self.match(sqlParser.ROLE)
                self.state = 988
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 985
                        self.matchWildcard() 
                    self.state = 990
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,103,self._ctx)

                pass

            elif la_ == 65:
                localctx = sqlParser.SetConfigurationContext(self, localctx)
                self.enterOuterAlt(localctx, 65)
                self.state = 991
                self.match(sqlParser.SET)
                self.state = 995
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,104,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 992
                        self.matchWildcard() 
                    self.state = 997
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,104,self._ctx)

                pass

            elif la_ == 66:
                localctx = sqlParser.ResetConfigurationContext(self, localctx)
                self.enterOuterAlt(localctx, 66)
                self.state = 998
                self.match(sqlParser.RESET)
                pass

            elif la_ == 67:
                localctx = sqlParser.FailNativeCommandContext(self, localctx)
                self.enterOuterAlt(localctx, 67)
                self.state = 999
                self.unsupportedHiveNativeCommands()
                self.state = 1003
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,105,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 1000
                        self.matchWildcard() 
                    self.state = 1005
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,105,self._ctx)

                pass


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


    class UnsupportedHiveNativeCommandsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.kw1 = None # Token
            self.kw2 = None # Token
            self.kw3 = None # Token
            self.kw4 = None # Token
            self.kw5 = None # Token
            self.kw6 = None # Token

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

        def ROLE(self):
            return self.getToken(sqlParser.ROLE, 0)

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

        def GRANT(self):
            return self.getToken(sqlParser.GRANT, 0)

        def REVOKE(self):
            return self.getToken(sqlParser.REVOKE, 0)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)

        def PRINCIPALS(self):
            return self.getToken(sqlParser.PRINCIPALS, 0)

        def ROLES(self):
            return self.getToken(sqlParser.ROLES, 0)

        def CURRENT(self):
            return self.getToken(sqlParser.CURRENT, 0)

        def EXPORT(self):
            return self.getToken(sqlParser.EXPORT, 0)

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

        def IMPORT(self):
            return self.getToken(sqlParser.IMPORT, 0)

        def COMPACTIONS(self):
            return self.getToken(sqlParser.COMPACTIONS, 0)

        def TRANSACTIONS(self):
            return self.getToken(sqlParser.TRANSACTIONS, 0)

        def INDEXES(self):
            return self.getToken(sqlParser.INDEXES, 0)

        def LOCKS(self):
            return self.getToken(sqlParser.LOCKS, 0)

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)

        def LOCK(self):
            return self.getToken(sqlParser.LOCK, 0)

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

        def UNLOCK(self):
            return self.getToken(sqlParser.UNLOCK, 0)

        def TEMPORARY(self):
            return self.getToken(sqlParser.TEMPORARY, 0)

        def MACRO(self):
            return self.getToken(sqlParser.MACRO, 0)

        def tableIdentifier(self):
            return self.getTypedRuleContext(sqlParser.TableIdentifierContext,0)


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

        def CLUSTERED(self):
            return self.getToken(sqlParser.CLUSTERED, 0)

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

        def SORTED(self):
            return self.getToken(sqlParser.SORTED, 0)

        def SKEWED(self):
            return self.getToken(sqlParser.SKEWED, 0)

        def STORED(self):
            return self.getToken(sqlParser.STORED, 0)

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

        def DIRECTORIES(self):
            return self.getToken(sqlParser.DIRECTORIES, 0)

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

        def LOCATION(self):
            return self.getToken(sqlParser.LOCATION, 0)

        def EXCHANGE(self):
            return self.getToken(sqlParser.EXCHANGE, 0)

        def PARTITION(self):
            return self.getToken(sqlParser.PARTITION, 0)

        def ARCHIVE(self):
            return self.getToken(sqlParser.ARCHIVE, 0)

        def UNARCHIVE(self):
            return self.getToken(sqlParser.UNARCHIVE, 0)

        def TOUCH(self):
            return self.getToken(sqlParser.TOUCH, 0)

        def COMPACT(self):
            return self.getToken(sqlParser.COMPACT, 0)

        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)


        def CONCATENATE(self):
            return self.getToken(sqlParser.CONCATENATE, 0)

        def FILEFORMAT(self):
            return self.getToken(sqlParser.FILEFORMAT, 0)

        def REPLACE(self):
            return self.getToken(sqlParser.REPLACE, 0)

        def COLUMNS(self):
            return self.getToken(sqlParser.COLUMNS, 0)

        def START(self):
            return self.getToken(sqlParser.START, 0)

        def TRANSACTION(self):
            return self.getToken(sqlParser.TRANSACTION, 0)

        def COMMIT(self):
            return self.getToken(sqlParser.COMMIT, 0)

        def ROLLBACK(self):
            return self.getToken(sqlParser.ROLLBACK, 0)

        def DFS(self):
            return self.getToken(sqlParser.DFS, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_unsupportedHiveNativeCommands

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




    def unsupportedHiveNativeCommands(self):

        localctx = sqlParser.UnsupportedHiveNativeCommandsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_unsupportedHiveNativeCommands)
        self._la = 0 # Token type
        try:
            self.state = 1176
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1008
                localctx.kw1 = self.match(sqlParser.CREATE)
                self.state = 1009
                localctx.kw2 = self.match(sqlParser.ROLE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1010
                localctx.kw1 = self.match(sqlParser.DROP)
                self.state = 1011
                localctx.kw2 = self.match(sqlParser.ROLE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1012
                localctx.kw1 = self.match(sqlParser.GRANT)
                self.state = 1014
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
                if la_ == 1:
                    self.state = 1013
                    localctx.kw2 = self.match(sqlParser.ROLE)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1016
                localctx.kw1 = self.match(sqlParser.REVOKE)
                self.state = 1018
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
                if la_ == 1:
                    self.state = 1017
                    localctx.kw2 = self.match(sqlParser.ROLE)


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1020
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1021
                localctx.kw2 = self.match(sqlParser.GRANT)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1022
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1023
                localctx.kw2 = self.match(sqlParser.ROLE)
                self.state = 1025
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
                if la_ == 1:
                    self.state = 1024
                    localctx.kw3 = self.match(sqlParser.GRANT)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1027
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1028
                localctx.kw2 = self.match(sqlParser.PRINCIPALS)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1029
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1030
                localctx.kw2 = self.match(sqlParser.ROLES)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1031
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1032
                localctx.kw2 = self.match(sqlParser.CURRENT)
                self.state = 1033
                localctx.kw3 = self.match(sqlParser.ROLES)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1034
                localctx.kw1 = self.match(sqlParser.EXPORT)
                self.state = 1035
                localctx.kw2 = self.match(sqlParser.TABLE)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1036
                localctx.kw1 = self.match(sqlParser.IMPORT)
                self.state = 1037
                localctx.kw2 = self.match(sqlParser.TABLE)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1038
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1039
                localctx.kw2 = self.match(sqlParser.COMPACTIONS)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1040
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1041
                localctx.kw2 = self.match(sqlParser.CREATE)
                self.state = 1042
                localctx.kw3 = self.match(sqlParser.TABLE)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1043
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1044
                localctx.kw2 = self.match(sqlParser.TRANSACTIONS)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1045
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1046
                localctx.kw2 = self.match(sqlParser.INDEXES)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1047
                localctx.kw1 = self.match(sqlParser.SHOW)
                self.state = 1048
                localctx.kw2 = self.match(sqlParser.LOCKS)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1049
                localctx.kw1 = self.match(sqlParser.CREATE)
                self.state = 1050
                localctx.kw2 = self.match(sqlParser.INDEX)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1051
                localctx.kw1 = self.match(sqlParser.DROP)
                self.state = 1052
                localctx.kw2 = self.match(sqlParser.INDEX)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1053
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1054
                localctx.kw2 = self.match(sqlParser.INDEX)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 1055
                localctx.kw1 = self.match(sqlParser.LOCK)
                self.state = 1056
                localctx.kw2 = self.match(sqlParser.TABLE)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 1057
                localctx.kw1 = self.match(sqlParser.LOCK)
                self.state = 1058
                localctx.kw2 = self.match(sqlParser.DATABASE)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 1059
                localctx.kw1 = self.match(sqlParser.UNLOCK)
                self.state = 1060
                localctx.kw2 = self.match(sqlParser.TABLE)
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 1061
                localctx.kw1 = self.match(sqlParser.UNLOCK)
                self.state = 1062
                localctx.kw2 = self.match(sqlParser.DATABASE)
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 1063
                localctx.kw1 = self.match(sqlParser.CREATE)
                self.state = 1064
                localctx.kw2 = self.match(sqlParser.TEMPORARY)
                self.state = 1065
                localctx.kw3 = self.match(sqlParser.MACRO)
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 1066
                localctx.kw1 = self.match(sqlParser.DROP)
                self.state = 1067
                localctx.kw2 = self.match(sqlParser.TEMPORARY)
                self.state = 1068
                localctx.kw3 = self.match(sqlParser.MACRO)
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 1069
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1070
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1071
                self.tableIdentifier()
                self.state = 1072
                localctx.kw3 = self.match(sqlParser.NOT)
                self.state = 1073
                localctx.kw4 = self.match(sqlParser.CLUSTERED)
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 1075
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1076
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1077
                self.tableIdentifier()
                self.state = 1078
                localctx.kw3 = self.match(sqlParser.CLUSTERED)
                self.state = 1079
                localctx.kw4 = self.match(sqlParser.BY)
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 1081
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1082
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1083
                self.tableIdentifier()
                self.state = 1084
                localctx.kw3 = self.match(sqlParser.NOT)
                self.state = 1085
                localctx.kw4 = self.match(sqlParser.SORTED)
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 1087
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1088
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1089
                self.tableIdentifier()
                self.state = 1090
                localctx.kw3 = self.match(sqlParser.SKEWED)
                self.state = 1091
                localctx.kw4 = self.match(sqlParser.BY)
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 1093
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1094
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1095
                self.tableIdentifier()
                self.state = 1096
                localctx.kw3 = self.match(sqlParser.NOT)
                self.state = 1097
                localctx.kw4 = self.match(sqlParser.SKEWED)
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 1099
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1100
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1101
                self.tableIdentifier()
                self.state = 1102
                localctx.kw3 = self.match(sqlParser.NOT)
                self.state = 1103
                localctx.kw4 = self.match(sqlParser.STORED)
                self.state = 1104
                localctx.kw5 = self.match(sqlParser.AS)
                self.state = 1105
                localctx.kw6 = self.match(sqlParser.DIRECTORIES)
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 1107
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1108
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1109
                self.tableIdentifier()
                self.state = 1110
                localctx.kw3 = self.match(sqlParser.SET)
                self.state = 1111
                localctx.kw4 = self.match(sqlParser.SKEWED)
                self.state = 1112
                localctx.kw5 = self.match(sqlParser.LOCATION)
                pass

            elif la_ == 33:
                self.enterOuterAlt(localctx, 33)
                self.state = 1114
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1115
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1116
                self.tableIdentifier()
                self.state = 1117
                localctx.kw3 = self.match(sqlParser.EXCHANGE)
                self.state = 1118
                localctx.kw4 = self.match(sqlParser.PARTITION)
                pass

            elif la_ == 34:
                self.enterOuterAlt(localctx, 34)
                self.state = 1120
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1121
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1122
                self.tableIdentifier()
                self.state = 1123
                localctx.kw3 = self.match(sqlParser.ARCHIVE)
                self.state = 1124
                localctx.kw4 = self.match(sqlParser.PARTITION)
                pass

            elif la_ == 35:
                self.enterOuterAlt(localctx, 35)
                self.state = 1126
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1127
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1128
                self.tableIdentifier()
                self.state = 1129
                localctx.kw3 = self.match(sqlParser.UNARCHIVE)
                self.state = 1130
                localctx.kw4 = self.match(sqlParser.PARTITION)
                pass

            elif la_ == 36:
                self.enterOuterAlt(localctx, 36)
                self.state = 1132
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1133
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1134
                self.tableIdentifier()
                self.state = 1135
                localctx.kw3 = self.match(sqlParser.TOUCH)
                pass

            elif la_ == 37:
                self.enterOuterAlt(localctx, 37)
                self.state = 1137
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1138
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1139
                self.tableIdentifier()
                self.state = 1141
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 1140
                    self.partitionSpec()


                self.state = 1143
                localctx.kw3 = self.match(sqlParser.COMPACT)
                pass

            elif la_ == 38:
                self.enterOuterAlt(localctx, 38)
                self.state = 1145
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1146
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1147
                self.tableIdentifier()
                self.state = 1149
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 1148
                    self.partitionSpec()


                self.state = 1151
                localctx.kw3 = self.match(sqlParser.CONCATENATE)
                pass

            elif la_ == 39:
                self.enterOuterAlt(localctx, 39)
                self.state = 1153
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1154
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1155
                self.tableIdentifier()
                self.state = 1157
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 1156
                    self.partitionSpec()


                self.state = 1159
                localctx.kw3 = self.match(sqlParser.SET)
                self.state = 1160
                localctx.kw4 = self.match(sqlParser.FILEFORMAT)
                pass

            elif la_ == 40:
                self.enterOuterAlt(localctx, 40)
                self.state = 1162
                localctx.kw1 = self.match(sqlParser.ALTER)
                self.state = 1163
                localctx.kw2 = self.match(sqlParser.TABLE)
                self.state = 1164
                self.tableIdentifier()
                self.state = 1166
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 1165
                    self.partitionSpec()


                self.state = 1168
                localctx.kw3 = self.match(sqlParser.REPLACE)
                self.state = 1169
                localctx.kw4 = self.match(sqlParser.COLUMNS)
                pass

            elif la_ == 41:
                self.enterOuterAlt(localctx, 41)
                self.state = 1171
                localctx.kw1 = self.match(sqlParser.START)
                self.state = 1172
                localctx.kw2 = self.match(sqlParser.TRANSACTION)
                pass

            elif la_ == 42:
                self.enterOuterAlt(localctx, 42)
                self.state = 1173
                localctx.kw1 = self.match(sqlParser.COMMIT)
                pass

            elif la_ == 43:
                self.enterOuterAlt(localctx, 43)
                self.state = 1174
                localctx.kw1 = self.match(sqlParser.ROLLBACK)
                pass

            elif la_ == 44:
                self.enterOuterAlt(localctx, 44)
                self.state = 1175
                localctx.kw1 = self.match(sqlParser.DFS)
                pass


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


    class CreateTableHeaderContext(ParserRuleContext):

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

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

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

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


        def TEMPORARY(self):
            return self.getToken(sqlParser.TEMPORARY, 0)

        def EXTERNAL(self):
            return self.getToken(sqlParser.EXTERNAL, 0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)

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

        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_createTableHeader

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




    def createTableHeader(self):

        localctx = sqlParser.CreateTableHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_createTableHeader)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1178
            self.match(sqlParser.CREATE)
            self.state = 1180
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.TEMPORARY:
                self.state = 1179
                self.match(sqlParser.TEMPORARY)


            self.state = 1183
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.EXTERNAL:
                self.state = 1182
                self.match(sqlParser.EXTERNAL)


            self.state = 1185
            self.match(sqlParser.TABLE)
            self.state = 1189
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
            if la_ == 1:
                self.state = 1186
                self.match(sqlParser.IF)
                self.state = 1187
                self.match(sqlParser.NOT)
                self.state = 1188
                self.match(sqlParser.EXISTS)


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


    class ReplaceTableHeaderContext(ParserRuleContext):

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

        def REPLACE(self):
            return self.getToken(sqlParser.REPLACE, 0)

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

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


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

        def OR(self):
            return self.getToken(sqlParser.OR, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_replaceTableHeader

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




    def replaceTableHeader(self):

        localctx = sqlParser.ReplaceTableHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_replaceTableHeader)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1195
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.CREATE:
                self.state = 1193
                self.match(sqlParser.CREATE)
                self.state = 1194
                self.match(sqlParser.OR)


            self.state = 1197
            self.match(sqlParser.REPLACE)
            self.state = 1198
            self.match(sqlParser.TABLE)
            self.state = 1199
            self.multipartIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BucketSpecContext(ParserRuleContext):

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

        def CLUSTERED(self):
            return self.getToken(sqlParser.CLUSTERED, 0)

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

        def identifierList(self):
            return self.getTypedRuleContext(sqlParser.IdentifierListContext,0)


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

        def INTEGER_VALUE(self):
            return self.getToken(sqlParser.INTEGER_VALUE, 0)

        def BUCKETS(self):
            return self.getToken(sqlParser.BUCKETS, 0)

        def SORTED(self):
            return self.getToken(sqlParser.SORTED, 0)

        def orderedIdentifierList(self):
            return self.getTypedRuleContext(sqlParser.OrderedIdentifierListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_bucketSpec

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




    def bucketSpec(self):

        localctx = sqlParser.BucketSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_bucketSpec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1201
            self.match(sqlParser.CLUSTERED)
            self.state = 1202
            self.match(sqlParser.BY)
            self.state = 1203
            self.identifierList()
            self.state = 1207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.SORTED:
                self.state = 1204
                self.match(sqlParser.SORTED)
                self.state = 1205
                self.match(sqlParser.BY)
                self.state = 1206
                self.orderedIdentifierList()


            self.state = 1209
            self.match(sqlParser.INTO)
            self.state = 1210
            self.match(sqlParser.INTEGER_VALUE)
            self.state = 1211
            self.match(sqlParser.BUCKETS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SkewSpecContext(ParserRuleContext):

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

        def SKEWED(self):
            return self.getToken(sqlParser.SKEWED, 0)

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

        def identifierList(self):
            return self.getTypedRuleContext(sqlParser.IdentifierListContext,0)


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

        def constantList(self):
            return self.getTypedRuleContext(sqlParser.ConstantListContext,0)


        def nestedConstantList(self):
            return self.getTypedRuleContext(sqlParser.NestedConstantListContext,0)


        def STORED(self):
            return self.getToken(sqlParser.STORED, 0)

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

        def DIRECTORIES(self):
            return self.getToken(sqlParser.DIRECTORIES, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_skewSpec

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




    def skewSpec(self):

        localctx = sqlParser.SkewSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_skewSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1213
            self.match(sqlParser.SKEWED)
            self.state = 1214
            self.match(sqlParser.BY)
            self.state = 1215
            self.identifierList()
            self.state = 1216
            self.match(sqlParser.ON)
            self.state = 1219
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,120,self._ctx)
            if la_ == 1:
                self.state = 1217
                self.constantList()
                pass

            elif la_ == 2:
                self.state = 1218
                self.nestedConstantList()
                pass


            self.state = 1224
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.state = 1221
                self.match(sqlParser.STORED)
                self.state = 1222
                self.match(sqlParser.AS)
                self.state = 1223
                self.match(sqlParser.DIRECTORIES)


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


    class LocationSpecContext(ParserRuleContext):

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

        def LOCATION(self):
            return self.getToken(sqlParser.LOCATION, 0)

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

        def getRuleIndex(self):
            return sqlParser.RULE_locationSpec

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




    def locationSpec(self):

        localctx = sqlParser.LocationSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_locationSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1226
            self.match(sqlParser.LOCATION)
            self.state = 1227
            self.match(sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CommentSpecContext(ParserRuleContext):

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

        def COMMENT(self):
            return self.getToken(sqlParser.COMMENT, 0)

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

        def getRuleIndex(self):
            return sqlParser.RULE_commentSpec

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




    def commentSpec(self):

        localctx = sqlParser.CommentSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_commentSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1229
            self.match(sqlParser.COMMENT)
            self.state = 1230
            self.match(sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryContext(ParserRuleContext):

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

        def queryTerm(self):
            return self.getTypedRuleContext(sqlParser.QueryTermContext,0)


        def queryOrganization(self):
            return self.getTypedRuleContext(sqlParser.QueryOrganizationContext,0)


        def ctes(self):
            return self.getTypedRuleContext(sqlParser.CtesContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_query

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




    def query(self):

        localctx = sqlParser.QueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_query)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1233
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.WITH:
                self.state = 1232
                self.ctes()


            self.state = 1235
            self.queryTerm(0)
            self.state = 1236
            self.queryOrganization()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InsertIntoContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_insertInto

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



    class InsertOverwriteHiveDirContext(InsertIntoContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.InsertIntoContext
            super().__init__(parser)
            self.path = None # Token
            self.copyFrom(ctx)

        def INSERT(self):
            return self.getToken(sqlParser.INSERT, 0)
        def OVERWRITE(self):
            return self.getToken(sqlParser.OVERWRITE, 0)
        def DIRECTORY(self):
            return self.getToken(sqlParser.DIRECTORY, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def LOCAL(self):
            return self.getToken(sqlParser.LOCAL, 0)
        def rowFormat(self):
            return self.getTypedRuleContext(sqlParser.RowFormatContext,0)

        def createFileFormat(self):
            return self.getTypedRuleContext(sqlParser.CreateFileFormatContext,0)


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


    class InsertOverwriteDirContext(InsertIntoContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.InsertIntoContext
            super().__init__(parser)
            self.path = None # Token
            self.options = None # TablePropertyListContext
            self.copyFrom(ctx)

        def INSERT(self):
            return self.getToken(sqlParser.INSERT, 0)
        def OVERWRITE(self):
            return self.getToken(sqlParser.OVERWRITE, 0)
        def DIRECTORY(self):
            return self.getToken(sqlParser.DIRECTORY, 0)
        def tableProvider(self):
            return self.getTypedRuleContext(sqlParser.TableProviderContext,0)

        def LOCAL(self):
            return self.getToken(sqlParser.LOCAL, 0)
        def OPTIONS(self):
            return self.getToken(sqlParser.OPTIONS, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)


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


    class InsertOverwriteTableContext(InsertIntoContext):

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

        def INSERT(self):
            return self.getToken(sqlParser.INSERT, 0)
        def OVERWRITE(self):
            return self.getToken(sqlParser.OVERWRITE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

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


    class InsertIntoTableContext(InsertIntoContext):

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

        def INSERT(self):
            return self.getToken(sqlParser.INSERT, 0)
        def INTO(self):
            return self.getToken(sqlParser.INTO, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

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



    def insertInto(self):

        localctx = sqlParser.InsertIntoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_insertInto)
        self._la = 0 # Token type
        try:
            self.state = 1293
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
            if la_ == 1:
                localctx = sqlParser.InsertOverwriteTableContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1238
                self.match(sqlParser.INSERT)
                self.state = 1239
                self.match(sqlParser.OVERWRITE)
                self.state = 1241
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
                if la_ == 1:
                    self.state = 1240
                    self.match(sqlParser.TABLE)


                self.state = 1243
                self.multipartIdentifier()
                self.state = 1250
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 1244
                    self.partitionSpec()
                    self.state = 1248
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.IF:
                        self.state = 1245
                        self.match(sqlParser.IF)
                        self.state = 1246
                        self.match(sqlParser.NOT)
                        self.state = 1247
                        self.match(sqlParser.EXISTS)




                pass

            elif la_ == 2:
                localctx = sqlParser.InsertIntoTableContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1252
                self.match(sqlParser.INSERT)
                self.state = 1253
                self.match(sqlParser.INTO)
                self.state = 1255
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
                if la_ == 1:
                    self.state = 1254
                    self.match(sqlParser.TABLE)


                self.state = 1257
                self.multipartIdentifier()
                self.state = 1259
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PARTITION:
                    self.state = 1258
                    self.partitionSpec()


                self.state = 1264
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.IF:
                    self.state = 1261
                    self.match(sqlParser.IF)
                    self.state = 1262
                    self.match(sqlParser.NOT)
                    self.state = 1263
                    self.match(sqlParser.EXISTS)


                pass

            elif la_ == 3:
                localctx = sqlParser.InsertOverwriteHiveDirContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1266
                self.match(sqlParser.INSERT)
                self.state = 1267
                self.match(sqlParser.OVERWRITE)
                self.state = 1269
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LOCAL:
                    self.state = 1268
                    self.match(sqlParser.LOCAL)


                self.state = 1271
                self.match(sqlParser.DIRECTORY)
                self.state = 1272
                localctx.path = self.match(sqlParser.STRING)
                self.state = 1274
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.ROW:
                    self.state = 1273
                    self.rowFormat()


                self.state = 1277
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.STORED:
                    self.state = 1276
                    self.createFileFormat()


                pass

            elif la_ == 4:
                localctx = sqlParser.InsertOverwriteDirContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1279
                self.match(sqlParser.INSERT)
                self.state = 1280
                self.match(sqlParser.OVERWRITE)
                self.state = 1282
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LOCAL:
                    self.state = 1281
                    self.match(sqlParser.LOCAL)


                self.state = 1284
                self.match(sqlParser.DIRECTORY)
                self.state = 1286
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.STRING:
                    self.state = 1285
                    localctx.path = self.match(sqlParser.STRING)


                self.state = 1288
                self.tableProvider()
                self.state = 1291
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OPTIONS:
                    self.state = 1289
                    self.match(sqlParser.OPTIONS)
                    self.state = 1290
                    localctx.options = self.tablePropertyList()


                pass


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


    class PartitionSpecLocationContext(ParserRuleContext):

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

        def partitionSpec(self):
            return self.getTypedRuleContext(sqlParser.PartitionSpecContext,0)


        def locationSpec(self):
            return self.getTypedRuleContext(sqlParser.LocationSpecContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_partitionSpecLocation

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




    def partitionSpecLocation(self):

        localctx = sqlParser.PartitionSpecLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_partitionSpecLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1295
            self.partitionSpec()
            self.state = 1297
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.LOCATION:
                self.state = 1296
                self.locationSpec()


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


    class PartitionSpecContext(ParserRuleContext):

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

        def PARTITION(self):
            return self.getToken(sqlParser.PARTITION, 0)

        def partitionVal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.PartitionValContext)
            else:
                return self.getTypedRuleContext(sqlParser.PartitionValContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_partitionSpec

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




    def partitionSpec(self):

        localctx = sqlParser.PartitionSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_partitionSpec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1299
            self.match(sqlParser.PARTITION)
            self.state = 1300
            self.match(sqlParser.T__1)
            self.state = 1301
            self.partitionVal()
            self.state = 1306
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 1302
                self.match(sqlParser.T__3)
                self.state = 1303
                self.partitionVal()
                self.state = 1308
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1309
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartitionValContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


        def EQ(self):
            return self.getToken(sqlParser.EQ, 0)

        def constant(self):
            return self.getTypedRuleContext(sqlParser.ConstantContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_partitionVal

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




    def partitionVal(self):

        localctx = sqlParser.PartitionValContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_partitionVal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1311
            self.identifier()
            self.state = 1314
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.EQ:
                self.state = 1312
                self.match(sqlParser.EQ)
                self.state = 1313
                self.constant()


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


    class NamespaceContext(ParserRuleContext):

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

        def NAMESPACE(self):
            return self.getToken(sqlParser.NAMESPACE, 0)

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

        def SCHEMA(self):
            return self.getToken(sqlParser.SCHEMA, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_namespace

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




    def namespace(self):

        localctx = sqlParser.NamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_namespace)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1316
            _la = self._input.LA(1)
            if not(_la==sqlParser.DATABASE or _la==sqlParser.NAMESPACE or _la==sqlParser.SCHEMA):
                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 DescribeFuncNameContext(ParserRuleContext):

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

        def qualifiedName(self):
            return self.getTypedRuleContext(sqlParser.QualifiedNameContext,0)


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

        def comparisonOperator(self):
            return self.getTypedRuleContext(sqlParser.ComparisonOperatorContext,0)


        def arithmeticOperator(self):
            return self.getTypedRuleContext(sqlParser.ArithmeticOperatorContext,0)


        def predicateOperator(self):
            return self.getTypedRuleContext(sqlParser.PredicateOperatorContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_describeFuncName

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




    def describeFuncName(self):

        localctx = sqlParser.DescribeFuncNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_describeFuncName)
        try:
            self.state = 1323
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1318
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1319
                self.match(sqlParser.STRING)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1320
                self.comparisonOperator()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1321
                self.arithmeticOperator()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1322
                self.predicateOperator()
                pass


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


    class DescribeColNameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._identifier = None # IdentifierContext
            self.nameParts = list() # of IdentifierContexts

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_describeColName

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




    def describeColName(self):

        localctx = sqlParser.DescribeColNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_describeColName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1325
            localctx._identifier = self.identifier()
            localctx.nameParts.append(localctx._identifier)
            self.state = 1330
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__4:
                self.state = 1326
                self.match(sqlParser.T__4)
                self.state = 1327
                localctx._identifier = self.identifier()
                localctx.nameParts.append(localctx._identifier)
                self.state = 1332
                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 CtesContext(ParserRuleContext):

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

        def WITH(self):
            return self.getToken(sqlParser.WITH, 0)

        def namedQuery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.NamedQueryContext)
            else:
                return self.getTypedRuleContext(sqlParser.NamedQueryContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_ctes

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




    def ctes(self):

        localctx = sqlParser.CtesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_ctes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1333
            self.match(sqlParser.WITH)
            self.state = 1334
            self.namedQuery()
            self.state = 1339
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 1335
                self.match(sqlParser.T__3)
                self.state = 1336
                self.namedQuery()
                self.state = 1341
                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 NamedQueryContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.name = None # ErrorCapturingIdentifierContext
            self.columnAliases = None # IdentifierListContext

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)


        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


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

        def identifierList(self):
            return self.getTypedRuleContext(sqlParser.IdentifierListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_namedQuery

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




    def namedQuery(self):

        localctx = sqlParser.NamedQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_namedQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1342
            localctx.name = self.errorCapturingIdentifier()
            self.state = 1344
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
            if la_ == 1:
                self.state = 1343
                localctx.columnAliases = self.identifierList()


            self.state = 1347
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.AS:
                self.state = 1346
                self.match(sqlParser.AS)


            self.state = 1349
            self.match(sqlParser.T__1)
            self.state = 1350
            self.query()
            self.state = 1351
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableProviderContext(ParserRuleContext):

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

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

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_tableProvider

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




    def tableProvider(self):

        localctx = sqlParser.TableProviderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_tableProvider)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1353
            self.match(sqlParser.USING)
            self.state = 1354
            self.multipartIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateTableClausesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.options = None # TablePropertyListContext
            self.partitioning = None # TransformListContext
            self.tableProps = None # TablePropertyListContext

        def bucketSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.BucketSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.BucketSpecContext,i)


        def locationSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.LocationSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.LocationSpecContext,i)


        def commentSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.CommentSpecContext)
            else:
                return self.getTypedRuleContext(sqlParser.CommentSpecContext,i)


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

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

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

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

        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(sqlParser.TablePropertyListContext,i)


        def transformList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TransformListContext)
            else:
                return self.getTypedRuleContext(sqlParser.TransformListContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_createTableClauses

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




    def createTableClauses(self):

        localctx = sqlParser.CreateTableClausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_createTableClauses)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1368
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.CLUSTERED or _la==sqlParser.COMMENT or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & ((1 << (sqlParser.LOCATION - 138)) | (1 << (sqlParser.OPTIONS - 138)) | (1 << (sqlParser.PARTITIONED - 138)))) != 0) or _la==sqlParser.TBLPROPERTIES:
                self.state = 1366
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [sqlParser.OPTIONS]:
                    self.state = 1356
                    self.match(sqlParser.OPTIONS)
                    self.state = 1357
                    localctx.options = self.tablePropertyList()
                    pass
                elif token in [sqlParser.PARTITIONED]:
                    self.state = 1358
                    self.match(sqlParser.PARTITIONED)
                    self.state = 1359
                    self.match(sqlParser.BY)
                    self.state = 1360
                    localctx.partitioning = self.transformList()
                    pass
                elif token in [sqlParser.CLUSTERED]:
                    self.state = 1361
                    self.bucketSpec()
                    pass
                elif token in [sqlParser.LOCATION]:
                    self.state = 1362
                    self.locationSpec()
                    pass
                elif token in [sqlParser.COMMENT]:
                    self.state = 1363
                    self.commentSpec()
                    pass
                elif token in [sqlParser.TBLPROPERTIES]:
                    self.state = 1364
                    self.match(sqlParser.TBLPROPERTIES)
                    self.state = 1365
                    localctx.tableProps = self.tablePropertyList()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1370
                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 TablePropertyListContext(ParserRuleContext):

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

        def tableProperty(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TablePropertyContext)
            else:
                return self.getTypedRuleContext(sqlParser.TablePropertyContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_tablePropertyList

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




    def tablePropertyList(self):

        localctx = sqlParser.TablePropertyListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_tablePropertyList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1371
            self.match(sqlParser.T__1)
            self.state = 1372
            self.tableProperty()
            self.state = 1377
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 1373
                self.match(sqlParser.T__3)
                self.state = 1374
                self.tableProperty()
                self.state = 1379
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1380
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TablePropertyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.key = None # TablePropertyKeyContext
            self.value = None # TablePropertyValueContext

        def tablePropertyKey(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyKeyContext,0)


        def tablePropertyValue(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyValueContext,0)


        def EQ(self):
            return self.getToken(sqlParser.EQ, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_tableProperty

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




    def tableProperty(self):

        localctx = sqlParser.TablePropertyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_tableProperty)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1382
            localctx.key = self.tablePropertyKey()
            self.state = 1387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.FALSE or ((((_la - 241)) & ~0x3f) == 0 and ((1 << (_la - 241)) & ((1 << (sqlParser.TRUE - 241)) | (1 << (sqlParser.EQ - 241)) | (1 << (sqlParser.STRING - 241)) | (1 << (sqlParser.INTEGER_VALUE - 241)) | (1 << (sqlParser.DECIMAL_VALUE - 241)))) != 0):
                self.state = 1384
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.EQ:
                    self.state = 1383
                    self.match(sqlParser.EQ)


                self.state = 1386
                localctx.value = self.tablePropertyValue()


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


    class TablePropertyKeyContext(ParserRuleContext):

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierContext,i)


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

        def getRuleIndex(self):
            return sqlParser.RULE_tablePropertyKey

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




    def tablePropertyKey(self):

        localctx = sqlParser.TablePropertyKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_tablePropertyKey)
        self._la = 0 # Token type
        try:
            self.state = 1398
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1389
                self.identifier()
                self.state = 1394
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__4:
                    self.state = 1390
                    self.match(sqlParser.T__4)
                    self.state = 1391
                    self.identifier()
                    self.state = 1396
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1397
                self.match(sqlParser.STRING)
                pass


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


    class TablePropertyValueContext(ParserRuleContext):

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

        def INTEGER_VALUE(self):
            return self.getToken(sqlParser.INTEGER_VALUE, 0)

        def DECIMAL_VALUE(self):
            return self.getToken(sqlParser.DECIMAL_VALUE, 0)

        def booleanValue(self):
            return self.getTypedRuleContext(sqlParser.BooleanValueContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_tablePropertyValue

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




    def tablePropertyValue(self):

        localctx = sqlParser.TablePropertyValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_tablePropertyValue)
        try:
            self.state = 1404
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.INTEGER_VALUE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1400
                self.match(sqlParser.INTEGER_VALUE)
                pass
            elif token in [sqlParser.DECIMAL_VALUE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1401
                self.match(sqlParser.DECIMAL_VALUE)
                pass
            elif token in [sqlParser.FALSE, sqlParser.TRUE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1402
                self.booleanValue()
                pass
            elif token in [sqlParser.STRING]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1403
                self.match(sqlParser.STRING)
                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 ConstantListContext(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(sqlParser.ConstantContext)
            else:
                return self.getTypedRuleContext(sqlParser.ConstantContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_constantList

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




    def constantList(self):

        localctx = sqlParser.ConstantListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_constantList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1406
            self.match(sqlParser.T__1)
            self.state = 1407
            self.constant()
            self.state = 1412
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 1408
                self.match(sqlParser.T__3)
                self.state = 1409
                self.constant()
                self.state = 1414
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1415
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NestedConstantListContext(ParserRuleContext):

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

        def constantList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ConstantListContext)
            else:
                return self.getTypedRuleContext(sqlParser.ConstantListContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_nestedConstantList

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




    def nestedConstantList(self):

        localctx = sqlParser.NestedConstantListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_nestedConstantList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1417
            self.match(sqlParser.T__1)
            self.state = 1418
            self.constantList()
            self.state = 1423
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 1419
                self.match(sqlParser.T__3)
                self.state = 1420
                self.constantList()
                self.state = 1425
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1426
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateFileFormatContext(ParserRuleContext):

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

        def STORED(self):
            return self.getToken(sqlParser.STORED, 0)

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

        def fileFormat(self):
            return self.getTypedRuleContext(sqlParser.FileFormatContext,0)


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

        def storageHandler(self):
            return self.getTypedRuleContext(sqlParser.StorageHandlerContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_createFileFormat

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




    def createFileFormat(self):

        localctx = sqlParser.CreateFileFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_createFileFormat)
        try:
            self.state = 1434
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,154,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1428
                self.match(sqlParser.STORED)
                self.state = 1429
                self.match(sqlParser.AS)
                self.state = 1430
                self.fileFormat()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1431
                self.match(sqlParser.STORED)
                self.state = 1432
                self.match(sqlParser.BY)
                self.state = 1433
                self.storageHandler()
                pass


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


    class FileFormatContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_fileFormat

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



    class TableFileFormatContext(FileFormatContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.FileFormatContext
            super().__init__(parser)
            self.inFmt = None # Token
            self.outFmt = None # Token
            self.copyFrom(ctx)

        def INPUTFORMAT(self):
            return self.getToken(sqlParser.INPUTFORMAT, 0)
        def OUTPUTFORMAT(self):
            return self.getToken(sqlParser.OUTPUTFORMAT, 0)
        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.STRING)
            else:
                return self.getToken(sqlParser.STRING, i)

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


    class GenericFileFormatContext(FileFormatContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


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



    def fileFormat(self):

        localctx = sqlParser.FileFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_fileFormat)
        try:
            self.state = 1441
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,155,self._ctx)
            if la_ == 1:
                localctx = sqlParser.TableFileFormatContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1436
                self.match(sqlParser.INPUTFORMAT)
                self.state = 1437
                localctx.inFmt = self.match(sqlParser.STRING)
                self.state = 1438
                self.match(sqlParser.OUTPUTFORMAT)
                self.state = 1439
                localctx.outFmt = self.match(sqlParser.STRING)
                pass

            elif la_ == 2:
                localctx = sqlParser.GenericFileFormatContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1440
                self.identifier()
                pass


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


    class StorageHandlerContext(ParserRuleContext):

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

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

        def WITH(self):
            return self.getToken(sqlParser.WITH, 0)

        def SERDEPROPERTIES(self):
            return self.getToken(sqlParser.SERDEPROPERTIES, 0)

        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_storageHandler

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




    def storageHandler(self):

        localctx = sqlParser.StorageHandlerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_storageHandler)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1443
            self.match(sqlParser.STRING)
            self.state = 1447
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
            if la_ == 1:
                self.state = 1444
                self.match(sqlParser.WITH)
                self.state = 1445
                self.match(sqlParser.SERDEPROPERTIES)
                self.state = 1446
                self.tablePropertyList()


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


    class ResourceContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_resource

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




    def resource(self):

        localctx = sqlParser.ResourceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_resource)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1449
            self.identifier()
            self.state = 1450
            self.match(sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DmlStatementNoWithContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_dmlStatementNoWith

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



    class DeleteFromTableContext(DmlStatementNoWithContext):

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

        def DELETE(self):
            return self.getToken(sqlParser.DELETE, 0)
        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(sqlParser.TableAliasContext,0)

        def whereClause(self):
            return self.getTypedRuleContext(sqlParser.WhereClauseContext,0)


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


    class SingleInsertQueryContext(DmlStatementNoWithContext):

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

        def insertInto(self):
            return self.getTypedRuleContext(sqlParser.InsertIntoContext,0)

        def queryTerm(self):
            return self.getTypedRuleContext(sqlParser.QueryTermContext,0)

        def queryOrganization(self):
            return self.getTypedRuleContext(sqlParser.QueryOrganizationContext,0)


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


    class MultiInsertQueryContext(DmlStatementNoWithContext):

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

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

        def multiInsertQueryBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MultiInsertQueryBodyContext)
            else:
                return self.getTypedRuleContext(sqlParser.MultiInsertQueryBodyContext,i)


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


    class UpdateTableContext(DmlStatementNoWithContext):

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

        def UPDATE(self):
            return self.getToken(sqlParser.UPDATE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(sqlParser.TableAliasContext,0)

        def setClause(self):
            return self.getTypedRuleContext(sqlParser.SetClauseContext,0)

        def whereClause(self):
            return self.getTypedRuleContext(sqlParser.WhereClauseContext,0)


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


    class MergeIntoTableContext(DmlStatementNoWithContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.target = None # MultipartIdentifierContext
            self.targetAlias = None # TableAliasContext
            self.source = None # MultipartIdentifierContext
            self.sourceQuery = None # QueryContext
            self.sourceAlias = None # TableAliasContext
            self.mergeCondition = None # BooleanExpressionContext
            self.copyFrom(ctx)

        def MERGE(self):
            return self.getToken(sqlParser.MERGE, 0)
        def INTO(self):
            return self.getToken(sqlParser.INTO, 0)
        def USING(self):
            return self.getToken(sqlParser.USING, 0)
        def ON(self):
            return self.getToken(sqlParser.ON, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,i)

        def tableAlias(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TableAliasContext)
            else:
                return self.getTypedRuleContext(sqlParser.TableAliasContext,i)

        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

        def matchedClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MatchedClauseContext)
            else:
                return self.getTypedRuleContext(sqlParser.MatchedClauseContext,i)

        def notMatchedClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.NotMatchedClauseContext)
            else:
                return self.getTypedRuleContext(sqlParser.NotMatchedClauseContext,i)


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



    def dmlStatementNoWith(self):

        localctx = sqlParser.DmlStatementNoWithContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_dmlStatementNoWith)
        self._la = 0 # Token type
        try:
            self.state = 1503
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.INSERT]:
                localctx = sqlParser.SingleInsertQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1452
                self.insertInto()
                self.state = 1453
                self.queryTerm(0)
                self.state = 1454
                self.queryOrganization()
                pass
            elif token in [sqlParser.FROM]:
                localctx = sqlParser.MultiInsertQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1456
                self.fromClause()
                self.state = 1458 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1457
                    self.multiInsertQueryBody()
                    self.state = 1460 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==sqlParser.INSERT):
                        break

                pass
            elif token in [sqlParser.DELETE]:
                localctx = sqlParser.DeleteFromTableContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1462
                self.match(sqlParser.DELETE)
                self.state = 1463
                self.match(sqlParser.FROM)
                self.state = 1464
                self.multipartIdentifier()
                self.state = 1465
                self.tableAlias()
                self.state = 1467
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.WHERE:
                    self.state = 1466
                    self.whereClause()


                pass
            elif token in [sqlParser.UPDATE]:
                localctx = sqlParser.UpdateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1469
                self.match(sqlParser.UPDATE)
                self.state = 1470
                self.multipartIdentifier()
                self.state = 1471
                self.tableAlias()
                self.state = 1472
                self.setClause()
                self.state = 1474
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.WHERE:
                    self.state = 1473
                    self.whereClause()


                pass
            elif token in [sqlParser.MERGE]:
                localctx = sqlParser.MergeIntoTableContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1476
                self.match(sqlParser.MERGE)
                self.state = 1477
                self.match(sqlParser.INTO)
                self.state = 1478
                localctx.target = self.multipartIdentifier()
                self.state = 1479
                localctx.targetAlias = self.tableAlias()
                self.state = 1480
                self.match(sqlParser.USING)
                self.state = 1486
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
                if la_ == 1:
                    self.state = 1481
                    localctx.source = self.multipartIdentifier()
                    pass

                elif la_ == 2:
                    self.state = 1482
                    self.match(sqlParser.T__1)
                    self.state = 1483
                    localctx.sourceQuery = self.query()
                    self.state = 1484
                    self.match(sqlParser.T__2)
                    pass


                self.state = 1488
                localctx.sourceAlias = self.tableAlias()
                self.state = 1489
                self.match(sqlParser.ON)
                self.state = 1490
                localctx.mergeCondition = self.booleanExpression(0)
                self.state = 1494
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,161,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1491
                        self.matchedClause() 
                    self.state = 1496
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,161,self._ctx)

                self.state = 1500
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.WHEN:
                    self.state = 1497
                    self.notMatchedClause()
                    self.state = 1502
                    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 QueryOrganizationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._sortItem = None # SortItemContext
            self.order = list() # of SortItemContexts
            self._expression = None # ExpressionContext
            self.clusterBy = list() # of ExpressionContexts
            self.distributeBy = list() # of ExpressionContexts
            self.sort = list() # of SortItemContexts
            self.limit = None # ExpressionContext

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

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

        def CLUSTER(self):
            return self.getToken(sqlParser.CLUSTER, 0)

        def DISTRIBUTE(self):
            return self.getToken(sqlParser.DISTRIBUTE, 0)

        def SORT(self):
            return self.getToken(sqlParser.SORT, 0)

        def windowClause(self):
            return self.getTypedRuleContext(sqlParser.WindowClauseContext,0)


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

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.SortItemContext)
            else:
                return self.getTypedRuleContext(sqlParser.SortItemContext,i)


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


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

        def getRuleIndex(self):
            return sqlParser.RULE_queryOrganization

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




    def queryOrganization(self):

        localctx = sqlParser.QueryOrganizationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_queryOrganization)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1515
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
            if la_ == 1:
                self.state = 1505
                self.match(sqlParser.ORDER)
                self.state = 1506
                self.match(sqlParser.BY)
                self.state = 1507
                localctx._sortItem = self.sortItem()
                localctx.order.append(localctx._sortItem)
                self.state = 1512
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,164,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1508
                        self.match(sqlParser.T__3)
                        self.state = 1509
                        localctx._sortItem = self.sortItem()
                        localctx.order.append(localctx._sortItem) 
                    self.state = 1514
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,164,self._ctx)



            self.state = 1527
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
            if la_ == 1:
                self.state = 1517
                self.match(sqlParser.CLUSTER)
                self.state = 1518
                self.match(sqlParser.BY)
                self.state = 1519
                localctx._expression = self.expression()
                localctx.clusterBy.append(localctx._expression)
                self.state = 1524
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,166,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1520
                        self.match(sqlParser.T__3)
                        self.state = 1521
                        localctx._expression = self.expression()
                        localctx.clusterBy.append(localctx._expression) 
                    self.state = 1526
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,166,self._ctx)



            self.state = 1539
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
            if la_ == 1:
                self.state = 1529
                self.match(sqlParser.DISTRIBUTE)
                self.state = 1530
                self.match(sqlParser.BY)
                self.state = 1531
                localctx._expression = self.expression()
                localctx.distributeBy.append(localctx._expression)
                self.state = 1536
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,168,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1532
                        self.match(sqlParser.T__3)
                        self.state = 1533
                        localctx._expression = self.expression()
                        localctx.distributeBy.append(localctx._expression) 
                    self.state = 1538
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,168,self._ctx)



            self.state = 1551
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
            if la_ == 1:
                self.state = 1541
                self.match(sqlParser.SORT)
                self.state = 1542
                self.match(sqlParser.BY)
                self.state = 1543
                localctx._sortItem = self.sortItem()
                localctx.sort.append(localctx._sortItem)
                self.state = 1548
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,170,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1544
                        self.match(sqlParser.T__3)
                        self.state = 1545
                        localctx._sortItem = self.sortItem()
                        localctx.sort.append(localctx._sortItem) 
                    self.state = 1550
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,170,self._ctx)



            self.state = 1554
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
            if la_ == 1:
                self.state = 1553
                self.windowClause()


            self.state = 1561
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
            if la_ == 1:
                self.state = 1556
                self.match(sqlParser.LIMIT)
                self.state = 1559
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
                if la_ == 1:
                    self.state = 1557
                    self.match(sqlParser.ALL)
                    pass

                elif la_ == 2:
                    self.state = 1558
                    localctx.limit = self.expression()
                    pass




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


    class MultiInsertQueryBodyContext(ParserRuleContext):

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

        def insertInto(self):
            return self.getTypedRuleContext(sqlParser.InsertIntoContext,0)


        def fromStatementBody(self):
            return self.getTypedRuleContext(sqlParser.FromStatementBodyContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_multiInsertQueryBody

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




    def multiInsertQueryBody(self):

        localctx = sqlParser.MultiInsertQueryBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_multiInsertQueryBody)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1563
            self.insertInto()
            self.state = 1564
            self.fromStatementBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryTermContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_queryTerm

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


    class QueryTermDefaultContext(QueryTermContext):

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

        def queryPrimary(self):
            return self.getTypedRuleContext(sqlParser.QueryPrimaryContext,0)


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


    class SetOperationContext(QueryTermContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.QueryTermContext
            super().__init__(parser)
            self.left = None # QueryTermContext
            self.operator = None # Token
            self.right = None # QueryTermContext
            self.copyFrom(ctx)

        def queryTerm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.QueryTermContext)
            else:
                return self.getTypedRuleContext(sqlParser.QueryTermContext,i)

        def INTERSECT(self):
            return self.getToken(sqlParser.INTERSECT, 0)
        def UNION(self):
            return self.getToken(sqlParser.UNION, 0)
        def EXCEPT(self):
            return self.getToken(sqlParser.EXCEPT, 0)
        def SETMINUS(self):
            return self.getToken(sqlParser.SETMINUS, 0)
        def setQuantifier(self):
            return self.getTypedRuleContext(sqlParser.SetQuantifierContext,0)


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



    def queryTerm(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = sqlParser.QueryTermContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 80
        self.enterRecursionRule(localctx, 80, self.RULE_queryTerm, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = sqlParser.QueryTermDefaultContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 1567
            self.queryPrimary()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1592
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,179,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 = 1590
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
                    if la_ == 1:
                        localctx = sqlParser.SetOperationContext(self, sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 1569
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1570
                        if not self.legacy_setops_precedence_enbled:
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.legacy_setops_precedence_enbled")
                        self.state = 1571
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==sqlParser.EXCEPT or _la==sqlParser.INTERSECT or _la==sqlParser.SETMINUS or _la==sqlParser.UNION):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1573
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==sqlParser.ALL or _la==sqlParser.DISTINCT:
                            self.state = 1572
                            self.setQuantifier()


                        self.state = 1575
                        localctx.right = self.queryTerm(4)
                        pass

                    elif la_ == 2:
                        localctx = sqlParser.SetOperationContext(self, sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 1576
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1577
                        if not not self.legacy_setops_precedence_enbled:
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "not self.legacy_setops_precedence_enbled")
                        self.state = 1578
                        localctx.operator = self.match(sqlParser.INTERSECT)
                        self.state = 1580
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==sqlParser.ALL or _la==sqlParser.DISTINCT:
                            self.state = 1579
                            self.setQuantifier()


                        self.state = 1582
                        localctx.right = self.queryTerm(3)
                        pass

                    elif la_ == 3:
                        localctx = sqlParser.SetOperationContext(self, sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 1583
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1584
                        if not not self.legacy_setops_precedence_enbled:
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "not self.legacy_setops_precedence_enbled")
                        self.state = 1585
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==sqlParser.EXCEPT or _la==sqlParser.SETMINUS or _la==sqlParser.UNION):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1587
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==sqlParser.ALL or _la==sqlParser.DISTINCT:
                            self.state = 1586
                            self.setQuantifier()


                        self.state = 1589
                        localctx.right = self.queryTerm(2)
                        pass

             
                self.state = 1594
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,179,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 QueryPrimaryContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_queryPrimary

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



    class SubqueryContext(QueryPrimaryContext):

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

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)


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


    class QueryPrimaryDefaultContext(QueryPrimaryContext):

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

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


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


    class InlineTableDefault1Context(QueryPrimaryContext):

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

        def inlineTable(self):
            return self.getTypedRuleContext(sqlParser.InlineTableContext,0)


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


    class FromStmtContext(QueryPrimaryContext):

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

        def fromStatement(self):
            return self.getTypedRuleContext(sqlParser.FromStatementContext,0)


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


    class TableContext(QueryPrimaryContext):

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

        def TABLE(self):
            return self.getToken(sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


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



    def queryPrimary(self):

        localctx = sqlParser.QueryPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_queryPrimary)
        try:
            self.state = 1604
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.MAP, sqlParser.REDUCE, sqlParser.SELECT]:
                localctx = sqlParser.QueryPrimaryDefaultContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1595
                self.querySpecification()
                pass
            elif token in [sqlParser.FROM]:
                localctx = sqlParser.FromStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1596
                self.fromStatement()
                pass
            elif token in [sqlParser.TABLE]:
                localctx = sqlParser.TableContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1597
                self.match(sqlParser.TABLE)
                self.state = 1598
                self.multipartIdentifier()
                pass
            elif token in [sqlParser.VALUES]:
                localctx = sqlParser.InlineTableDefault1Context(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1599
                self.inlineTable()
                pass
            elif token in [sqlParser.T__1]:
                localctx = sqlParser.SubqueryContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1600
                self.match(sqlParser.T__1)
                self.state = 1601
                self.query()
                self.state = 1602
                self.match(sqlParser.T__2)
                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 SortItemContext(ParserRuleContext):

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

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


        def NULLS(self):
            return self.getToken(sqlParser.NULLS, 0)

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

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

        def LAST(self):
            return self.getToken(sqlParser.LAST, 0)

        def FIRST(self):
            return self.getToken(sqlParser.FIRST, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_sortItem

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




    def sortItem(self):

        localctx = sqlParser.SortItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_sortItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1606
            self.expression()
            self.state = 1608
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
            if la_ == 1:
                self.state = 1607
                localctx.ordering = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.ASC or _la==sqlParser.DESC):
                    localctx.ordering = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1612
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
            if la_ == 1:
                self.state = 1610
                self.match(sqlParser.NULLS)
                self.state = 1611
                localctx.nullOrder = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.FIRST or _la==sqlParser.LAST):
                    localctx.nullOrder = 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 FromStatementContext(ParserRuleContext):

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

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


        def fromStatementBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.FromStatementBodyContext)
            else:
                return self.getTypedRuleContext(sqlParser.FromStatementBodyContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_fromStatement

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




    def fromStatement(self):

        localctx = sqlParser.FromStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_fromStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1614
            self.fromClause()
            self.state = 1616 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1615
                    self.fromStatementBody()

                else:
                    raise NoViableAltException(self)
                self.state = 1618 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,183,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 FromStatementBodyContext(ParserRuleContext):

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

        def transformClause(self):
            return self.getTypedRuleContext(sqlParser.TransformClauseContext,0)


        def queryOrganization(self):
            return self.getTypedRuleContext(sqlParser.QueryOrganizationContext,0)


        def whereClause(self):
            return self.getTypedRuleContext(sqlParser.WhereClauseContext,0)


        def selectClause(self):
            return self.getTypedRuleContext(sqlParser.SelectClauseContext,0)


        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(sqlParser.LateralViewContext,i)


        def aggregationClause(self):
            return self.getTypedRuleContext(sqlParser.AggregationClauseContext,0)


        def havingClause(self):
            return self.getTypedRuleContext(sqlParser.HavingClauseContext,0)


        def windowClause(self):
            return self.getTypedRuleContext(sqlParser.WindowClauseContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_fromStatementBody

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




    def fromStatementBody(self):

        localctx = sqlParser.FromStatementBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_fromStatementBody)
        try:
            self.state = 1647
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1620
                self.transformClause()
                self.state = 1622
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,184,self._ctx)
                if la_ == 1:
                    self.state = 1621
                    self.whereClause()


                self.state = 1624
                self.queryOrganization()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1626
                self.selectClause()
                self.state = 1630
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,185,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1627
                        self.lateralView() 
                    self.state = 1632
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,185,self._ctx)

                self.state = 1634
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
                if la_ == 1:
                    self.state = 1633
                    self.whereClause()


                self.state = 1637
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
                if la_ == 1:
                    self.state = 1636
                    self.aggregationClause()


                self.state = 1640
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,188,self._ctx)
                if la_ == 1:
                    self.state = 1639
                    self.havingClause()


                self.state = 1643
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,189,self._ctx)
                if la_ == 1:
                    self.state = 1642
                    self.windowClause()


                self.state = 1645
                self.queryOrganization()
                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 getRuleIndex(self):
            return sqlParser.RULE_querySpecification

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



    class RegularQuerySpecificationContext(QuerySpecificationContext):

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

        def selectClause(self):
            return self.getTypedRuleContext(sqlParser.SelectClauseContext,0)

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

        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(sqlParser.LateralViewContext,i)

        def whereClause(self):
            return self.getTypedRuleContext(sqlParser.WhereClauseContext,0)

        def aggregationClause(self):
            return self.getTypedRuleContext(sqlParser.AggregationClauseContext,0)

        def havingClause(self):
            return self.getTypedRuleContext(sqlParser.HavingClauseContext,0)

        def windowClause(self):
            return self.getTypedRuleContext(sqlParser.WindowClauseContext,0)


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


    class TransformQuerySpecificationContext(QuerySpecificationContext):

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

        def transformClause(self):
            return self.getTypedRuleContext(sqlParser.TransformClauseContext,0)

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

        def whereClause(self):
            return self.getTypedRuleContext(sqlParser.WhereClauseContext,0)


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



    def querySpecification(self):

        localctx = sqlParser.QuerySpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_querySpecification)
        try:
            self.state = 1678
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
            if la_ == 1:
                localctx = sqlParser.TransformQuerySpecificationContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1649
                self.transformClause()
                self.state = 1651
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
                if la_ == 1:
                    self.state = 1650
                    self.fromClause()


                self.state = 1654
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,192,self._ctx)
                if la_ == 1:
                    self.state = 1653
                    self.whereClause()


                pass

            elif la_ == 2:
                localctx = sqlParser.RegularQuerySpecificationContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1656
                self.selectClause()
                self.state = 1658
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
                if la_ == 1:
                    self.state = 1657
                    self.fromClause()


                self.state = 1663
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,194,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1660
                        self.lateralView() 
                    self.state = 1665
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,194,self._ctx)

                self.state = 1667
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
                if la_ == 1:
                    self.state = 1666
                    self.whereClause()


                self.state = 1670
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
                if la_ == 1:
                    self.state = 1669
                    self.aggregationClause()


                self.state = 1673
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
                if la_ == 1:
                    self.state = 1672
                    self.havingClause()


                self.state = 1676
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
                if la_ == 1:
                    self.state = 1675
                    self.windowClause()


                pass


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


    class TransformClauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.kind = None # Token
            self.inRowFormat = None # RowFormatContext
            self.recordWriter = None # Token
            self.script = None # Token
            self.outRowFormat = None # RowFormatContext
            self.recordReader = None # Token

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

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

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

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(sqlParser.NamedExpressionSeqContext,0)


        def TRANSFORM(self):
            return self.getToken(sqlParser.TRANSFORM, 0)

        def MAP(self):
            return self.getToken(sqlParser.MAP, 0)

        def REDUCE(self):
            return self.getToken(sqlParser.REDUCE, 0)

        def RECORDWRITER(self):
            return self.getToken(sqlParser.RECORDWRITER, 0)

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

        def RECORDREADER(self):
            return self.getToken(sqlParser.RECORDREADER, 0)

        def rowFormat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.RowFormatContext)
            else:
                return self.getTypedRuleContext(sqlParser.RowFormatContext,i)


        def identifierSeq(self):
            return self.getTypedRuleContext(sqlParser.IdentifierSeqContext,0)


        def colTypeList(self):
            return self.getTypedRuleContext(sqlParser.ColTypeListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_transformClause

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




    def transformClause(self):

        localctx = sqlParser.TransformClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_transformClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1690
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.SELECT]:
                self.state = 1680
                self.match(sqlParser.SELECT)
                self.state = 1681
                localctx.kind = self.match(sqlParser.TRANSFORM)
                self.state = 1682
                self.match(sqlParser.T__1)
                self.state = 1683
                self.namedExpressionSeq()
                self.state = 1684
                self.match(sqlParser.T__2)
                pass
            elif token in [sqlParser.MAP]:
                self.state = 1686
                localctx.kind = self.match(sqlParser.MAP)
                self.state = 1687
                self.namedExpressionSeq()
                pass
            elif token in [sqlParser.REDUCE]:
                self.state = 1688
                localctx.kind = self.match(sqlParser.REDUCE)
                self.state = 1689
                self.namedExpressionSeq()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1693
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.ROW:
                self.state = 1692
                localctx.inRowFormat = self.rowFormat()


            self.state = 1697
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.RECORDWRITER:
                self.state = 1695
                self.match(sqlParser.RECORDWRITER)
                self.state = 1696
                localctx.recordWriter = self.match(sqlParser.STRING)


            self.state = 1699
            self.match(sqlParser.USING)
            self.state = 1700
            localctx.script = self.match(sqlParser.STRING)
            self.state = 1713
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
            if la_ == 1:
                self.state = 1701
                self.match(sqlParser.AS)
                self.state = 1711
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,204,self._ctx)
                if la_ == 1:
                    self.state = 1702
                    self.identifierSeq()
                    pass

                elif la_ == 2:
                    self.state = 1703
                    self.colTypeList()
                    pass

                elif la_ == 3:
                    self.state = 1704
                    self.match(sqlParser.T__1)
                    self.state = 1707
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
                    if la_ == 1:
                        self.state = 1705
                        self.identifierSeq()
                        pass

                    elif la_ == 2:
                        self.state = 1706
                        self.colTypeList()
                        pass


                    self.state = 1709
                    self.match(sqlParser.T__2)
                    pass




            self.state = 1716
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
            if la_ == 1:
                self.state = 1715
                localctx.outRowFormat = self.rowFormat()


            self.state = 1720
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,207,self._ctx)
            if la_ == 1:
                self.state = 1718
                self.match(sqlParser.RECORDREADER)
                self.state = 1719
                localctx.recordReader = self.match(sqlParser.STRING)


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


    class SelectClauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._hint = None # HintContext
            self.hints = list() # of HintContexts

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

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(sqlParser.NamedExpressionSeqContext,0)


        def setQuantifier(self):
            return self.getTypedRuleContext(sqlParser.SetQuantifierContext,0)


        def hint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.HintContext)
            else:
                return self.getTypedRuleContext(sqlParser.HintContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_selectClause

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




    def selectClause(self):

        localctx = sqlParser.SelectClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_selectClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1722
            self.match(sqlParser.SELECT)
            self.state = 1726
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,208,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1723
                    localctx._hint = self.hint()
                    localctx.hints.append(localctx._hint) 
                self.state = 1728
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,208,self._ctx)

            self.state = 1730
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
            if la_ == 1:
                self.state = 1729
                self.setQuantifier()


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


    class SetClauseContext(ParserRuleContext):

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

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

        def assignmentList(self):
            return self.getTypedRuleContext(sqlParser.AssignmentListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_setClause

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




    def setClause(self):

        localctx = sqlParser.SetClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_setClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1734
            self.match(sqlParser.SET)
            self.state = 1735
            self.assignmentList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MatchedClauseContext(ParserRuleContext):

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

        def WHEN(self):
            return self.getToken(sqlParser.WHEN, 0)

        def MATCHED(self):
            return self.getToken(sqlParser.MATCHED, 0)

        def THEN(self):
            return self.getToken(sqlParser.THEN, 0)

        def matchedAction(self):
            return self.getTypedRuleContext(sqlParser.MatchedActionContext,0)


        def AND(self):
            return self.getToken(sqlParser.AND, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_matchedClause

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




    def matchedClause(self):

        localctx = sqlParser.MatchedClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_matchedClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1737
            self.match(sqlParser.WHEN)
            self.state = 1738
            self.match(sqlParser.MATCHED)
            self.state = 1741
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.AND:
                self.state = 1739
                self.match(sqlParser.AND)
                self.state = 1740
                localctx.matchedCond = self.booleanExpression(0)


            self.state = 1743
            self.match(sqlParser.THEN)
            self.state = 1744
            self.matchedAction()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NotMatchedClauseContext(ParserRuleContext):

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

        def WHEN(self):
            return self.getToken(sqlParser.WHEN, 0)

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

        def MATCHED(self):
            return self.getToken(sqlParser.MATCHED, 0)

        def THEN(self):
            return self.getToken(sqlParser.THEN, 0)

        def notMatchedAction(self):
            return self.getTypedRuleContext(sqlParser.NotMatchedActionContext,0)


        def AND(self):
            return self.getToken(sqlParser.AND, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_notMatchedClause

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




    def notMatchedClause(self):

        localctx = sqlParser.NotMatchedClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_notMatchedClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1746
            self.match(sqlParser.WHEN)
            self.state = 1747
            self.match(sqlParser.NOT)
            self.state = 1748
            self.match(sqlParser.MATCHED)
            self.state = 1751
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.AND:
                self.state = 1749
                self.match(sqlParser.AND)
                self.state = 1750
                localctx.notMatchedCond = self.booleanExpression(0)


            self.state = 1753
            self.match(sqlParser.THEN)
            self.state = 1754
            self.notMatchedAction()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MatchedActionContext(ParserRuleContext):

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

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

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

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

        def ASTERISK(self):
            return self.getToken(sqlParser.ASTERISK, 0)

        def assignmentList(self):
            return self.getTypedRuleContext(sqlParser.AssignmentListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_matchedAction

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




    def matchedAction(self):

        localctx = sqlParser.MatchedActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_matchedAction)
        try:
            self.state = 1763
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1756
                self.match(sqlParser.DELETE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1757
                self.match(sqlParser.UPDATE)
                self.state = 1758
                self.match(sqlParser.SET)
                self.state = 1759
                self.match(sqlParser.ASTERISK)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1760
                self.match(sqlParser.UPDATE)
                self.state = 1761
                self.match(sqlParser.SET)
                self.state = 1762
                self.assignmentList()
                pass


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


    class NotMatchedActionContext(ParserRuleContext):

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

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

        def ASTERISK(self):
            return self.getToken(sqlParser.ASTERISK, 0)

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

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


        def multipartIdentifierList(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_notMatchedAction

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




    def notMatchedAction(self):

        localctx = sqlParser.NotMatchedActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_notMatchedAction)
        self._la = 0 # Token type
        try:
            self.state = 1783
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,214,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1765
                self.match(sqlParser.INSERT)
                self.state = 1766
                self.match(sqlParser.ASTERISK)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1767
                self.match(sqlParser.INSERT)
                self.state = 1768
                self.match(sqlParser.T__1)
                self.state = 1769
                localctx.columns = self.multipartIdentifierList()
                self.state = 1770
                self.match(sqlParser.T__2)
                self.state = 1771
                self.match(sqlParser.VALUES)
                self.state = 1772
                self.match(sqlParser.T__1)
                self.state = 1773
                self.expression()
                self.state = 1778
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 1774
                    self.match(sqlParser.T__3)
                    self.state = 1775
                    self.expression()
                    self.state = 1780
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1781
                self.match(sqlParser.T__2)
                pass


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


    class AssignmentListContext(ParserRuleContext):

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

        def assignment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.AssignmentContext)
            else:
                return self.getTypedRuleContext(sqlParser.AssignmentContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_assignmentList

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




    def assignmentList(self):

        localctx = sqlParser.AssignmentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_assignmentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1785
            self.assignment()
            self.state = 1790
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 1786
                self.match(sqlParser.T__3)
                self.state = 1787
                self.assignment()
                self.state = 1792
                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 AssignmentContext(ParserRuleContext):

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

        def EQ(self):
            return self.getToken(sqlParser.EQ, 0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


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


        def getRuleIndex(self):
            return sqlParser.RULE_assignment

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




    def assignment(self):

        localctx = sqlParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1793
            localctx.key = self.multipartIdentifier()
            self.state = 1794
            self.match(sqlParser.EQ)
            self.state = 1795
            localctx.value = self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhereClauseContext(ParserRuleContext):

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

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

        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_whereClause

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




    def whereClause(self):

        localctx = sqlParser.WhereClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_whereClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1797
            self.match(sqlParser.WHERE)
            self.state = 1798
            self.booleanExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HavingClauseContext(ParserRuleContext):

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

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

        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_havingClause

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




    def havingClause(self):

        localctx = sqlParser.HavingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_havingClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1800
            self.match(sqlParser.HAVING)
            self.state = 1801
            self.booleanExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HintContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._hintStatement = None # HintStatementContext
            self.hintStatements = list() # of HintStatementContexts

        def hintStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.HintStatementContext)
            else:
                return self.getTypedRuleContext(sqlParser.HintStatementContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_hint

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




    def hint(self):

        localctx = sqlParser.HintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_hint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1803
            self.match(sqlParser.T__5)
            self.state = 1804
            localctx._hintStatement = self.hintStatement()
            localctx.hintStatements.append(localctx._hintStatement)
            self.state = 1811
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,217,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1806
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
                    if la_ == 1:
                        self.state = 1805
                        self.match(sqlParser.T__3)


                    self.state = 1808
                    localctx._hintStatement = self.hintStatement()
                    localctx.hintStatements.append(localctx._hintStatement) 
                self.state = 1813
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,217,self._ctx)

            self.state = 1814
            self.match(sqlParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HintStatementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.hintName = None # IdentifierContext
            self._primaryExpression = None # PrimaryExpressionContext
            self.parameters = list() # of PrimaryExpressionContexts

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


        def primaryExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.PrimaryExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.PrimaryExpressionContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_hintStatement

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




    def hintStatement(self):

        localctx = sqlParser.HintStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_hintStatement)
        self._la = 0 # Token type
        try:
            self.state = 1829
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,219,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1816
                localctx.hintName = self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1817
                localctx.hintName = self.identifier()
                self.state = 1818
                self.match(sqlParser.T__1)
                self.state = 1819
                localctx._primaryExpression = self.primaryExpression(0)
                localctx.parameters.append(localctx._primaryExpression)
                self.state = 1824
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 1820
                    self.match(sqlParser.T__3)
                    self.state = 1821
                    localctx._primaryExpression = self.primaryExpression(0)
                    localctx.parameters.append(localctx._primaryExpression)
                    self.state = 1826
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1827
                self.match(sqlParser.T__2)
                pass


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


    class FromClauseContext(ParserRuleContext):

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

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

        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.RelationContext)
            else:
                return self.getTypedRuleContext(sqlParser.RelationContext,i)


        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(sqlParser.LateralViewContext,i)


        def pivotClause(self):
            return self.getTypedRuleContext(sqlParser.PivotClauseContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_fromClause

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




    def fromClause(self):

        localctx = sqlParser.FromClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_fromClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1831
            self.match(sqlParser.FROM)
            self.state = 1832
            self.relation()
            self.state = 1837
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,220,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1833
                    self.match(sqlParser.T__3)
                    self.state = 1834
                    self.relation() 
                self.state = 1839
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,220,self._ctx)

            self.state = 1843
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,221,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1840
                    self.lateralView() 
                self.state = 1845
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,221,self._ctx)

            self.state = 1847
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,222,self._ctx)
            if la_ == 1:
                self.state = 1846
                self.pivotClause()


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


    class AggregationClauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._expression = None # ExpressionContext
            self.groupingExpressions = list() # of ExpressionContexts
            self.kind = None # Token

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

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

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


        def WITH(self):
            return self.getToken(sqlParser.WITH, 0)

        def SETS(self):
            return self.getToken(sqlParser.SETS, 0)

        def groupingSet(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.GroupingSetContext)
            else:
                return self.getTypedRuleContext(sqlParser.GroupingSetContext,i)


        def ROLLUP(self):
            return self.getToken(sqlParser.ROLLUP, 0)

        def CUBE(self):
            return self.getToken(sqlParser.CUBE, 0)

        def GROUPING(self):
            return self.getToken(sqlParser.GROUPING, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_aggregationClause

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




    def aggregationClause(self):

        localctx = sqlParser.AggregationClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_aggregationClause)
        self._la = 0 # Token type
        try:
            self.state = 1893
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,227,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1849
                self.match(sqlParser.GROUP)
                self.state = 1850
                self.match(sqlParser.BY)
                self.state = 1851
                localctx._expression = self.expression()
                localctx.groupingExpressions.append(localctx._expression)
                self.state = 1856
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,223,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1852
                        self.match(sqlParser.T__3)
                        self.state = 1853
                        localctx._expression = self.expression()
                        localctx.groupingExpressions.append(localctx._expression) 
                    self.state = 1858
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,223,self._ctx)

                self.state = 1876
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
                if la_ == 1:
                    self.state = 1859
                    self.match(sqlParser.WITH)
                    self.state = 1860
                    localctx.kind = self.match(sqlParser.ROLLUP)

                elif la_ == 2:
                    self.state = 1861
                    self.match(sqlParser.WITH)
                    self.state = 1862
                    localctx.kind = self.match(sqlParser.CUBE)

                elif la_ == 3:
                    self.state = 1863
                    localctx.kind = self.match(sqlParser.GROUPING)
                    self.state = 1864
                    self.match(sqlParser.SETS)
                    self.state = 1865
                    self.match(sqlParser.T__1)
                    self.state = 1866
                    self.groupingSet()
                    self.state = 1871
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==sqlParser.T__3:
                        self.state = 1867
                        self.match(sqlParser.T__3)
                        self.state = 1868
                        self.groupingSet()
                        self.state = 1873
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1874
                    self.match(sqlParser.T__2)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1878
                self.match(sqlParser.GROUP)
                self.state = 1879
                self.match(sqlParser.BY)
                self.state = 1880
                localctx.kind = self.match(sqlParser.GROUPING)
                self.state = 1881
                self.match(sqlParser.SETS)
                self.state = 1882
                self.match(sqlParser.T__1)
                self.state = 1883
                self.groupingSet()
                self.state = 1888
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 1884
                    self.match(sqlParser.T__3)
                    self.state = 1885
                    self.groupingSet()
                    self.state = 1890
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1891
                self.match(sqlParser.T__2)
                pass


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


    class GroupingSetContext(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(sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ExpressionContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_groupingSet

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




    def groupingSet(self):

        localctx = sqlParser.GroupingSetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_groupingSet)
        self._la = 0 # Token type
        try:
            self.state = 1908
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1895
                self.match(sqlParser.T__1)
                self.state = 1904
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
                if la_ == 1:
                    self.state = 1896
                    self.expression()
                    self.state = 1901
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==sqlParser.T__3:
                        self.state = 1897
                        self.match(sqlParser.T__3)
                        self.state = 1898
                        self.expression()
                        self.state = 1903
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1906
                self.match(sqlParser.T__2)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1907
                self.expression()
                pass


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


    class PivotClauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.aggregates = None # NamedExpressionSeqContext
            self._pivotValue = None # PivotValueContext
            self.pivotValues = list() # of PivotValueContexts

        def PIVOT(self):
            return self.getToken(sqlParser.PIVOT, 0)

        def FOR(self):
            return self.getToken(sqlParser.FOR, 0)

        def pivotColumn(self):
            return self.getTypedRuleContext(sqlParser.PivotColumnContext,0)


        def IN(self):
            return self.getToken(sqlParser.IN, 0)

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(sqlParser.NamedExpressionSeqContext,0)


        def pivotValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.PivotValueContext)
            else:
                return self.getTypedRuleContext(sqlParser.PivotValueContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_pivotClause

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




    def pivotClause(self):

        localctx = sqlParser.PivotClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_pivotClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1910
            self.match(sqlParser.PIVOT)
            self.state = 1911
            self.match(sqlParser.T__1)
            self.state = 1912
            localctx.aggregates = self.namedExpressionSeq()
            self.state = 1913
            self.match(sqlParser.FOR)
            self.state = 1914
            self.pivotColumn()
            self.state = 1915
            self.match(sqlParser.IN)
            self.state = 1916
            self.match(sqlParser.T__1)
            self.state = 1917
            localctx._pivotValue = self.pivotValue()
            localctx.pivotValues.append(localctx._pivotValue)
            self.state = 1922
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 1918
                self.match(sqlParser.T__3)
                self.state = 1919
                localctx._pivotValue = self.pivotValue()
                localctx.pivotValues.append(localctx._pivotValue)
                self.state = 1924
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1925
            self.match(sqlParser.T__2)
            self.state = 1926
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PivotColumnContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._identifier = None # IdentifierContext
            self.identifiers = list() # of IdentifierContexts

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_pivotColumn

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




    def pivotColumn(self):

        localctx = sqlParser.PivotColumnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_pivotColumn)
        self._la = 0 # Token type
        try:
            self.state = 1940
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1928
                localctx._identifier = self.identifier()
                localctx.identifiers.append(localctx._identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1929
                self.match(sqlParser.T__1)
                self.state = 1930
                localctx._identifier = self.identifier()
                localctx.identifiers.append(localctx._identifier)
                self.state = 1935
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 1931
                    self.match(sqlParser.T__3)
                    self.state = 1932
                    localctx._identifier = self.identifier()
                    localctx.identifiers.append(localctx._identifier)
                    self.state = 1937
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1938
                self.match(sqlParser.T__2)
                pass


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


    class PivotValueContext(ParserRuleContext):

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

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


        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


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

        def getRuleIndex(self):
            return sqlParser.RULE_pivotValue

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




    def pivotValue(self):

        localctx = sqlParser.PivotValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_pivotValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1942
            self.expression()
            self.state = 1947
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,235,self._ctx)
            if la_ == 1:
                self.state = 1944
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
                if la_ == 1:
                    self.state = 1943
                    self.match(sqlParser.AS)


                self.state = 1946
                self.identifier()


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


    class LateralViewContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.tblName = None # IdentifierContext
            self._identifier = None # IdentifierContext
            self.colName = list() # of IdentifierContexts

        def LATERAL(self):
            return self.getToken(sqlParser.LATERAL, 0)

        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(sqlParser.QualifiedNameContext,0)


        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierContext,i)


        def OUTER(self):
            return self.getToken(sqlParser.OUTER, 0)

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


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

        def getRuleIndex(self):
            return sqlParser.RULE_lateralView

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




    def lateralView(self):

        localctx = sqlParser.LateralViewContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_lateralView)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1949
            self.match(sqlParser.LATERAL)
            self.state = 1950
            self.match(sqlParser.VIEW)
            self.state = 1952
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,236,self._ctx)
            if la_ == 1:
                self.state = 1951
                self.match(sqlParser.OUTER)


            self.state = 1954
            self.qualifiedName()
            self.state = 1955
            self.match(sqlParser.T__1)
            self.state = 1964
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
            if la_ == 1:
                self.state = 1956
                self.expression()
                self.state = 1961
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 1957
                    self.match(sqlParser.T__3)
                    self.state = 1958
                    self.expression()
                    self.state = 1963
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1966
            self.match(sqlParser.T__2)
            self.state = 1967
            localctx.tblName = self.identifier()
            self.state = 1979
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
            if la_ == 1:
                self.state = 1969
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,239,self._ctx)
                if la_ == 1:
                    self.state = 1968
                    self.match(sqlParser.AS)


                self.state = 1971
                localctx._identifier = self.identifier()
                localctx.colName.append(localctx._identifier)
                self.state = 1976
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,240,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1972
                        self.match(sqlParser.T__3)
                        self.state = 1973
                        localctx._identifier = self.identifier()
                        localctx.colName.append(localctx._identifier) 
                    self.state = 1978
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,240,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 SetQuantifierContext(ParserRuleContext):

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

        def DISTINCT(self):
            return self.getToken(sqlParser.DISTINCT, 0)

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

        def getRuleIndex(self):
            return sqlParser.RULE_setQuantifier

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




    def setQuantifier(self):

        localctx = sqlParser.SetQuantifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_setQuantifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1981
            _la = self._input.LA(1)
            if not(_la==sqlParser.ALL or _la==sqlParser.DISTINCT):
                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 RelationContext(ParserRuleContext):

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

        def relationPrimary(self):
            return self.getTypedRuleContext(sqlParser.RelationPrimaryContext,0)


        def joinRelation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.JoinRelationContext)
            else:
                return self.getTypedRuleContext(sqlParser.JoinRelationContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_relation

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




    def relation(self):

        localctx = sqlParser.RelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_relation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1983
            self.relationPrimary()
            self.state = 1987
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,242,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1984
                    self.joinRelation() 
                self.state = 1989
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,242,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 JoinRelationContext(ParserRuleContext):

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

        def JOIN(self):
            return self.getToken(sqlParser.JOIN, 0)

        def relationPrimary(self):
            return self.getTypedRuleContext(sqlParser.RelationPrimaryContext,0)


        def joinType(self):
            return self.getTypedRuleContext(sqlParser.JoinTypeContext,0)


        def joinCriteria(self):
            return self.getTypedRuleContext(sqlParser.JoinCriteriaContext,0)


        def NATURAL(self):
            return self.getToken(sqlParser.NATURAL, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_joinRelation

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




    def joinRelation(self):

        localctx = sqlParser.JoinRelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_joinRelation)
        try:
            self.state = 2001
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.ANTI, sqlParser.CROSS, sqlParser.FULL, sqlParser.INNER, sqlParser.JOIN, sqlParser.LEFT, sqlParser.RIGHT, sqlParser.SEMI]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1990
                self.joinType()
                self.state = 1991
                self.match(sqlParser.JOIN)
                self.state = 1992
                localctx.right = self.relationPrimary()
                self.state = 1994
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,243,self._ctx)
                if la_ == 1:
                    self.state = 1993
                    self.joinCriteria()


                pass
            elif token in [sqlParser.NATURAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1996
                self.match(sqlParser.NATURAL)
                self.state = 1997
                self.joinType()
                self.state = 1998
                self.match(sqlParser.JOIN)
                self.state = 1999
                localctx.right = self.relationPrimary()
                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 JoinTypeContext(ParserRuleContext):

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

        def INNER(self):
            return self.getToken(sqlParser.INNER, 0)

        def CROSS(self):
            return self.getToken(sqlParser.CROSS, 0)

        def LEFT(self):
            return self.getToken(sqlParser.LEFT, 0)

        def OUTER(self):
            return self.getToken(sqlParser.OUTER, 0)

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

        def RIGHT(self):
            return self.getToken(sqlParser.RIGHT, 0)

        def FULL(self):
            return self.getToken(sqlParser.FULL, 0)

        def ANTI(self):
            return self.getToken(sqlParser.ANTI, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_joinType

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




    def joinType(self):

        localctx = sqlParser.JoinTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_joinType)
        self._la = 0 # Token type
        try:
            self.state = 2027
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,251,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2004
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.INNER:
                    self.state = 2003
                    self.match(sqlParser.INNER)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2006
                self.match(sqlParser.CROSS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2007
                self.match(sqlParser.LEFT)
                self.state = 2009
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OUTER:
                    self.state = 2008
                    self.match(sqlParser.OUTER)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2012
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LEFT:
                    self.state = 2011
                    self.match(sqlParser.LEFT)


                self.state = 2014
                self.match(sqlParser.SEMI)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2015
                self.match(sqlParser.RIGHT)
                self.state = 2017
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OUTER:
                    self.state = 2016
                    self.match(sqlParser.OUTER)


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2019
                self.match(sqlParser.FULL)
                self.state = 2021
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.OUTER:
                    self.state = 2020
                    self.match(sqlParser.OUTER)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2024
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.LEFT:
                    self.state = 2023
                    self.match(sqlParser.LEFT)


                self.state = 2026
                self.match(sqlParser.ANTI)
                pass


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


    class JoinCriteriaContext(ParserRuleContext):

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

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

        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)


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

        def identifierList(self):
            return self.getTypedRuleContext(sqlParser.IdentifierListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_joinCriteria

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




    def joinCriteria(self):

        localctx = sqlParser.JoinCriteriaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_joinCriteria)
        try:
            self.state = 2033
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.ON]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2029
                self.match(sqlParser.ON)
                self.state = 2030
                self.booleanExpression(0)
                pass
            elif token in [sqlParser.USING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2031
                self.match(sqlParser.USING)
                self.state = 2032
                self.identifierList()
                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 SampleContext(ParserRuleContext):

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

        def TABLESAMPLE(self):
            return self.getToken(sqlParser.TABLESAMPLE, 0)

        def sampleMethod(self):
            return self.getTypedRuleContext(sqlParser.SampleMethodContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_sample

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




    def sample(self):

        localctx = sqlParser.SampleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_sample)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2035
            self.match(sqlParser.TABLESAMPLE)
            self.state = 2036
            self.match(sqlParser.T__1)
            self.state = 2038
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,253,self._ctx)
            if la_ == 1:
                self.state = 2037
                self.sampleMethod()


            self.state = 2040
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SampleMethodContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_sampleMethod

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



    class SampleByRowsContext(SampleMethodContext):

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

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

        def ROWS(self):
            return self.getToken(sqlParser.ROWS, 0)

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


    class SampleByPercentileContext(SampleMethodContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.SampleMethodContext
            super().__init__(parser)
            self.negativeSign = None # Token
            self.percentage = None # Token
            self.copyFrom(ctx)

        def PERCENTLIT(self):
            return self.getToken(sqlParser.PERCENTLIT, 0)
        def INTEGER_VALUE(self):
            return self.getToken(sqlParser.INTEGER_VALUE, 0)
        def DECIMAL_VALUE(self):
            return self.getToken(sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class SampleByBucketContext(SampleMethodContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.SampleMethodContext
            super().__init__(parser)
            self.sampleType = None # Token
            self.numerator = None # Token
            self.denominator = None # Token
            self.copyFrom(ctx)

        def OUT(self):
            return self.getToken(sqlParser.OUT, 0)
        def OF(self):
            return self.getToken(sqlParser.OF, 0)
        def BUCKET(self):
            return self.getToken(sqlParser.BUCKET, 0)
        def INTEGER_VALUE(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.INTEGER_VALUE)
            else:
                return self.getToken(sqlParser.INTEGER_VALUE, i)
        def ON(self):
            return self.getToken(sqlParser.ON, 0)
        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)

        def qualifiedName(self):
            return self.getTypedRuleContext(sqlParser.QualifiedNameContext,0)


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


    class SampleByBytesContext(SampleMethodContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.SampleMethodContext
            super().__init__(parser)
            self.bytes = None # ExpressionContext
            self.copyFrom(ctx)

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


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



    def sampleMethod(self):

        localctx = sqlParser.SampleMethodContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_sampleMethod)
        self._la = 0 # Token type
        try:
            self.state = 2066
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,257,self._ctx)
            if la_ == 1:
                localctx = sqlParser.SampleByPercentileContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2043
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2042
                    localctx.negativeSign = self.match(sqlParser.MINUS)


                self.state = 2045
                localctx.percentage = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.INTEGER_VALUE or _la==sqlParser.DECIMAL_VALUE):
                    localctx.percentage = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2046
                self.match(sqlParser.PERCENTLIT)
                pass

            elif la_ == 2:
                localctx = sqlParser.SampleByRowsContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2047
                self.expression()
                self.state = 2048
                self.match(sqlParser.ROWS)
                pass

            elif la_ == 3:
                localctx = sqlParser.SampleByBucketContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2050
                localctx.sampleType = self.match(sqlParser.BUCKET)
                self.state = 2051
                localctx.numerator = self.match(sqlParser.INTEGER_VALUE)
                self.state = 2052
                self.match(sqlParser.OUT)
                self.state = 2053
                self.match(sqlParser.OF)
                self.state = 2054
                localctx.denominator = self.match(sqlParser.INTEGER_VALUE)
                self.state = 2063
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.ON:
                    self.state = 2055
                    self.match(sqlParser.ON)
                    self.state = 2061
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,255,self._ctx)
                    if la_ == 1:
                        self.state = 2056
                        self.identifier()
                        pass

                    elif la_ == 2:
                        self.state = 2057
                        self.qualifiedName()
                        self.state = 2058
                        self.match(sqlParser.T__1)
                        self.state = 2059
                        self.match(sqlParser.T__2)
                        pass




                pass

            elif la_ == 4:
                localctx = sqlParser.SampleByBytesContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2065
                localctx.bytes = self.expression()
                pass


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


    class IdentifierListContext(ParserRuleContext):

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

        def identifierSeq(self):
            return self.getTypedRuleContext(sqlParser.IdentifierSeqContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_identifierList

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




    def identifierList(self):

        localctx = sqlParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_identifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2068
            self.match(sqlParser.T__1)
            self.state = 2069
            self.identifierSeq()
            self.state = 2070
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierSeqContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._errorCapturingIdentifier = None # ErrorCapturingIdentifierContext
            self.ident = list() # of ErrorCapturingIdentifierContexts

        def errorCapturingIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_identifierSeq

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




    def identifierSeq(self):

        localctx = sqlParser.IdentifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_identifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2072
            localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
            localctx.ident.append(localctx._errorCapturingIdentifier)
            self.state = 2077
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,258,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2073
                    self.match(sqlParser.T__3)
                    self.state = 2074
                    localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
                    localctx.ident.append(localctx._errorCapturingIdentifier) 
                self.state = 2079
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,258,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 OrderedIdentifierListContext(ParserRuleContext):

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

        def orderedIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.OrderedIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.OrderedIdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_orderedIdentifierList

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




    def orderedIdentifierList(self):

        localctx = sqlParser.OrderedIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_orderedIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2080
            self.match(sqlParser.T__1)
            self.state = 2081
            self.orderedIdentifier()
            self.state = 2086
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 2082
                self.match(sqlParser.T__3)
                self.state = 2083
                self.orderedIdentifier()
                self.state = 2088
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2089
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OrderedIdentifierContext(ParserRuleContext):

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

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


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

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

        def getRuleIndex(self):
            return sqlParser.RULE_orderedIdentifier

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




    def orderedIdentifier(self):

        localctx = sqlParser.OrderedIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_orderedIdentifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2091
            localctx.ident = self.errorCapturingIdentifier()
            self.state = 2093
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.ASC or _la==sqlParser.DESC:
                self.state = 2092
                localctx.ordering = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.ASC or _la==sqlParser.DESC):
                    localctx.ordering = 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 IdentifierCommentListContext(ParserRuleContext):

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

        def identifierComment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierCommentContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierCommentContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_identifierCommentList

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




    def identifierCommentList(self):

        localctx = sqlParser.IdentifierCommentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_identifierCommentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2095
            self.match(sqlParser.T__1)
            self.state = 2096
            self.identifierComment()
            self.state = 2101
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 2097
                self.match(sqlParser.T__3)
                self.state = 2098
                self.identifierComment()
                self.state = 2103
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2104
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierCommentContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


        def commentSpec(self):
            return self.getTypedRuleContext(sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_identifierComment

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




    def identifierComment(self):

        localctx = sqlParser.IdentifierCommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_identifierComment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2106
            self.identifier()
            self.state = 2108
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.COMMENT:
                self.state = 2107
                self.commentSpec()


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


    class RelationPrimaryContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_relationPrimary

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



    class AliasedRelationContext(RelationPrimaryContext):

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

        def relation(self):
            return self.getTypedRuleContext(sqlParser.RelationContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(sqlParser.TableAliasContext,0)

        def sample(self):
            return self.getTypedRuleContext(sqlParser.SampleContext,0)


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


    class AliasedQueryContext(RelationPrimaryContext):

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

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(sqlParser.TableAliasContext,0)

        def sample(self):
            return self.getTypedRuleContext(sqlParser.SampleContext,0)


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


    class TableNameContext(RelationPrimaryContext):

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

        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(sqlParser.TableAliasContext,0)

        def sample(self):
            return self.getTypedRuleContext(sqlParser.SampleContext,0)


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



    def relationPrimary(self):

        localctx = sqlParser.RelationPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_relationPrimary)
        try:
            self.state = 2132
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,266,self._ctx)
            if la_ == 1:
                localctx = sqlParser.TableNameContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2110
                self.multipartIdentifier()
                self.state = 2112
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,263,self._ctx)
                if la_ == 1:
                    self.state = 2111
                    self.sample()


                self.state = 2114
                self.tableAlias()
                pass

            elif la_ == 2:
                localctx = sqlParser.AliasedQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2116
                self.match(sqlParser.T__1)
                self.state = 2117
                self.query()
                self.state = 2118
                self.match(sqlParser.T__2)
                self.state = 2120
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,264,self._ctx)
                if la_ == 1:
                    self.state = 2119
                    self.sample()


                self.state = 2122
                self.tableAlias()
                pass

            elif la_ == 3:
                localctx = sqlParser.AliasedRelationContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2124
                self.match(sqlParser.T__1)
                self.state = 2125
                self.relation()
                self.state = 2126
                self.match(sqlParser.T__2)
                self.state = 2128
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,265,self._ctx)
                if la_ == 1:
                    self.state = 2127
                    self.sample()


                self.state = 2130
                self.tableAlias()
                pass


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


    class InlineTableContext(ParserRuleContext):

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

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

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


        def tableAlias(self):
            return self.getTypedRuleContext(sqlParser.TableAliasContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_inlineTable

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




    def inlineTable(self):

        localctx = sqlParser.InlineTableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_inlineTable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2134
            self.match(sqlParser.VALUES)
            self.state = 2135
            self.expression()
            self.state = 2140
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,267,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2136
                    self.match(sqlParser.T__3)
                    self.state = 2137
                    self.expression() 
                self.state = 2142
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,267,self._ctx)

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


    class FunctionTableContext(ParserRuleContext):

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

        def tableAlias(self):
            return self.getTypedRuleContext(sqlParser.TableAliasContext,0)


        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


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


        def getRuleIndex(self):
            return sqlParser.RULE_functionTable

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




    def functionTable(self):

        localctx = sqlParser.FunctionTableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_functionTable)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2145
            localctx.funcName = self.errorCapturingIdentifier()
            self.state = 2146
            self.match(sqlParser.T__1)
            self.state = 2155
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,269,self._ctx)
            if la_ == 1:
                self.state = 2147
                self.expression()
                self.state = 2152
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 2148
                    self.match(sqlParser.T__3)
                    self.state = 2149
                    self.expression()
                    self.state = 2154
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 2157
            self.match(sqlParser.T__2)
            self.state = 2158
            self.tableAlias()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableAliasContext(ParserRuleContext):

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

        def strictIdentifier(self):
            return self.getTypedRuleContext(sqlParser.StrictIdentifierContext,0)


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

        def identifierList(self):
            return self.getTypedRuleContext(sqlParser.IdentifierListContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_tableAlias

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




    def tableAlias(self):

        localctx = sqlParser.TableAliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_tableAlias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2167
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,272,self._ctx)
            if la_ == 1:
                self.state = 2161
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,270,self._ctx)
                if la_ == 1:
                    self.state = 2160
                    self.match(sqlParser.AS)


                self.state = 2163
                self.strictIdentifier()
                self.state = 2165
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,271,self._ctx)
                if la_ == 1:
                    self.state = 2164
                    self.identifierList()




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


    class RowFormatContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_rowFormat

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



    class RowFormatSerdeContext(RowFormatContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.RowFormatContext
            super().__init__(parser)
            self.name = None # Token
            self.props = None # TablePropertyListContext
            self.copyFrom(ctx)

        def ROW(self):
            return self.getToken(sqlParser.ROW, 0)
        def FORMAT(self):
            return self.getToken(sqlParser.FORMAT, 0)
        def SERDE(self):
            return self.getToken(sqlParser.SERDE, 0)
        def STRING(self):
            return self.getToken(sqlParser.STRING, 0)
        def WITH(self):
            return self.getToken(sqlParser.WITH, 0)
        def SERDEPROPERTIES(self):
            return self.getToken(sqlParser.SERDEPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(sqlParser.TablePropertyListContext,0)


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


    class RowFormatDelimitedContext(RowFormatContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.RowFormatContext
            super().__init__(parser)
            self.fieldsTerminatedBy = None # Token
            self.escapedBy = None # Token
            self.collectionItemsTerminatedBy = None # Token
            self.keysTerminatedBy = None # Token
            self.linesSeparatedBy = None # Token
            self.nullDefinedAs = None # Token
            self.copyFrom(ctx)

        def ROW(self):
            return self.getToken(sqlParser.ROW, 0)
        def FORMAT(self):
            return self.getToken(sqlParser.FORMAT, 0)
        def DELIMITED(self):
            return self.getToken(sqlParser.DELIMITED, 0)
        def FIELDS(self):
            return self.getToken(sqlParser.FIELDS, 0)
        def TERMINATED(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.TERMINATED)
            else:
                return self.getToken(sqlParser.TERMINATED, i)
        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.BY)
            else:
                return self.getToken(sqlParser.BY, i)
        def COLLECTION(self):
            return self.getToken(sqlParser.COLLECTION, 0)
        def ITEMS(self):
            return self.getToken(sqlParser.ITEMS, 0)
        def MAP(self):
            return self.getToken(sqlParser.MAP, 0)
        def KEYS(self):
            return self.getToken(sqlParser.KEYS, 0)
        def LINES(self):
            return self.getToken(sqlParser.LINES, 0)
        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)
        def DEFINED(self):
            return self.getToken(sqlParser.DEFINED, 0)
        def AS(self):
            return self.getToken(sqlParser.AS, 0)
        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.STRING)
            else:
                return self.getToken(sqlParser.STRING, i)
        def ESCAPED(self):
            return self.getToken(sqlParser.ESCAPED, 0)

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



    def rowFormat(self):

        localctx = sqlParser.RowFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_rowFormat)
        try:
            self.state = 2218
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,280,self._ctx)
            if la_ == 1:
                localctx = sqlParser.RowFormatSerdeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2169
                self.match(sqlParser.ROW)
                self.state = 2170
                self.match(sqlParser.FORMAT)
                self.state = 2171
                self.match(sqlParser.SERDE)
                self.state = 2172
                localctx.name = self.match(sqlParser.STRING)
                self.state = 2176
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,273,self._ctx)
                if la_ == 1:
                    self.state = 2173
                    self.match(sqlParser.WITH)
                    self.state = 2174
                    self.match(sqlParser.SERDEPROPERTIES)
                    self.state = 2175
                    localctx.props = self.tablePropertyList()


                pass

            elif la_ == 2:
                localctx = sqlParser.RowFormatDelimitedContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2178
                self.match(sqlParser.ROW)
                self.state = 2179
                self.match(sqlParser.FORMAT)
                self.state = 2180
                self.match(sqlParser.DELIMITED)
                self.state = 2190
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,275,self._ctx)
                if la_ == 1:
                    self.state = 2181
                    self.match(sqlParser.FIELDS)
                    self.state = 2182
                    self.match(sqlParser.TERMINATED)
                    self.state = 2183
                    self.match(sqlParser.BY)
                    self.state = 2184
                    localctx.fieldsTerminatedBy = self.match(sqlParser.STRING)
                    self.state = 2188
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
                    if la_ == 1:
                        self.state = 2185
                        self.match(sqlParser.ESCAPED)
                        self.state = 2186
                        self.match(sqlParser.BY)
                        self.state = 2187
                        localctx.escapedBy = self.match(sqlParser.STRING)




                self.state = 2197
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,276,self._ctx)
                if la_ == 1:
                    self.state = 2192
                    self.match(sqlParser.COLLECTION)
                    self.state = 2193
                    self.match(sqlParser.ITEMS)
                    self.state = 2194
                    self.match(sqlParser.TERMINATED)
                    self.state = 2195
                    self.match(sqlParser.BY)
                    self.state = 2196
                    localctx.collectionItemsTerminatedBy = self.match(sqlParser.STRING)


                self.state = 2204
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,277,self._ctx)
                if la_ == 1:
                    self.state = 2199
                    self.match(sqlParser.MAP)
                    self.state = 2200
                    self.match(sqlParser.KEYS)
                    self.state = 2201
                    self.match(sqlParser.TERMINATED)
                    self.state = 2202
                    self.match(sqlParser.BY)
                    self.state = 2203
                    localctx.keysTerminatedBy = self.match(sqlParser.STRING)


                self.state = 2210
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,278,self._ctx)
                if la_ == 1:
                    self.state = 2206
                    self.match(sqlParser.LINES)
                    self.state = 2207
                    self.match(sqlParser.TERMINATED)
                    self.state = 2208
                    self.match(sqlParser.BY)
                    self.state = 2209
                    localctx.linesSeparatedBy = self.match(sqlParser.STRING)


                self.state = 2216
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,279,self._ctx)
                if la_ == 1:
                    self.state = 2212
                    self.match(sqlParser.NULL)
                    self.state = 2213
                    self.match(sqlParser.DEFINED)
                    self.state = 2214
                    self.match(sqlParser.AS)
                    self.state = 2215
                    localctx.nullDefinedAs = self.match(sqlParser.STRING)


                pass


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


    class MultipartIdentifierListContext(ParserRuleContext):

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

        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_multipartIdentifierList

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




    def multipartIdentifierList(self):

        localctx = sqlParser.MultipartIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_multipartIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2220
            self.multipartIdentifier()
            self.state = 2225
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 2221
                self.match(sqlParser.T__3)
                self.state = 2222
                self.multipartIdentifier()
                self.state = 2227
                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 MultipartIdentifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._errorCapturingIdentifier = None # ErrorCapturingIdentifierContext
            self.parts = list() # of ErrorCapturingIdentifierContexts

        def errorCapturingIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_multipartIdentifier

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




    def multipartIdentifier(self):

        localctx = sqlParser.MultipartIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_multipartIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2228
            localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
            localctx.parts.append(localctx._errorCapturingIdentifier)
            self.state = 2233
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,282,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2229
                    self.match(sqlParser.T__4)
                    self.state = 2230
                    localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
                    localctx.parts.append(localctx._errorCapturingIdentifier) 
                self.state = 2235
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,282,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 TableIdentifierContext(ParserRuleContext):

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

        def errorCapturingIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_tableIdentifier

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




    def tableIdentifier(self):

        localctx = sqlParser.TableIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_tableIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2239
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,283,self._ctx)
            if la_ == 1:
                self.state = 2236
                localctx.db = self.errorCapturingIdentifier()
                self.state = 2237
                self.match(sqlParser.T__4)


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


    class FunctionIdentifierContext(ParserRuleContext):

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

        def errorCapturingIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_functionIdentifier

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




    def functionIdentifier(self):

        localctx = sqlParser.FunctionIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_functionIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2246
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,284,self._ctx)
            if la_ == 1:
                self.state = 2243
                localctx.db = self.errorCapturingIdentifier()
                self.state = 2244
                self.match(sqlParser.T__4)


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


    class NamedExpressionContext(ParserRuleContext):

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

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


        def identifierList(self):
            return self.getTypedRuleContext(sqlParser.IdentifierListContext,0)


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

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_namedExpression

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




    def namedExpression(self):

        localctx = sqlParser.NamedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_namedExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2250
            self.expression()
            self.state = 2258
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,287,self._ctx)
            if la_ == 1:
                self.state = 2252
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,285,self._ctx)
                if la_ == 1:
                    self.state = 2251
                    self.match(sqlParser.AS)


                self.state = 2256
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,286,self._ctx)
                if la_ == 1:
                    self.state = 2254
                    localctx.name = self.errorCapturingIdentifier()
                    pass

                elif la_ == 2:
                    self.state = 2255
                    self.identifierList()
                    pass




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


    class NamedExpressionSeqContext(ParserRuleContext):

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

        def namedExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.NamedExpressionContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_namedExpressionSeq

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




    def namedExpressionSeq(self):

        localctx = sqlParser.NamedExpressionSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_namedExpressionSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2260
            self.namedExpression()
            self.state = 2265
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,288,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2261
                    self.match(sqlParser.T__3)
                    self.state = 2262
                    self.namedExpression() 
                self.state = 2267
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,288,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 TransformListContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._transform = None # TransformContext
            self.transforms = list() # of TransformContexts

        def transform(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TransformContext)
            else:
                return self.getTypedRuleContext(sqlParser.TransformContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_transformList

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




    def transformList(self):

        localctx = sqlParser.TransformListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_transformList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2268
            self.match(sqlParser.T__1)
            self.state = 2269
            localctx._transform = self.transform()
            localctx.transforms.append(localctx._transform)
            self.state = 2274
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 2270
                self.match(sqlParser.T__3)
                self.state = 2271
                localctx._transform = self.transform()
                localctx.transforms.append(localctx._transform)
                self.state = 2276
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2277
            self.match(sqlParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TransformContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_transform

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



    class IdentityTransformContext(TransformContext):

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

        def qualifiedName(self):
            return self.getTypedRuleContext(sqlParser.QualifiedNameContext,0)


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


    class ApplyTransformContext(TransformContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.TransformContext
            super().__init__(parser)
            self.transformName = None # IdentifierContext
            self._transformArgument = None # TransformArgumentContext
            self.argument = list() # of TransformArgumentContexts
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)

        def transformArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.TransformArgumentContext)
            else:
                return self.getTypedRuleContext(sqlParser.TransformArgumentContext,i)


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



    def transform(self):

        localctx = sqlParser.TransformContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_transform)
        self._la = 0 # Token type
        try:
            self.state = 2292
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,291,self._ctx)
            if la_ == 1:
                localctx = sqlParser.IdentityTransformContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2279
                self.qualifiedName()
                pass

            elif la_ == 2:
                localctx = sqlParser.ApplyTransformContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2280
                localctx.transformName = self.identifier()
                self.state = 2281
                self.match(sqlParser.T__1)
                self.state = 2282
                localctx._transformArgument = self.transformArgument()
                localctx.argument.append(localctx._transformArgument)
                self.state = 2287
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 2283
                    self.match(sqlParser.T__3)
                    self.state = 2284
                    localctx._transformArgument = self.transformArgument()
                    localctx.argument.append(localctx._transformArgument)
                    self.state = 2289
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2290
                self.match(sqlParser.T__2)
                pass


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


    class TransformArgumentContext(ParserRuleContext):

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

        def qualifiedName(self):
            return self.getTypedRuleContext(sqlParser.QualifiedNameContext,0)


        def constant(self):
            return self.getTypedRuleContext(sqlParser.ConstantContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_transformArgument

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




    def transformArgument(self):

        localctx = sqlParser.TransformArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_transformArgument)
        try:
            self.state = 2296
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,292,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2294
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2295
                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 ExpressionContext(ParserRuleContext):

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

        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_expression

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




    def expression(self):

        localctx = sqlParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2298
            self.booleanExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanExpressionContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_booleanExpression

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


    class LogicalNotContext(BooleanExpressionContext):

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

        def NOT(self):
            return self.getToken(sqlParser.NOT, 0)
        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)


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


    class PredicatedContext(BooleanExpressionContext):

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

        def valueExpression(self):
            return self.getTypedRuleContext(sqlParser.ValueExpressionContext,0)

        def predicate(self):
            return self.getTypedRuleContext(sqlParser.PredicateContext,0)


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


    class ExistsContext(BooleanExpressionContext):

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

        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)
        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)


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


    class LogicalBinaryContext(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.BooleanExpressionContext
            super().__init__(parser)
            self.left = None # BooleanExpressionContext
            self.operator = None # Token
            self.right = None # BooleanExpressionContext
            self.copyFrom(ctx)

        def booleanExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.BooleanExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,i)

        def AND(self):
            return self.getToken(sqlParser.AND, 0)
        def OR(self):
            return self.getToken(sqlParser.OR, 0)

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



    def booleanExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = sqlParser.BooleanExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 188
        self.enterRecursionRule(localctx, 188, self.RULE_booleanExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2312
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,294,self._ctx)
            if la_ == 1:
                localctx = sqlParser.LogicalNotContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2301
                self.match(sqlParser.NOT)
                self.state = 2302
                self.booleanExpression(5)
                pass

            elif la_ == 2:
                localctx = sqlParser.ExistsContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2303
                self.match(sqlParser.EXISTS)
                self.state = 2304
                self.match(sqlParser.T__1)
                self.state = 2305
                self.query()
                self.state = 2306
                self.match(sqlParser.T__2)
                pass

            elif la_ == 3:
                localctx = sqlParser.PredicatedContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2308
                self.valueExpression(0)
                self.state = 2310
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,293,self._ctx)
                if la_ == 1:
                    self.state = 2309
                    self.predicate()


                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 2322
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,296,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 = 2320
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,295,self._ctx)
                    if la_ == 1:
                        localctx = sqlParser.LogicalBinaryContext(self, sqlParser.BooleanExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpression)
                        self.state = 2314
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 2315
                        localctx.operator = self.match(sqlParser.AND)
                        self.state = 2316
                        localctx.right = self.booleanExpression(3)
                        pass

                    elif la_ == 2:
                        localctx = sqlParser.LogicalBinaryContext(self, sqlParser.BooleanExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpression)
                        self.state = 2317
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 2318
                        localctx.operator = self.match(sqlParser.OR)
                        self.state = 2319
                        localctx.right = self.booleanExpression(2)
                        pass

             
                self.state = 2324
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,296,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
            self.kind = None # Token
            self.lower = None # ValueExpressionContext
            self.upper = None # ValueExpressionContext
            self.pattern = None # ValueExpressionContext
            self.quantifier = None # Token
            self.escapeChar = None # Token
            self.right = None # ValueExpressionContext

        def AND(self):
            return self.getToken(sqlParser.AND, 0)

        def BETWEEN(self):
            return self.getToken(sqlParser.BETWEEN, 0)

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ValueExpressionContext,i)


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

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


        def IN(self):
            return self.getToken(sqlParser.IN, 0)

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)


        def RLIKE(self):
            return self.getToken(sqlParser.RLIKE, 0)

        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)

        def ANY(self):
            return self.getToken(sqlParser.ANY, 0)

        def SOME(self):
            return self.getToken(sqlParser.SOME, 0)

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

        def ESCAPE(self):
            return self.getToken(sqlParser.ESCAPE, 0)

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

        def IS(self):
            return self.getToken(sqlParser.IS, 0)

        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

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

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

        def UNKNOWN(self):
            return self.getToken(sqlParser.UNKNOWN, 0)

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

        def DISTINCT(self):
            return self.getToken(sqlParser.DISTINCT, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_predicate

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




    def predicate(self):

        localctx = sqlParser.PredicateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_predicate)
        self._la = 0 # Token type
        try:
            self.state = 2407
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,310,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2326
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2325
                    self.match(sqlParser.NOT)


                self.state = 2328
                localctx.kind = self.match(sqlParser.BETWEEN)
                self.state = 2329
                localctx.lower = self.valueExpression(0)
                self.state = 2330
                self.match(sqlParser.AND)
                self.state = 2331
                localctx.upper = self.valueExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2334
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2333
                    self.match(sqlParser.NOT)


                self.state = 2336
                localctx.kind = self.match(sqlParser.IN)
                self.state = 2337
                self.match(sqlParser.T__1)
                self.state = 2338
                self.expression()
                self.state = 2343
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==sqlParser.T__3:
                    self.state = 2339
                    self.match(sqlParser.T__3)
                    self.state = 2340
                    self.expression()
                    self.state = 2345
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2346
                self.match(sqlParser.T__2)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2349
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2348
                    self.match(sqlParser.NOT)


                self.state = 2351
                localctx.kind = self.match(sqlParser.IN)
                self.state = 2352
                self.match(sqlParser.T__1)
                self.state = 2353
                self.query()
                self.state = 2354
                self.match(sqlParser.T__2)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2356
                    self.match(sqlParser.NOT)


                self.state = 2359
                localctx.kind = self.match(sqlParser.RLIKE)
                self.state = 2360
                localctx.pattern = self.valueExpression(0)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2362
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2361
                    self.match(sqlParser.NOT)


                self.state = 2364
                localctx.kind = self.match(sqlParser.LIKE)
                self.state = 2365
                localctx.quantifier = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.ALL or _la==sqlParser.ANY or _la==sqlParser.SOME):
                    localctx.quantifier = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2379
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,304,self._ctx)
                if la_ == 1:
                    self.state = 2366
                    self.match(sqlParser.T__1)
                    self.state = 2367
                    self.match(sqlParser.T__2)
                    pass

                elif la_ == 2:
                    self.state = 2368
                    self.match(sqlParser.T__1)
                    self.state = 2369
                    self.expression()
                    self.state = 2374
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==sqlParser.T__3:
                        self.state = 2370
                        self.match(sqlParser.T__3)
                        self.state = 2371
                        self.expression()
                        self.state = 2376
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2377
                    self.match(sqlParser.T__2)
                    pass


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2382
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2381
                    self.match(sqlParser.NOT)


                self.state = 2384
                localctx.kind = self.match(sqlParser.LIKE)
                self.state = 2385
                localctx.pattern = self.valueExpression(0)
                self.state = 2388
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,306,self._ctx)
                if la_ == 1:
                    self.state = 2386
                    self.match(sqlParser.ESCAPE)
                    self.state = 2387
                    localctx.escapeChar = self.match(sqlParser.STRING)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2390
                self.match(sqlParser.IS)
                self.state = 2392
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2391
                    self.match(sqlParser.NOT)


                self.state = 2394
                localctx.kind = self.match(sqlParser.NULL)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2395
                self.match(sqlParser.IS)
                self.state = 2397
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2396
                    self.match(sqlParser.NOT)


                self.state = 2399
                localctx.kind = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.FALSE or _la==sqlParser.TRUE or _la==sqlParser.UNKNOWN):
                    localctx.kind = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 2400
                self.match(sqlParser.IS)
                self.state = 2402
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.NOT:
                    self.state = 2401
                    self.match(sqlParser.NOT)


                self.state = 2404
                localctx.kind = self.match(sqlParser.DISTINCT)
                self.state = 2405
                self.match(sqlParser.FROM)
                self.state = 2406
                localctx.right = self.valueExpression(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 ValueExpressionContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_valueExpression

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


    class ValueExpressionDefaultContext(ValueExpressionContext):

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

        def primaryExpression(self):
            return self.getTypedRuleContext(sqlParser.PrimaryExpressionContext,0)


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


    class ComparisonContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.left = None # ValueExpressionContext
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

        def comparisonOperator(self):
            return self.getTypedRuleContext(sqlParser.ComparisonOperatorContext,0)

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ValueExpressionContext,i)


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


    class ArithmeticBinaryContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.left = None # ValueExpressionContext
            self.operator = None # Token
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ValueExpressionContext,i)

        def ASTERISK(self):
            return self.getToken(sqlParser.ASTERISK, 0)
        def SLASH(self):
            return self.getToken(sqlParser.SLASH, 0)
        def PERCENT(self):
            return self.getToken(sqlParser.PERCENT, 0)
        def DIV(self):
            return self.getToken(sqlParser.DIV, 0)
        def PLUS(self):
            return self.getToken(sqlParser.PLUS, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)
        def CONCAT_PIPE(self):
            return self.getToken(sqlParser.CONCAT_PIPE, 0)
        def AMPERSAND(self):
            return self.getToken(sqlParser.AMPERSAND, 0)
        def HAT(self):
            return self.getToken(sqlParser.HAT, 0)
        def PIPE(self):
            return self.getToken(sqlParser.PIPE, 0)

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


    class ArithmeticUnaryContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.operator = None # Token
            self.copyFrom(ctx)

        def valueExpression(self):
            return self.getTypedRuleContext(sqlParser.ValueExpressionContext,0)

        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)
        def PLUS(self):
            return self.getToken(sqlParser.PLUS, 0)
        def TILDE(self):
            return self.getToken(sqlParser.TILDE, 0)

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



    def valueExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = sqlParser.ValueExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 192
        self.enterRecursionRule(localctx, 192, self.RULE_valueExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2413
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,311,self._ctx)
            if la_ == 1:
                localctx = sqlParser.ValueExpressionDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2410
                self.primaryExpression(0)
                pass

            elif la_ == 2:
                localctx = sqlParser.ArithmeticUnaryContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2411
                localctx.operator = self._input.LT(1)
                _la = self._input.LA(1)
                if not(((((_la - 272)) & ~0x3f) == 0 and ((1 << (_la - 272)) & ((1 << (sqlParser.PLUS - 272)) | (1 << (sqlParser.MINUS - 272)) | (1 << (sqlParser.TILDE - 272)))) != 0)):
                    localctx.operator = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2412
                self.valueExpression(7)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 2436
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,313,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 = 2434
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,312,self._ctx)
                    if la_ == 1:
                        localctx = sqlParser.ArithmeticBinaryContext(self, sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 2415
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 2416
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 274)) & ~0x3f) == 0 and ((1 << (_la - 274)) & ((1 << (sqlParser.ASTERISK - 274)) | (1 << (sqlParser.SLASH - 274)) | (1 << (sqlParser.PERCENT - 274)) | (1 << (sqlParser.DIV - 274)))) != 0)):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2417
                        localctx.right = self.valueExpression(7)
                        pass

                    elif la_ == 2:
                        localctx = sqlParser.ArithmeticBinaryContext(self, sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 2418
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 2419
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 272)) & ~0x3f) == 0 and ((1 << (_la - 272)) & ((1 << (sqlParser.PLUS - 272)) | (1 << (sqlParser.MINUS - 272)) | (1 << (sqlParser.CONCAT_PIPE - 272)))) != 0)):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2420
                        localctx.right = self.valueExpression(6)
                        pass

                    elif la_ == 3:
                        localctx = sqlParser.ArithmeticBinaryContext(self, sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 2421
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 2422
                        localctx.operator = self.match(sqlParser.AMPERSAND)
                        self.state = 2423
                        localctx.right = self.valueExpression(5)
                        pass

                    elif la_ == 4:
                        localctx = sqlParser.ArithmeticBinaryContext(self, sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 2424
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 2425
                        localctx.operator = self.match(sqlParser.HAT)
                        self.state = 2426
                        localctx.right = self.valueExpression(4)
                        pass

                    elif la_ == 5:
                        localctx = sqlParser.ArithmeticBinaryContext(self, sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 2427
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 2428
                        localctx.operator = self.match(sqlParser.PIPE)
                        self.state = 2429
                        localctx.right = self.valueExpression(3)
                        pass

                    elif la_ == 6:
                        localctx = sqlParser.ComparisonContext(self, sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 2430
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 2431
                        self.comparisonOperator()
                        self.state = 2432
                        localctx.right = self.valueExpression(2)
                        pass

             
                self.state = 2438
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,313,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 PrimaryExpressionContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_primaryExpression

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


    class StructContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self._namedExpression = None # NamedExpressionContext
            self.argument = list() # of NamedExpressionContexts
            self.copyFrom(ctx)

        def STRUCT(self):
            return self.getToken(sqlParser.STRUCT, 0)
        def namedExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.NamedExpressionContext,i)


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


    class DereferenceContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.base = None # PrimaryExpressionContext
            self.fieldName = None # IdentifierContext
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(sqlParser.PrimaryExpressionContext,0)

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


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


    class SimpleCaseContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.value = None # ExpressionContext
            self.elseExpression = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(sqlParser.CASE, 0)
        def END(self):
            return self.getToken(sqlParser.END, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ExpressionContext,i)

        def whenClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.WhenClauseContext)
            else:
                return self.getTypedRuleContext(sqlParser.WhenClauseContext,i)

        def ELSE(self):
            return self.getToken(sqlParser.ELSE, 0)

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


    class ColumnReferenceContext(PrimaryExpressionContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


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


    class RowConstructorContext(PrimaryExpressionContext):

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

        def namedExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.NamedExpressionContext,i)


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


    class LastContext(PrimaryExpressionContext):

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

        def LAST(self):
            return self.getToken(sqlParser.LAST, 0)
        def expression(self):
            return self.getTypedRuleContext(sqlParser.ExpressionContext,0)

        def IGNORE(self):
            return self.getToken(sqlParser.IGNORE, 0)
        def NULLS(self):
            return self.getToken(sqlParser.NULLS, 0)

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


    class StarContext(PrimaryExpressionContext):

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

        def ASTERISK(self):
            return self.getToken(sqlParser.ASTERISK, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(sqlParser.QualifiedNameContext,0)


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


    class OverlayContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.qpdinput = None # ValueExpressionContext
            self.replace = None # ValueExpressionContext
            self.position = None # ValueExpressionContext
            self.length = None # ValueExpressionContext
            self.copyFrom(ctx)

        def OVERLAY(self):
            return self.getToken(sqlParser.OVERLAY, 0)
        def PLACING(self):
            return self.getToken(sqlParser.PLACING, 0)
        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ValueExpressionContext,i)

        def FOR(self):
            return self.getToken(sqlParser.FOR, 0)

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


    class SubscriptContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.value = None # PrimaryExpressionContext
            self.index = None # ValueExpressionContext
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(sqlParser.PrimaryExpressionContext,0)

        def valueExpression(self):
            return self.getTypedRuleContext(sqlParser.ValueExpressionContext,0)


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


    class SubqueryExpressionContext(PrimaryExpressionContext):

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

        def query(self):
            return self.getTypedRuleContext(sqlParser.QueryContext,0)


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


    class SubstringContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.qpdstr = None # ValueExpressionContext
            self.pos = None # ValueExpressionContext
            self.qpdlen = None # ValueExpressionContext
            self.copyFrom(ctx)

        def SUBSTR(self):
            return self.getToken(sqlParser.SUBSTR, 0)
        def SUBSTRING(self):
            return self.getToken(sqlParser.SUBSTRING, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ValueExpressionContext,i)

        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def FOR(self):
            return self.getToken(sqlParser.FOR, 0)

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


    class CurrentDatetimeContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def CURRENT_DATE(self):
            return self.getToken(sqlParser.CURRENT_DATE, 0)
        def CURRENT_TIMESTAMP(self):
            return self.getToken(sqlParser.CURRENT_TIMESTAMP, 0)

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


    class CastContext(PrimaryExpressionContext):

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

        def CAST(self):
            return self.getToken(sqlParser.CAST, 0)
        def expression(self):
            return self.getTypedRuleContext(sqlParser.ExpressionContext,0)

        def AS(self):
            return self.getToken(sqlParser.AS, 0)
        def dataType(self):
            return self.getTypedRuleContext(sqlParser.DataTypeContext,0)


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


    class ConstantDefaultContext(PrimaryExpressionContext):

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

        def constant(self):
            return self.getTypedRuleContext(sqlParser.ConstantContext,0)


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


    class LambdaContext(PrimaryExpressionContext):

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierContext,i)

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


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


    class ParenthesizedExpressionContext(PrimaryExpressionContext):

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

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


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


    class ExtractContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.field = None # IdentifierContext
            self.source = None # ValueExpressionContext
            self.copyFrom(ctx)

        def EXTRACT(self):
            return self.getToken(sqlParser.EXTRACT, 0)
        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)

        def valueExpression(self):
            return self.getTypedRuleContext(sqlParser.ValueExpressionContext,0)


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


    class TrimContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.trimOption = None # Token
            self.trimStr = None # ValueExpressionContext
            self.srcStr = None # ValueExpressionContext
            self.copyFrom(ctx)

        def TRIM(self):
            return self.getToken(sqlParser.TRIM, 0)
        def FROM(self):
            return self.getToken(sqlParser.FROM, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ValueExpressionContext,i)

        def BOTH(self):
            return self.getToken(sqlParser.BOTH, 0)
        def LEADING(self):
            return self.getToken(sqlParser.LEADING, 0)
        def TRAILING(self):
            return self.getToken(sqlParser.TRAILING, 0)

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


    class FunctionCallContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self._expression = None # ExpressionContext
            self.argument = list() # of ExpressionContexts
            self.where = None # BooleanExpressionContext
            self.copyFrom(ctx)

        def functionName(self):
            return self.getTypedRuleContext(sqlParser.FunctionNameContext,0)

        def FILTER(self):
            return self.getToken(sqlParser.FILTER, 0)
        def WHERE(self):
            return self.getToken(sqlParser.WHERE, 0)
        def OVER(self):
            return self.getToken(sqlParser.OVER, 0)
        def windowSpec(self):
            return self.getTypedRuleContext(sqlParser.WindowSpecContext,0)

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

        def booleanExpression(self):
            return self.getTypedRuleContext(sqlParser.BooleanExpressionContext,0)

        def setQuantifier(self):
            return self.getTypedRuleContext(sqlParser.SetQuantifierContext,0)


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


    class SearchedCaseContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.elseExpression = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(sqlParser.CASE, 0)
        def END(self):
            return self.getToken(sqlParser.END, 0)
        def whenClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.WhenClauseContext)
            else:
                return self.getTypedRuleContext(sqlParser.WhenClauseContext,i)

        def ELSE(self):
            return self.getToken(sqlParser.ELSE, 0)
        def expression(self):
            return self.getTypedRuleContext(sqlParser.ExpressionContext,0)


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


    class PositionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.substr = None # ValueExpressionContext
            self.qpdstr = None # ValueExpressionContext
            self.copyFrom(ctx)

        def POSITION(self):
            return self.getToken(sqlParser.POSITION, 0)
        def IN(self):
            return self.getToken(sqlParser.IN, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ValueExpressionContext,i)


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


    class FirstContext(PrimaryExpressionContext):

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

        def FIRST(self):
            return self.getToken(sqlParser.FIRST, 0)
        def expression(self):
            return self.getTypedRuleContext(sqlParser.ExpressionContext,0)

        def IGNORE(self):
            return self.getToken(sqlParser.IGNORE, 0)
        def NULLS(self):
            return self.getToken(sqlParser.NULLS, 0)

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



    def primaryExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = sqlParser.PrimaryExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 194
        self.enterRecursionRule(localctx, 194, self.RULE_primaryExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2623
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,333,self._ctx)
            if la_ == 1:
                localctx = sqlParser.CurrentDatetimeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2440
                localctx.name = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.CURRENT_DATE or _la==sqlParser.CURRENT_TIMESTAMP):
                    localctx.name = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                localctx = sqlParser.SearchedCaseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2441
                self.match(sqlParser.CASE)
                self.state = 2443 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2442
                    self.whenClause()
                    self.state = 2445 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==sqlParser.WHEN):
                        break

                self.state = 2449
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.ELSE:
                    self.state = 2447
                    self.match(sqlParser.ELSE)
                    self.state = 2448
                    localctx.elseExpression = self.expression()


                self.state = 2451
                self.match(sqlParser.END)
                pass

            elif la_ == 3:
                localctx = sqlParser.SimpleCaseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2453
                self.match(sqlParser.CASE)
                self.state = 2454
                localctx.value = self.expression()
                self.state = 2456 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2455
                    self.whenClause()
                    self.state = 2458 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==sqlParser.WHEN):
                        break

                self.state = 2462
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.ELSE:
                    self.state = 2460
                    self.match(sqlParser.ELSE)
                    self.state = 2461
                    localctx.elseExpression = self.expression()


                self.state = 2464
                self.match(sqlParser.END)
                pass

            elif la_ == 4:
                localctx = sqlParser.CastContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2466
                self.match(sqlParser.CAST)
                self.state = 2467
                self.match(sqlParser.T__1)
                self.state = 2468
                self.expression()
                self.state = 2469
                self.match(sqlParser.AS)
                self.state = 2470
                self.dataType()
                self.state = 2471
                self.match(sqlParser.T__2)
                pass

            elif la_ == 5:
                localctx = sqlParser.StructContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2473
                self.match(sqlParser.STRUCT)
                self.state = 2474
                self.match(sqlParser.T__1)
                self.state = 2483
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,319,self._ctx)
                if la_ == 1:
                    self.state = 2475
                    localctx._namedExpression = self.namedExpression()
                    localctx.argument.append(localctx._namedExpression)
                    self.state = 2480
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==sqlParser.T__3:
                        self.state = 2476
                        self.match(sqlParser.T__3)
                        self.state = 2477
                        localctx._namedExpression = self.namedExpression()
                        localctx.argument.append(localctx._namedExpression)
                        self.state = 2482
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2485
                self.match(sqlParser.T__2)
                pass

            elif la_ == 6:
                localctx = sqlParser.FirstContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2486
                self.match(sqlParser.FIRST)
                self.state = 2487
                self.match(sqlParser.T__1)
                self.state = 2488
                self.expression()
                self.state = 2491
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.IGNORE:
                    self.state = 2489
                    self.match(sqlParser.IGNORE)
                    self.state = 2490
                    self.match(sqlParser.NULLS)


                self.state = 2493
                self.match(sqlParser.T__2)
                pass

            elif la_ == 7:
                localctx = sqlParser.LastContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2495
                self.match(sqlParser.LAST)
                self.state = 2496
                self.match(sqlParser.T__1)
                self.state = 2497
                self.expression()
                self.state = 2500
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.IGNORE:
                    self.state = 2498
                    self.match(sqlParser.IGNORE)
                    self.state = 2499
                    self.match(sqlParser.NULLS)


                self.state = 2502
                self.match(sqlParser.T__2)
                pass

            elif la_ == 8:
                localctx = sqlParser.PositionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2504
                self.match(sqlParser.POSITION)
                self.state = 2505
                self.match(sqlParser.T__1)
                self.state = 2506
                localctx.substr = self.valueExpression(0)
                self.state = 2507
                self.match(sqlParser.IN)
                self.state = 2508
                localctx.qpdstr = self.valueExpression(0)
                self.state = 2509
                self.match(sqlParser.T__2)
                pass

            elif la_ == 9:
                localctx = sqlParser.ConstantDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2511
                self.constant()
                pass

            elif la_ == 10:
                localctx = sqlParser.StarContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2512
                self.match(sqlParser.ASTERISK)
                pass

            elif la_ == 11:
                localctx = sqlParser.StarContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2513
                self.qualifiedName()
                self.state = 2514
                self.match(sqlParser.T__4)
                self.state = 2515
                self.match(sqlParser.ASTERISK)
                pass

            elif la_ == 12:
                localctx = sqlParser.RowConstructorContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2517
                self.match(sqlParser.T__1)
                self.state = 2518
                self.namedExpression()
                self.state = 2521 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2519
                    self.match(sqlParser.T__3)
                    self.state = 2520
                    self.namedExpression()
                    self.state = 2523 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==sqlParser.T__3):
                        break

                self.state = 2525
                self.match(sqlParser.T__2)
                pass

            elif la_ == 13:
                localctx = sqlParser.SubqueryExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2527
                self.match(sqlParser.T__1)
                self.state = 2528
                self.query()
                self.state = 2529
                self.match(sqlParser.T__2)
                pass

            elif la_ == 14:
                localctx = sqlParser.FunctionCallContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2531
                self.functionName()
                self.state = 2532
                self.match(sqlParser.T__1)
                self.state = 2544
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,325,self._ctx)
                if la_ == 1:
                    self.state = 2534
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,323,self._ctx)
                    if la_ == 1:
                        self.state = 2533
                        self.setQuantifier()


                    self.state = 2536
                    localctx._expression = self.expression()
                    localctx.argument.append(localctx._expression)
                    self.state = 2541
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==sqlParser.T__3:
                        self.state = 2537
                        self.match(sqlParser.T__3)
                        self.state = 2538
                        localctx._expression = self.expression()
                        localctx.argument.append(localctx._expression)
                        self.state = 2543
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2546
                self.match(sqlParser.T__2)
                self.state = 2553
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,326,self._ctx)
                if la_ == 1:
                    self.state = 2547
                    self.match(sqlParser.FILTER)
                    self.state = 2548
                    self.match(sqlParser.T__1)
                    self.state = 2549
                    self.match(sqlParser.WHERE)
                    self.state = 2550
                    localctx.where = self.booleanExpression(0)
                    self.state = 2551
                    self.match(sqlParser.T__2)


                self.state = 2557
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,327,self._ctx)
                if la_ == 1:
                    self.state = 2555
                    self.match(sqlParser.OVER)
                    self.state = 2556
                    self.windowSpec()


                pass

            elif la_ == 15:
                localctx = sqlParser.LambdaContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2559
                self.identifier()
                self.state = 2560
                self.match(sqlParser.T__7)
                self.state = 2561
                self.expression()
                pass

            elif la_ == 16:
                localctx = sqlParser.LambdaContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2563
                self.match(sqlParser.T__1)
                self.state = 2564
                self.identifier()
                self.state = 2567 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2565
                    self.match(sqlParser.T__3)
                    self.state = 2566
                    self.identifier()
                    self.state = 2569 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==sqlParser.T__3):
                        break

                self.state = 2571
                self.match(sqlParser.T__2)
                self.state = 2572
                self.match(sqlParser.T__7)
                self.state = 2573
                self.expression()
                pass

            elif la_ == 17:
                localctx = sqlParser.ColumnReferenceContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2575
                self.identifier()
                pass

            elif la_ == 18:
                localctx = sqlParser.ParenthesizedExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2576
                self.match(sqlParser.T__1)
                self.state = 2577
                self.expression()
                self.state = 2578
                self.match(sqlParser.T__2)
                pass

            elif la_ == 19:
                localctx = sqlParser.ExtractContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2580
                self.match(sqlParser.EXTRACT)
                self.state = 2581
                self.match(sqlParser.T__1)
                self.state = 2582
                localctx.field = self.identifier()
                self.state = 2583
                self.match(sqlParser.FROM)
                self.state = 2584
                localctx.source = self.valueExpression(0)
                self.state = 2585
                self.match(sqlParser.T__2)
                pass

            elif la_ == 20:
                localctx = sqlParser.SubstringContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2587
                _la = self._input.LA(1)
                if not(_la==sqlParser.SUBSTR or _la==sqlParser.SUBSTRING):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2588
                self.match(sqlParser.T__1)
                self.state = 2589
                localctx.qpdstr = self.valueExpression(0)
                self.state = 2590
                _la = self._input.LA(1)
                if not(_la==sqlParser.T__3 or _la==sqlParser.FROM):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2591
                localctx.pos = self.valueExpression(0)
                self.state = 2594
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.T__3 or _la==sqlParser.FOR:
                    self.state = 2592
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.T__3 or _la==sqlParser.FOR):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2593
                    localctx.qpdlen = self.valueExpression(0)


                self.state = 2596
                self.match(sqlParser.T__2)
                pass

            elif la_ == 21:
                localctx = sqlParser.TrimContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2598
                self.match(sqlParser.TRIM)
                self.state = 2599
                self.match(sqlParser.T__1)
                self.state = 2601
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,330,self._ctx)
                if la_ == 1:
                    self.state = 2600
                    localctx.trimOption = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.BOTH or _la==sqlParser.LEADING or _la==sqlParser.TRAILING):
                        localctx.trimOption = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 2604
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,331,self._ctx)
                if la_ == 1:
                    self.state = 2603
                    localctx.trimStr = self.valueExpression(0)


                self.state = 2606
                self.match(sqlParser.FROM)
                self.state = 2607
                localctx.srcStr = self.valueExpression(0)
                self.state = 2608
                self.match(sqlParser.T__2)
                pass

            elif la_ == 22:
                localctx = sqlParser.OverlayContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2610
                self.match(sqlParser.OVERLAY)
                self.state = 2611
                self.match(sqlParser.T__1)
                self.state = 2612
                localctx.qpdinput = self.valueExpression(0)
                self.state = 2613
                self.match(sqlParser.PLACING)
                self.state = 2614
                localctx.replace = self.valueExpression(0)
                self.state = 2615
                self.match(sqlParser.FROM)
                self.state = 2616
                localctx.position = self.valueExpression(0)
                self.state = 2619
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.FOR:
                    self.state = 2617
                    self.match(sqlParser.FOR)
                    self.state = 2618
                    localctx.length = self.valueExpression(0)


                self.state = 2621
                self.match(sqlParser.T__2)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 2635
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,335,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 = 2633
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,334,self._ctx)
                    if la_ == 1:
                        localctx = sqlParser.SubscriptContext(self, sqlParser.PrimaryExpressionContext(self, _parentctx, _parentState))
                        localctx.value = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_primaryExpression)
                        self.state = 2625
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 2626
                        self.match(sqlParser.T__8)
                        self.state = 2627
                        localctx.index = self.valueExpression(0)
                        self.state = 2628
                        self.match(sqlParser.T__9)
                        pass

                    elif la_ == 2:
                        localctx = sqlParser.DereferenceContext(self, sqlParser.PrimaryExpressionContext(self, _parentctx, _parentState))
                        localctx.base = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_primaryExpression)
                        self.state = 2630
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 2631
                        self.match(sqlParser.T__4)
                        self.state = 2632
                        localctx.fieldName = self.identifier()
                        pass

             
                self.state = 2637
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,335,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 ConstantContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_constant

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



    class NullLiteralContext(ConstantContext):

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

        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

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


    class StringLiteralContext(ConstantContext):

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

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

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


    class TypeConstructorContext(ConstantContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)

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

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


    class IntervalLiteralContext(ConstantContext):

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

        def interval(self):
            return self.getTypedRuleContext(sqlParser.IntervalContext,0)


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


    class NumericLiteralContext(ConstantContext):

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

        def number(self):
            return self.getTypedRuleContext(sqlParser.NumberContext,0)


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


    class BooleanLiteralContext(ConstantContext):

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

        def booleanValue(self):
            return self.getTypedRuleContext(sqlParser.BooleanValueContext,0)


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



    def constant(self):

        localctx = sqlParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_constant)
        try:
            self.state = 2650
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,337,self._ctx)
            if la_ == 1:
                localctx = sqlParser.NullLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2638
                self.match(sqlParser.NULL)
                pass

            elif la_ == 2:
                localctx = sqlParser.IntervalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2639
                self.interval()
                pass

            elif la_ == 3:
                localctx = sqlParser.TypeConstructorContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2640
                self.identifier()
                self.state = 2641
                self.match(sqlParser.STRING)
                pass

            elif la_ == 4:
                localctx = sqlParser.NumericLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2643
                self.number()
                pass

            elif la_ == 5:
                localctx = sqlParser.BooleanLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2644
                self.booleanValue()
                pass

            elif la_ == 6:
                localctx = sqlParser.StringLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 2646 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 2645
                        self.match(sqlParser.STRING)

                    else:
                        raise NoViableAltException(self)
                    self.state = 2648 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,336,self._ctx)

                pass


        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 EQ(self):
            return self.getToken(sqlParser.EQ, 0)

        def NEQ(self):
            return self.getToken(sqlParser.NEQ, 0)

        def NEQJ(self):
            return self.getToken(sqlParser.NEQJ, 0)

        def LT(self):
            return self.getToken(sqlParser.LT, 0)

        def LTE(self):
            return self.getToken(sqlParser.LTE, 0)

        def GT(self):
            return self.getToken(sqlParser.GT, 0)

        def GTE(self):
            return self.getToken(sqlParser.GTE, 0)

        def NSEQ(self):
            return self.getToken(sqlParser.NSEQ, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_comparisonOperator

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




    def comparisonOperator(self):

        localctx = sqlParser.ComparisonOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_comparisonOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2652
            _la = self._input.LA(1)
            if not(((((_la - 264)) & ~0x3f) == 0 and ((1 << (_la - 264)) & ((1 << (sqlParser.EQ - 264)) | (1 << (sqlParser.NSEQ - 264)) | (1 << (sqlParser.NEQ - 264)) | (1 << (sqlParser.NEQJ - 264)) | (1 << (sqlParser.LT - 264)) | (1 << (sqlParser.LTE - 264)) | (1 << (sqlParser.GT - 264)) | (1 << (sqlParser.GTE - 264)))) != 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 ArithmeticOperatorContext(ParserRuleContext):

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

        def PLUS(self):
            return self.getToken(sqlParser.PLUS, 0)

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

        def ASTERISK(self):
            return self.getToken(sqlParser.ASTERISK, 0)

        def SLASH(self):
            return self.getToken(sqlParser.SLASH, 0)

        def PERCENT(self):
            return self.getToken(sqlParser.PERCENT, 0)

        def DIV(self):
            return self.getToken(sqlParser.DIV, 0)

        def TILDE(self):
            return self.getToken(sqlParser.TILDE, 0)

        def AMPERSAND(self):
            return self.getToken(sqlParser.AMPERSAND, 0)

        def PIPE(self):
            return self.getToken(sqlParser.PIPE, 0)

        def CONCAT_PIPE(self):
            return self.getToken(sqlParser.CONCAT_PIPE, 0)

        def HAT(self):
            return self.getToken(sqlParser.HAT, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_arithmeticOperator

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




    def arithmeticOperator(self):

        localctx = sqlParser.ArithmeticOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_arithmeticOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2654
            _la = self._input.LA(1)
            if not(((((_la - 272)) & ~0x3f) == 0 and ((1 << (_la - 272)) & ((1 << (sqlParser.PLUS - 272)) | (1 << (sqlParser.MINUS - 272)) | (1 << (sqlParser.ASTERISK - 272)) | (1 << (sqlParser.SLASH - 272)) | (1 << (sqlParser.PERCENT - 272)) | (1 << (sqlParser.DIV - 272)) | (1 << (sqlParser.TILDE - 272)) | (1 << (sqlParser.AMPERSAND - 272)) | (1 << (sqlParser.PIPE - 272)) | (1 << (sqlParser.CONCAT_PIPE - 272)) | (1 << (sqlParser.HAT - 272)))) != 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 PredicateOperatorContext(ParserRuleContext):

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

        def OR(self):
            return self.getToken(sqlParser.OR, 0)

        def AND(self):
            return self.getToken(sqlParser.AND, 0)

        def IN(self):
            return self.getToken(sqlParser.IN, 0)

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

        def getRuleIndex(self):
            return sqlParser.RULE_predicateOperator

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




    def predicateOperator(self):

        localctx = sqlParser.PredicateOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_predicateOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2656
            _la = self._input.LA(1)
            if not(_la==sqlParser.AND or ((((_la - 113)) & ~0x3f) == 0 and ((1 << (_la - 113)) & ((1 << (sqlParser.IN - 113)) | (1 << (sqlParser.NOT - 113)) | (1 << (sqlParser.OR - 113)))) != 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 BooleanValueContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return sqlParser.RULE_booleanValue

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




    def booleanValue(self):

        localctx = sqlParser.BooleanValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_booleanValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2658
            _la = self._input.LA(1)
            if not(_la==sqlParser.FALSE or _la==sqlParser.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 IntervalContext(ParserRuleContext):

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

        def INTERVAL(self):
            return self.getToken(sqlParser.INTERVAL, 0)

        def errorCapturingMultiUnitsInterval(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingMultiUnitsIntervalContext,0)


        def errorCapturingUnitToUnitInterval(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingUnitToUnitIntervalContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_interval

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




    def interval(self):

        localctx = sqlParser.IntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_interval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2660
            self.match(sqlParser.INTERVAL)
            self.state = 2663
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,338,self._ctx)
            if la_ == 1:
                self.state = 2661
                self.errorCapturingMultiUnitsInterval()

            elif la_ == 2:
                self.state = 2662
                self.errorCapturingUnitToUnitInterval()


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


    class ErrorCapturingMultiUnitsIntervalContext(ParserRuleContext):

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

        def multiUnitsInterval(self):
            return self.getTypedRuleContext(sqlParser.MultiUnitsIntervalContext,0)


        def unitToUnitInterval(self):
            return self.getTypedRuleContext(sqlParser.UnitToUnitIntervalContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_errorCapturingMultiUnitsInterval

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




    def errorCapturingMultiUnitsInterval(self):

        localctx = sqlParser.ErrorCapturingMultiUnitsIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_errorCapturingMultiUnitsInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2665
            self.multiUnitsInterval()
            self.state = 2667
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,339,self._ctx)
            if la_ == 1:
                self.state = 2666
                self.unitToUnitInterval()


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


    class MultiUnitsIntervalContext(ParserRuleContext):

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

        def intervalValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IntervalValueContext)
            else:
                return self.getTypedRuleContext(sqlParser.IntervalValueContext,i)


        def intervalUnit(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IntervalUnitContext)
            else:
                return self.getTypedRuleContext(sqlParser.IntervalUnitContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_multiUnitsInterval

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




    def multiUnitsInterval(self):

        localctx = sqlParser.MultiUnitsIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_multiUnitsInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2672 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2669
                    self.intervalValue()
                    self.state = 2670
                    self.intervalUnit()

                else:
                    raise NoViableAltException(self)
                self.state = 2674 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,340,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 ErrorCapturingUnitToUnitIntervalContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.body = None # UnitToUnitIntervalContext
            self.error1 = None # MultiUnitsIntervalContext
            self.error2 = None # UnitToUnitIntervalContext

        def unitToUnitInterval(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.UnitToUnitIntervalContext)
            else:
                return self.getTypedRuleContext(sqlParser.UnitToUnitIntervalContext,i)


        def multiUnitsInterval(self):
            return self.getTypedRuleContext(sqlParser.MultiUnitsIntervalContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_errorCapturingUnitToUnitInterval

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




    def errorCapturingUnitToUnitInterval(self):

        localctx = sqlParser.ErrorCapturingUnitToUnitIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_errorCapturingUnitToUnitInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2676
            localctx.body = self.unitToUnitInterval()
            self.state = 2679
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,341,self._ctx)
            if la_ == 1:
                self.state = 2677
                localctx.error1 = self.multiUnitsInterval()

            elif la_ == 2:
                self.state = 2678
                localctx.error2 = self.unitToUnitInterval()


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


    class UnitToUnitIntervalContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.value = None # IntervalValueContext
            self.qpdfrom = None # IntervalUnitContext
            self.to = None # IntervalUnitContext

        def TO(self):
            return self.getToken(sqlParser.TO, 0)

        def intervalValue(self):
            return self.getTypedRuleContext(sqlParser.IntervalValueContext,0)


        def intervalUnit(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IntervalUnitContext)
            else:
                return self.getTypedRuleContext(sqlParser.IntervalUnitContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_unitToUnitInterval

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




    def unitToUnitInterval(self):

        localctx = sqlParser.UnitToUnitIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_unitToUnitInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2681
            localctx.value = self.intervalValue()
            self.state = 2682
            localctx.qpdfrom = self.intervalUnit()
            self.state = 2683
            self.match(sqlParser.TO)
            self.state = 2684
            localctx.to = self.intervalUnit()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntervalValueContext(ParserRuleContext):

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

        def INTEGER_VALUE(self):
            return self.getToken(sqlParser.INTEGER_VALUE, 0)

        def DECIMAL_VALUE(self):
            return self.getToken(sqlParser.DECIMAL_VALUE, 0)

        def PLUS(self):
            return self.getToken(sqlParser.PLUS, 0)

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

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

        def getRuleIndex(self):
            return sqlParser.RULE_intervalValue

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




    def intervalValue(self):

        localctx = sqlParser.IntervalValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_intervalValue)
        self._la = 0 # Token type
        try:
            self.state = 2691
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.PLUS, sqlParser.MINUS, sqlParser.INTEGER_VALUE, sqlParser.DECIMAL_VALUE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2687
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.PLUS or _la==sqlParser.MINUS:
                    self.state = 2686
                    _la = self._input.LA(1)
                    if not(_la==sqlParser.PLUS or _la==sqlParser.MINUS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 2689
                _la = self._input.LA(1)
                if not(_la==sqlParser.INTEGER_VALUE or _la==sqlParser.DECIMAL_VALUE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [sqlParser.STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2690
                self.match(sqlParser.STRING)
                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 IntervalUnitContext(ParserRuleContext):

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

        def DAY(self):
            return self.getToken(sqlParser.DAY, 0)

        def HOUR(self):
            return self.getToken(sqlParser.HOUR, 0)

        def MINUTE(self):
            return self.getToken(sqlParser.MINUTE, 0)

        def MONTH(self):
            return self.getToken(sqlParser.MONTH, 0)

        def SECOND(self):
            return self.getToken(sqlParser.SECOND, 0)

        def YEAR(self):
            return self.getToken(sqlParser.YEAR, 0)

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_intervalUnit

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




    def intervalUnit(self):

        localctx = sqlParser.IntervalUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_intervalUnit)
        try:
            self.state = 2700
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,344,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2693
                self.match(sqlParser.DAY)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2694
                self.match(sqlParser.HOUR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2695
                self.match(sqlParser.MINUTE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2696
                self.match(sqlParser.MONTH)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2697
                self.match(sqlParser.SECOND)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2698
                self.match(sqlParser.YEAR)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2699
                self.identifier()
                pass


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


    class ColPositionContext(ParserRuleContext):

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

        def FIRST(self):
            return self.getToken(sqlParser.FIRST, 0)

        def AFTER(self):
            return self.getToken(sqlParser.AFTER, 0)

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_colPosition

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




    def colPosition(self):

        localctx = sqlParser.ColPositionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_colPosition)
        try:
            self.state = 2705
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.FIRST]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2702
                localctx.position = self.match(sqlParser.FIRST)
                pass
            elif token in [sqlParser.AFTER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2703
                localctx.position = self.match(sqlParser.AFTER)
                self.state = 2704
                localctx.afterCol = self.errorCapturingIdentifier()
                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 DataTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_dataType

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



    class ComplexDataTypeContext(DataTypeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.DataTypeContext
            super().__init__(parser)
            self.qpdcomplex = None # Token
            self.copyFrom(ctx)

        def LT(self):
            return self.getToken(sqlParser.LT, 0)
        def dataType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.DataTypeContext)
            else:
                return self.getTypedRuleContext(sqlParser.DataTypeContext,i)

        def GT(self):
            return self.getToken(sqlParser.GT, 0)
        def ARRAY(self):
            return self.getToken(sqlParser.ARRAY, 0)
        def MAP(self):
            return self.getToken(sqlParser.MAP, 0)
        def STRUCT(self):
            return self.getToken(sqlParser.STRUCT, 0)
        def NEQ(self):
            return self.getToken(sqlParser.NEQ, 0)
        def complexColTypeList(self):
            return self.getTypedRuleContext(sqlParser.ComplexColTypeListContext,0)


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


    class PrimitiveDataTypeContext(DataTypeContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)

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

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



    def dataType(self):

        localctx = sqlParser.DataTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_dataType)
        self._la = 0 # Token type
        try:
            self.state = 2741
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,350,self._ctx)
            if la_ == 1:
                localctx = sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2707
                localctx.qpdcomplex = self.match(sqlParser.ARRAY)
                self.state = 2708
                self.match(sqlParser.LT)
                self.state = 2709
                self.dataType()
                self.state = 2710
                self.match(sqlParser.GT)
                pass

            elif la_ == 2:
                localctx = sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2712
                localctx.qpdcomplex = self.match(sqlParser.MAP)
                self.state = 2713
                self.match(sqlParser.LT)
                self.state = 2714
                self.dataType()
                self.state = 2715
                self.match(sqlParser.T__3)
                self.state = 2716
                self.dataType()
                self.state = 2717
                self.match(sqlParser.GT)
                pass

            elif la_ == 3:
                localctx = sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2719
                localctx.qpdcomplex = self.match(sqlParser.STRUCT)
                self.state = 2726
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [sqlParser.LT]:
                    self.state = 2720
                    self.match(sqlParser.LT)
                    self.state = 2722
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,346,self._ctx)
                    if la_ == 1:
                        self.state = 2721
                        self.complexColTypeList()


                    self.state = 2724
                    self.match(sqlParser.GT)
                    pass
                elif token in [sqlParser.NEQ]:
                    self.state = 2725
                    self.match(sqlParser.NEQ)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 4:
                localctx = sqlParser.PrimitiveDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2728
                self.identifier()
                self.state = 2739
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,349,self._ctx)
                if la_ == 1:
                    self.state = 2729
                    self.match(sqlParser.T__1)
                    self.state = 2730
                    self.match(sqlParser.INTEGER_VALUE)
                    self.state = 2735
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==sqlParser.T__3:
                        self.state = 2731
                        self.match(sqlParser.T__3)
                        self.state = 2732
                        self.match(sqlParser.INTEGER_VALUE)
                        self.state = 2737
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2738
                    self.match(sqlParser.T__2)


                pass


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


    class QualifiedColTypeWithPositionListContext(ParserRuleContext):

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

        def qualifiedColTypeWithPosition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.QualifiedColTypeWithPositionContext)
            else:
                return self.getTypedRuleContext(sqlParser.QualifiedColTypeWithPositionContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_qualifiedColTypeWithPositionList

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




    def qualifiedColTypeWithPositionList(self):

        localctx = sqlParser.QualifiedColTypeWithPositionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_qualifiedColTypeWithPositionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2743
            self.qualifiedColTypeWithPosition()
            self.state = 2748
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 2744
                self.match(sqlParser.T__3)
                self.state = 2745
                self.qualifiedColTypeWithPosition()
                self.state = 2750
                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 QualifiedColTypeWithPositionContext(ParserRuleContext):

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

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


        def multipartIdentifier(self):
            return self.getTypedRuleContext(sqlParser.MultipartIdentifierContext,0)


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

        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(sqlParser.CommentSpecContext,0)


        def colPosition(self):
            return self.getTypedRuleContext(sqlParser.ColPositionContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_qualifiedColTypeWithPosition

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




    def qualifiedColTypeWithPosition(self):

        localctx = sqlParser.QualifiedColTypeWithPositionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_qualifiedColTypeWithPosition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2751
            localctx.name = self.multipartIdentifier()
            self.state = 2752
            self.dataType()
            self.state = 2755
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.NOT:
                self.state = 2753
                self.match(sqlParser.NOT)
                self.state = 2754
                self.match(sqlParser.NULL)


            self.state = 2758
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.COMMENT:
                self.state = 2757
                self.commentSpec()


            self.state = 2761
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.AFTER or _la==sqlParser.FIRST:
                self.state = 2760
                self.colPosition()


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


    class ColTypeListContext(ParserRuleContext):

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

        def colType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ColTypeContext)
            else:
                return self.getTypedRuleContext(sqlParser.ColTypeContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_colTypeList

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




    def colTypeList(self):

        localctx = sqlParser.ColTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_colTypeList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2763
            self.colType()
            self.state = 2768
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,355,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2764
                    self.match(sqlParser.T__3)
                    self.state = 2765
                    self.colType() 
                self.state = 2770
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,355,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 ColTypeContext(ParserRuleContext):

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

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


        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


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

        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_colType

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




    def colType(self):

        localctx = sqlParser.ColTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_colType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2771
            localctx.colName = self.errorCapturingIdentifier()
            self.state = 2772
            self.dataType()
            self.state = 2775
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,356,self._ctx)
            if la_ == 1:
                self.state = 2773
                self.match(sqlParser.NOT)
                self.state = 2774
                self.match(sqlParser.NULL)


            self.state = 2778
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,357,self._ctx)
            if la_ == 1:
                self.state = 2777
                self.commentSpec()


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


    class ComplexColTypeListContext(ParserRuleContext):

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

        def complexColType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ComplexColTypeContext)
            else:
                return self.getTypedRuleContext(sqlParser.ComplexColTypeContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_complexColTypeList

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




    def complexColTypeList(self):

        localctx = sqlParser.ComplexColTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_complexColTypeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2780
            self.complexColType()
            self.state = 2785
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 2781
                self.match(sqlParser.T__3)
                self.state = 2782
                self.complexColType()
                self.state = 2787
                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 ComplexColTypeContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


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


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

        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_complexColType

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




    def complexColType(self):

        localctx = sqlParser.ComplexColTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_complexColType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2788
            self.identifier()
            self.state = 2789
            self.match(sqlParser.T__10)
            self.state = 2790
            self.dataType()
            self.state = 2793
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.NOT:
                self.state = 2791
                self.match(sqlParser.NOT)
                self.state = 2792
                self.match(sqlParser.NULL)


            self.state = 2796
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==sqlParser.COMMENT:
                self.state = 2795
                self.commentSpec()


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


    class WhenClauseContext(ParserRuleContext):

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

        def WHEN(self):
            return self.getToken(sqlParser.WHEN, 0)

        def THEN(self):
            return self.getToken(sqlParser.THEN, 0)

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


        def getRuleIndex(self):
            return sqlParser.RULE_whenClause

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




    def whenClause(self):

        localctx = sqlParser.WhenClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_whenClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2798
            self.match(sqlParser.WHEN)
            self.state = 2799
            localctx.condition = self.expression()
            self.state = 2800
            self.match(sqlParser.THEN)
            self.state = 2801
            localctx.result = self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WindowClauseContext(ParserRuleContext):

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

        def WINDOW(self):
            return self.getToken(sqlParser.WINDOW, 0)

        def namedWindow(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.NamedWindowContext)
            else:
                return self.getTypedRuleContext(sqlParser.NamedWindowContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_windowClause

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




    def windowClause(self):

        localctx = sqlParser.WindowClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_windowClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2803
            self.match(sqlParser.WINDOW)
            self.state = 2804
            self.namedWindow()
            self.state = 2809
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,361,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2805
                    self.match(sqlParser.T__3)
                    self.state = 2806
                    self.namedWindow() 
                self.state = 2811
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,361,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 NamedWindowContext(ParserRuleContext):

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

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

        def windowSpec(self):
            return self.getTypedRuleContext(sqlParser.WindowSpecContext,0)


        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_namedWindow

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




    def namedWindow(self):

        localctx = sqlParser.NamedWindowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_namedWindow)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2812
            localctx.name = self.errorCapturingIdentifier()
            self.state = 2813
            self.match(sqlParser.AS)
            self.state = 2814
            self.windowSpec()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WindowSpecContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_windowSpec

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



    class WindowRefContext(WindowSpecContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.WindowSpecContext
            super().__init__(parser)
            self.name = None # ErrorCapturingIdentifierContext
            self.copyFrom(ctx)

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierContext,0)


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


    class WindowDefContext(WindowSpecContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a sqlParser.WindowSpecContext
            super().__init__(parser)
            self._expression = None # ExpressionContext
            self.partition = list() # of ExpressionContexts
            self.copyFrom(ctx)

        def CLUSTER(self):
            return self.getToken(sqlParser.CLUSTER, 0)
        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.BY)
            else:
                return self.getToken(sqlParser.BY, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(sqlParser.ExpressionContext,i)

        def windowFrame(self):
            return self.getTypedRuleContext(sqlParser.WindowFrameContext,0)

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.SortItemContext)
            else:
                return self.getTypedRuleContext(sqlParser.SortItemContext,i)

        def PARTITION(self):
            return self.getToken(sqlParser.PARTITION, 0)
        def DISTRIBUTE(self):
            return self.getToken(sqlParser.DISTRIBUTE, 0)
        def ORDER(self):
            return self.getToken(sqlParser.ORDER, 0)
        def SORT(self):
            return self.getToken(sqlParser.SORT, 0)

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



    def windowSpec(self):

        localctx = sqlParser.WindowSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_windowSpec)
        self._la = 0 # Token type
        try:
            self.state = 2862
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,369,self._ctx)
            if la_ == 1:
                localctx = sqlParser.WindowRefContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2816
                localctx.name = self.errorCapturingIdentifier()
                pass

            elif la_ == 2:
                localctx = sqlParser.WindowRefContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2817
                self.match(sqlParser.T__1)
                self.state = 2818
                localctx.name = self.errorCapturingIdentifier()
                self.state = 2819
                self.match(sqlParser.T__2)
                pass

            elif la_ == 3:
                localctx = sqlParser.WindowDefContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2821
                self.match(sqlParser.T__1)
                self.state = 2856
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [sqlParser.CLUSTER]:
                    self.state = 2822
                    self.match(sqlParser.CLUSTER)
                    self.state = 2823
                    self.match(sqlParser.BY)
                    self.state = 2824
                    localctx._expression = self.expression()
                    localctx.partition.append(localctx._expression)
                    self.state = 2829
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==sqlParser.T__3:
                        self.state = 2825
                        self.match(sqlParser.T__3)
                        self.state = 2826
                        localctx._expression = self.expression()
                        localctx.partition.append(localctx._expression)
                        self.state = 2831
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [sqlParser.T__2, sqlParser.DISTRIBUTE, sqlParser.ORDER, sqlParser.PARTITION, sqlParser.RANGE, sqlParser.ROWS, sqlParser.SORT]:
                    self.state = 2842
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.DISTRIBUTE or _la==sqlParser.PARTITION:
                        self.state = 2832
                        _la = self._input.LA(1)
                        if not(_la==sqlParser.DISTRIBUTE or _la==sqlParser.PARTITION):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2833
                        self.match(sqlParser.BY)
                        self.state = 2834
                        localctx._expression = self.expression()
                        localctx.partition.append(localctx._expression)
                        self.state = 2839
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==sqlParser.T__3:
                            self.state = 2835
                            self.match(sqlParser.T__3)
                            self.state = 2836
                            localctx._expression = self.expression()
                            localctx.partition.append(localctx._expression)
                            self.state = 2841
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    self.state = 2854
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==sqlParser.ORDER or _la==sqlParser.SORT:
                        self.state = 2844
                        _la = self._input.LA(1)
                        if not(_la==sqlParser.ORDER or _la==sqlParser.SORT):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2845
                        self.match(sqlParser.BY)
                        self.state = 2846
                        self.sortItem()
                        self.state = 2851
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==sqlParser.T__3:
                            self.state = 2847
                            self.match(sqlParser.T__3)
                            self.state = 2848
                            self.sortItem()
                            self.state = 2853
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2859
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.RANGE or _la==sqlParser.ROWS:
                    self.state = 2858
                    self.windowFrame()


                self.state = 2861
                self.match(sqlParser.T__2)
                pass


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


    class WindowFrameContext(ParserRuleContext):

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

        def RANGE(self):
            return self.getToken(sqlParser.RANGE, 0)

        def frameBound(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.FrameBoundContext)
            else:
                return self.getTypedRuleContext(sqlParser.FrameBoundContext,i)


        def ROWS(self):
            return self.getToken(sqlParser.ROWS, 0)

        def BETWEEN(self):
            return self.getToken(sqlParser.BETWEEN, 0)

        def AND(self):
            return self.getToken(sqlParser.AND, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_windowFrame

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




    def windowFrame(self):

        localctx = sqlParser.WindowFrameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_windowFrame)
        try:
            self.state = 2880
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,370,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2864
                localctx.frameType = self.match(sqlParser.RANGE)
                self.state = 2865
                localctx.start = self.frameBound()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2866
                localctx.frameType = self.match(sqlParser.ROWS)
                self.state = 2867
                localctx.start = self.frameBound()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2868
                localctx.frameType = self.match(sqlParser.RANGE)
                self.state = 2869
                self.match(sqlParser.BETWEEN)
                self.state = 2870
                localctx.start = self.frameBound()
                self.state = 2871
                self.match(sqlParser.AND)
                self.state = 2872
                localctx.end = self.frameBound()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2874
                localctx.frameType = self.match(sqlParser.ROWS)
                self.state = 2875
                self.match(sqlParser.BETWEEN)
                self.state = 2876
                localctx.start = self.frameBound()
                self.state = 2877
                self.match(sqlParser.AND)
                self.state = 2878
                localctx.end = self.frameBound()
                pass


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


    class FrameBoundContext(ParserRuleContext):

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

        def UNBOUNDED(self):
            return self.getToken(sqlParser.UNBOUNDED, 0)

        def PRECEDING(self):
            return self.getToken(sqlParser.PRECEDING, 0)

        def FOLLOWING(self):
            return self.getToken(sqlParser.FOLLOWING, 0)

        def ROW(self):
            return self.getToken(sqlParser.ROW, 0)

        def CURRENT(self):
            return self.getToken(sqlParser.CURRENT, 0)

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


        def getRuleIndex(self):
            return sqlParser.RULE_frameBound

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




    def frameBound(self):

        localctx = sqlParser.FrameBoundContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_frameBound)
        self._la = 0 # Token type
        try:
            self.state = 2889
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,371,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2882
                self.match(sqlParser.UNBOUNDED)
                self.state = 2883
                localctx.boundType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.FOLLOWING or _la==sqlParser.PRECEDING):
                    localctx.boundType = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2884
                localctx.boundType = self.match(sqlParser.CURRENT)
                self.state = 2885
                self.match(sqlParser.ROW)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2886
                self.expression()
                self.state = 2887
                localctx.boundType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.FOLLOWING or _la==sqlParser.PRECEDING):
                    localctx.boundType = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass


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


    class QualifiedNameListContext(ParserRuleContext):

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

        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(sqlParser.QualifiedNameContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_qualifiedNameList

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




    def qualifiedNameList(self):

        localctx = sqlParser.QualifiedNameListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_qualifiedNameList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2891
            self.qualifiedName()
            self.state = 2896
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==sqlParser.T__3:
                self.state = 2892
                self.match(sqlParser.T__3)
                self.state = 2893
                self.qualifiedName()
                self.state = 2898
                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 FunctionNameContext(ParserRuleContext):

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

        def qualifiedName(self):
            return self.getTypedRuleContext(sqlParser.QualifiedNameContext,0)


        def FILTER(self):
            return self.getToken(sqlParser.FILTER, 0)

        def LEFT(self):
            return self.getToken(sqlParser.LEFT, 0)

        def RIGHT(self):
            return self.getToken(sqlParser.RIGHT, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_functionName

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




    def functionName(self):

        localctx = sqlParser.FunctionNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_functionName)
        try:
            self.state = 2903
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,373,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2899
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2900
                self.match(sqlParser.FILTER)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2901
                self.match(sqlParser.LEFT)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2902
                self.match(sqlParser.RIGHT)
                pass


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


    class QualifiedNameContext(ParserRuleContext):

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return sqlParser.RULE_qualifiedName

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




    def qualifiedName(self):

        localctx = sqlParser.QualifiedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_qualifiedName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2905
            self.identifier()
            self.state = 2910
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,374,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2906
                    self.match(sqlParser.T__4)
                    self.state = 2907
                    self.identifier() 
                self.state = 2912
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,374,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 ErrorCapturingIdentifierContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(sqlParser.IdentifierContext,0)


        def errorCapturingIdentifierExtra(self):
            return self.getTypedRuleContext(sqlParser.ErrorCapturingIdentifierExtraContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_errorCapturingIdentifier

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




    def errorCapturingIdentifier(self):

        localctx = sqlParser.ErrorCapturingIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_errorCapturingIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2913
            self.identifier()
            self.state = 2914
            self.errorCapturingIdentifierExtra()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ErrorCapturingIdentifierExtraContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_errorCapturingIdentifierExtra

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



    class ErrorIdentContext(ErrorCapturingIdentifierExtraContext):

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

        def MINUS(self, i:int=None):
            if i is None:
                return self.getTokens(sqlParser.MINUS)
            else:
                return self.getToken(sqlParser.MINUS, i)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(sqlParser.IdentifierContext,i)


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


    class RealIdentContext(ErrorCapturingIdentifierExtraContext):

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


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



    def errorCapturingIdentifierExtra(self):

        localctx = sqlParser.ErrorCapturingIdentifierExtraContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_errorCapturingIdentifierExtra)
        try:
            self.state = 2923
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,376,self._ctx)
            if la_ == 1:
                localctx = sqlParser.ErrorIdentContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2918 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 2916
                        self.match(sqlParser.MINUS)
                        self.state = 2917
                        self.identifier()

                    else:
                        raise NoViableAltException(self)
                    self.state = 2920 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,375,self._ctx)

                pass

            elif la_ == 2:
                localctx = sqlParser.RealIdentContext(self, localctx)
                self.enterOuterAlt(localctx, 2)

                pass


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


    class IdentifierContext(ParserRuleContext):

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

        def strictIdentifier(self):
            return self.getTypedRuleContext(sqlParser.StrictIdentifierContext,0)


        def strictNonReserved(self):
            return self.getTypedRuleContext(sqlParser.StrictNonReservedContext,0)


        def getRuleIndex(self):
            return sqlParser.RULE_identifier

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




    def identifier(self):

        localctx = sqlParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_identifier)
        try:
            self.state = 2928
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,377,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2925
                self.strictIdentifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2926
                if not not self.SQL_standard_keyword_behavior:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "not self.SQL_standard_keyword_behavior")
                self.state = 2927
                self.strictNonReserved()
                pass


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


    class StrictIdentifierContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_strictIdentifier

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



    class QuotedIdentifierAlternativeContext(StrictIdentifierContext):

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

        def quotedIdentifier(self):
            return self.getTypedRuleContext(sqlParser.QuotedIdentifierContext,0)


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


    class UnquotedIdentifierContext(StrictIdentifierContext):

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

        def IDENTIFIER(self):
            return self.getToken(sqlParser.IDENTIFIER, 0)
        def ansiNonReserved(self):
            return self.getTypedRuleContext(sqlParser.AnsiNonReservedContext,0)

        def nonReserved(self):
            return self.getTypedRuleContext(sqlParser.NonReservedContext,0)


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



    def strictIdentifier(self):

        localctx = sqlParser.StrictIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_strictIdentifier)
        try:
            self.state = 2936
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,378,self._ctx)
            if la_ == 1:
                localctx = sqlParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2930
                self.match(sqlParser.IDENTIFIER)
                pass

            elif la_ == 2:
                localctx = sqlParser.QuotedIdentifierAlternativeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2931
                self.quotedIdentifier()
                pass

            elif la_ == 3:
                localctx = sqlParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2932
                if not self.SQL_standard_keyword_behavior:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.SQL_standard_keyword_behavior")
                self.state = 2933
                self.ansiNonReserved()
                pass

            elif la_ == 4:
                localctx = sqlParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2934
                if not not self.SQL_standard_keyword_behavior:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "not self.SQL_standard_keyword_behavior")
                self.state = 2935
                self.nonReserved()
                pass


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


    class QuotedIdentifierContext(ParserRuleContext):

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

        def BACKQUOTED_IDENTIFIER(self):
            return self.getToken(sqlParser.BACKQUOTED_IDENTIFIER, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_quotedIdentifier

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




    def quotedIdentifier(self):

        localctx = sqlParser.QuotedIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_quotedIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2938
            self.match(sqlParser.BACKQUOTED_IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return sqlParser.RULE_number

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



    class DecimalLiteralContext(NumberContext):

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

        def DECIMAL_VALUE(self):
            return self.getToken(sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class BigIntLiteralContext(NumberContext):

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

        def BIGINT_LITERAL(self):
            return self.getToken(sqlParser.BIGINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class TinyIntLiteralContext(NumberContext):

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

        def TINYINT_LITERAL(self):
            return self.getToken(sqlParser.TINYINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class LegacyDecimalLiteralContext(NumberContext):

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

        def EXPONENT_VALUE(self):
            return self.getToken(sqlParser.EXPONENT_VALUE, 0)
        def DECIMAL_VALUE(self):
            return self.getToken(sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class BigDecimalLiteralContext(NumberContext):

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

        def BIGDECIMAL_LITERAL(self):
            return self.getToken(sqlParser.BIGDECIMAL_LITERAL, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class ExponentLiteralContext(NumberContext):

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

        def EXPONENT_VALUE(self):
            return self.getToken(sqlParser.EXPONENT_VALUE, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class DoubleLiteralContext(NumberContext):

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

        def DOUBLE_LITERAL(self):
            return self.getToken(sqlParser.DOUBLE_LITERAL, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class IntegerLiteralContext(NumberContext):

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

        def INTEGER_VALUE(self):
            return self.getToken(sqlParser.INTEGER_VALUE, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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


    class SmallIntLiteralContext(NumberContext):

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

        def SMALLINT_LITERAL(self):
            return self.getToken(sqlParser.SMALLINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(sqlParser.MINUS, 0)

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



    def number(self):

        localctx = sqlParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.state = 2979
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,388,self._ctx)
            if la_ == 1:
                localctx = sqlParser.ExponentLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2940
                if not not self.legacy_exponent_literal_as_decimal_enabled:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "not self.legacy_exponent_literal_as_decimal_enabled")
                self.state = 2942
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2941
                    self.match(sqlParser.MINUS)


                self.state = 2944
                self.match(sqlParser.EXPONENT_VALUE)
                pass

            elif la_ == 2:
                localctx = sqlParser.DecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2945
                if not not self.legacy_exponent_literal_as_decimal_enabled:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "not self.legacy_exponent_literal_as_decimal_enabled")
                self.state = 2947
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2946
                    self.match(sqlParser.MINUS)


                self.state = 2949
                self.match(sqlParser.DECIMAL_VALUE)
                pass

            elif la_ == 3:
                localctx = sqlParser.LegacyDecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2950
                if not self.legacy_exponent_literal_as_decimal_enabled:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.legacy_exponent_literal_as_decimal_enabled")
                self.state = 2952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2951
                    self.match(sqlParser.MINUS)


                self.state = 2954
                _la = self._input.LA(1)
                if not(_la==sqlParser.EXPONENT_VALUE or _la==sqlParser.DECIMAL_VALUE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 4:
                localctx = sqlParser.IntegerLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2956
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2955
                    self.match(sqlParser.MINUS)


                self.state = 2958
                self.match(sqlParser.INTEGER_VALUE)
                pass

            elif la_ == 5:
                localctx = sqlParser.BigIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2960
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2959
                    self.match(sqlParser.MINUS)


                self.state = 2962
                self.match(sqlParser.BIGINT_LITERAL)
                pass

            elif la_ == 6:
                localctx = sqlParser.SmallIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 2964
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2963
                    self.match(sqlParser.MINUS)


                self.state = 2966
                self.match(sqlParser.SMALLINT_LITERAL)
                pass

            elif la_ == 7:
                localctx = sqlParser.TinyIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 2968
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2967
                    self.match(sqlParser.MINUS)


                self.state = 2970
                self.match(sqlParser.TINYINT_LITERAL)
                pass

            elif la_ == 8:
                localctx = sqlParser.DoubleLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 2972
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2971
                    self.match(sqlParser.MINUS)


                self.state = 2974
                self.match(sqlParser.DOUBLE_LITERAL)
                pass

            elif la_ == 9:
                localctx = sqlParser.BigDecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 2976
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==sqlParser.MINUS:
                    self.state = 2975
                    self.match(sqlParser.MINUS)


                self.state = 2978
                self.match(sqlParser.BIGDECIMAL_LITERAL)
                pass


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


    class AlterColumnActionContext(ParserRuleContext):

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

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

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


        def commentSpec(self):
            return self.getTypedRuleContext(sqlParser.CommentSpecContext,0)


        def colPosition(self):
            return self.getTypedRuleContext(sqlParser.ColPositionContext,0)


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

        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

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

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

        def getRuleIndex(self):
            return sqlParser.RULE_alterColumnAction

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




    def alterColumnAction(self):

        localctx = sqlParser.AlterColumnActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_alterColumnAction)
        self._la = 0 # Token type
        try:
            self.state = 2988
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [sqlParser.TYPE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2981
                self.match(sqlParser.TYPE)
                self.state = 2982
                self.dataType()
                pass
            elif token in [sqlParser.COMMENT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2983
                self.commentSpec()
                pass
            elif token in [sqlParser.AFTER, sqlParser.FIRST]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2984
                self.colPosition()
                pass
            elif token in [sqlParser.DROP, sqlParser.SET]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2985
                localctx.setOrDrop = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==sqlParser.DROP or _la==sqlParser.SET):
                    localctx.setOrDrop = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2986
                self.match(sqlParser.NOT)
                self.state = 2987
                self.match(sqlParser.NULL)
                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 AnsiNonReservedContext(ParserRuleContext):

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

        def ADD(self):
            return self.getToken(sqlParser.ADD, 0)

        def AFTER(self):
            return self.getToken(sqlParser.AFTER, 0)

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)

        def ANALYZE(self):
            return self.getToken(sqlParser.ANALYZE, 0)

        def ARCHIVE(self):
            return self.getToken(sqlParser.ARCHIVE, 0)

        def ARRAY(self):
            return self.getToken(sqlParser.ARRAY, 0)

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

        def AT(self):
            return self.getToken(sqlParser.AT, 0)

        def BETWEEN(self):
            return self.getToken(sqlParser.BETWEEN, 0)

        def BUCKET(self):
            return self.getToken(sqlParser.BUCKET, 0)

        def BUCKETS(self):
            return self.getToken(sqlParser.BUCKETS, 0)

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

        def CACHE(self):
            return self.getToken(sqlParser.CACHE, 0)

        def CASCADE(self):
            return self.getToken(sqlParser.CASCADE, 0)

        def CHANGE(self):
            return self.getToken(sqlParser.CHANGE, 0)

        def CLEAR(self):
            return self.getToken(sqlParser.CLEAR, 0)

        def CLUSTER(self):
            return self.getToken(sqlParser.CLUSTER, 0)

        def CLUSTERED(self):
            return self.getToken(sqlParser.CLUSTERED, 0)

        def CODEGEN(self):
            return self.getToken(sqlParser.CODEGEN, 0)

        def COLLECTION(self):
            return self.getToken(sqlParser.COLLECTION, 0)

        def COLUMNS(self):
            return self.getToken(sqlParser.COLUMNS, 0)

        def COMMENT(self):
            return self.getToken(sqlParser.COMMENT, 0)

        def COMMIT(self):
            return self.getToken(sqlParser.COMMIT, 0)

        def COMPACT(self):
            return self.getToken(sqlParser.COMPACT, 0)

        def COMPACTIONS(self):
            return self.getToken(sqlParser.COMPACTIONS, 0)

        def COMPUTE(self):
            return self.getToken(sqlParser.COMPUTE, 0)

        def CONCATENATE(self):
            return self.getToken(sqlParser.CONCATENATE, 0)

        def COST(self):
            return self.getToken(sqlParser.COST, 0)

        def CUBE(self):
            return self.getToken(sqlParser.CUBE, 0)

        def CURRENT(self):
            return self.getToken(sqlParser.CURRENT, 0)

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

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

        def DATABASES(self):
            return self.getToken(sqlParser.DATABASES, 0)

        def DBPROPERTIES(self):
            return self.getToken(sqlParser.DBPROPERTIES, 0)

        def DEFINED(self):
            return self.getToken(sqlParser.DEFINED, 0)

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

        def DELIMITED(self):
            return self.getToken(sqlParser.DELIMITED, 0)

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

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

        def DFS(self):
            return self.getToken(sqlParser.DFS, 0)

        def DIRECTORIES(self):
            return self.getToken(sqlParser.DIRECTORIES, 0)

        def DIRECTORY(self):
            return self.getToken(sqlParser.DIRECTORY, 0)

        def DISTRIBUTE(self):
            return self.getToken(sqlParser.DISTRIBUTE, 0)

        def DIV(self):
            return self.getToken(sqlParser.DIV, 0)

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

        def ESCAPED(self):
            return self.getToken(sqlParser.ESCAPED, 0)

        def EXCHANGE(self):
            return self.getToken(sqlParser.EXCHANGE, 0)

        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

        def EXPLAIN(self):
            return self.getToken(sqlParser.EXPLAIN, 0)

        def EXPORT(self):
            return self.getToken(sqlParser.EXPORT, 0)

        def EXTENDED(self):
            return self.getToken(sqlParser.EXTENDED, 0)

        def EXTERNAL(self):
            return self.getToken(sqlParser.EXTERNAL, 0)

        def EXTRACT(self):
            return self.getToken(sqlParser.EXTRACT, 0)

        def FIELDS(self):
            return self.getToken(sqlParser.FIELDS, 0)

        def FILEFORMAT(self):
            return self.getToken(sqlParser.FILEFORMAT, 0)

        def FIRST(self):
            return self.getToken(sqlParser.FIRST, 0)

        def FOLLOWING(self):
            return self.getToken(sqlParser.FOLLOWING, 0)

        def FORMAT(self):
            return self.getToken(sqlParser.FORMAT, 0)

        def FORMATTED(self):
            return self.getToken(sqlParser.FORMATTED, 0)

        def FUNCTION(self):
            return self.getToken(sqlParser.FUNCTION, 0)

        def FUNCTIONS(self):
            return self.getToken(sqlParser.FUNCTIONS, 0)

        def GLOBAL(self):
            return self.getToken(sqlParser.GLOBAL, 0)

        def GROUPING(self):
            return self.getToken(sqlParser.GROUPING, 0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)

        def IGNORE(self):
            return self.getToken(sqlParser.IGNORE, 0)

        def IMPORT(self):
            return self.getToken(sqlParser.IMPORT, 0)

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

        def INDEXES(self):
            return self.getToken(sqlParser.INDEXES, 0)

        def INPATH(self):
            return self.getToken(sqlParser.INPATH, 0)

        def INPUTFORMAT(self):
            return self.getToken(sqlParser.INPUTFORMAT, 0)

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

        def INTERVAL(self):
            return self.getToken(sqlParser.INTERVAL, 0)

        def ITEMS(self):
            return self.getToken(sqlParser.ITEMS, 0)

        def KEYS(self):
            return self.getToken(sqlParser.KEYS, 0)

        def LAST(self):
            return self.getToken(sqlParser.LAST, 0)

        def LATERAL(self):
            return self.getToken(sqlParser.LATERAL, 0)

        def LAZY(self):
            return self.getToken(sqlParser.LAZY, 0)

        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)

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

        def LINES(self):
            return self.getToken(sqlParser.LINES, 0)

        def LIST(self):
            return self.getToken(sqlParser.LIST, 0)

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

        def LOCAL(self):
            return self.getToken(sqlParser.LOCAL, 0)

        def LOCATION(self):
            return self.getToken(sqlParser.LOCATION, 0)

        def LOCK(self):
            return self.getToken(sqlParser.LOCK, 0)

        def LOCKS(self):
            return self.getToken(sqlParser.LOCKS, 0)

        def LOGICAL(self):
            return self.getToken(sqlParser.LOGICAL, 0)

        def MACRO(self):
            return self.getToken(sqlParser.MACRO, 0)

        def MAP(self):
            return self.getToken(sqlParser.MAP, 0)

        def MATCHED(self):
            return self.getToken(sqlParser.MATCHED, 0)

        def MERGE(self):
            return self.getToken(sqlParser.MERGE, 0)

        def MSCK(self):
            return self.getToken(sqlParser.MSCK, 0)

        def NAMESPACE(self):
            return self.getToken(sqlParser.NAMESPACE, 0)

        def NAMESPACES(self):
            return self.getToken(sqlParser.NAMESPACES, 0)

        def NO(self):
            return self.getToken(sqlParser.NO, 0)

        def NULLS(self):
            return self.getToken(sqlParser.NULLS, 0)

        def OF(self):
            return self.getToken(sqlParser.OF, 0)

        def OPTION(self):
            return self.getToken(sqlParser.OPTION, 0)

        def OPTIONS(self):
            return self.getToken(sqlParser.OPTIONS, 0)

        def OUT(self):
            return self.getToken(sqlParser.OUT, 0)

        def OUTPUTFORMAT(self):
            return self.getToken(sqlParser.OUTPUTFORMAT, 0)

        def OVER(self):
            return self.getToken(sqlParser.OVER, 0)

        def OVERLAY(self):
            return self.getToken(sqlParser.OVERLAY, 0)

        def OVERWRITE(self):
            return self.getToken(sqlParser.OVERWRITE, 0)

        def PARTITION(self):
            return self.getToken(sqlParser.PARTITION, 0)

        def PARTITIONED(self):
            return self.getToken(sqlParser.PARTITIONED, 0)

        def PARTITIONS(self):
            return self.getToken(sqlParser.PARTITIONS, 0)

        def PERCENTLIT(self):
            return self.getToken(sqlParser.PERCENTLIT, 0)

        def PIVOT(self):
            return self.getToken(sqlParser.PIVOT, 0)

        def PLACING(self):
            return self.getToken(sqlParser.PLACING, 0)

        def POSITION(self):
            return self.getToken(sqlParser.POSITION, 0)

        def PRECEDING(self):
            return self.getToken(sqlParser.PRECEDING, 0)

        def PRINCIPALS(self):
            return self.getToken(sqlParser.PRINCIPALS, 0)

        def PROPERTIES(self):
            return self.getToken(sqlParser.PROPERTIES, 0)

        def PURGE(self):
            return self.getToken(sqlParser.PURGE, 0)

        def QUERY(self):
            return self.getToken(sqlParser.QUERY, 0)

        def RANGE(self):
            return self.getToken(sqlParser.RANGE, 0)

        def RECORDREADER(self):
            return self.getToken(sqlParser.RECORDREADER, 0)

        def RECORDWRITER(self):
            return self.getToken(sqlParser.RECORDWRITER, 0)

        def RECOVER(self):
            return self.getToken(sqlParser.RECOVER, 0)

        def REDUCE(self):
            return self.getToken(sqlParser.REDUCE, 0)

        def REFRESH(self):
            return self.getToken(sqlParser.REFRESH, 0)

        def RENAME(self):
            return self.getToken(sqlParser.RENAME, 0)

        def REPAIR(self):
            return self.getToken(sqlParser.REPAIR, 0)

        def REPLACE(self):
            return self.getToken(sqlParser.REPLACE, 0)

        def RESET(self):
            return self.getToken(sqlParser.RESET, 0)

        def RESTRICT(self):
            return self.getToken(sqlParser.RESTRICT, 0)

        def REVOKE(self):
            return self.getToken(sqlParser.REVOKE, 0)

        def RLIKE(self):
            return self.getToken(sqlParser.RLIKE, 0)

        def ROLE(self):
            return self.getToken(sqlParser.ROLE, 0)

        def ROLES(self):
            return self.getToken(sqlParser.ROLES, 0)

        def ROLLBACK(self):
            return self.getToken(sqlParser.ROLLBACK, 0)

        def ROLLUP(self):
            return self.getToken(sqlParser.ROLLUP, 0)

        def ROW(self):
            return self.getToken(sqlParser.ROW, 0)

        def ROWS(self):
            return self.getToken(sqlParser.ROWS, 0)

        def SCHEMA(self):
            return self.getToken(sqlParser.SCHEMA, 0)

        def SEPARATED(self):
            return self.getToken(sqlParser.SEPARATED, 0)

        def SERDE(self):
            return self.getToken(sqlParser.SERDE, 0)

        def SERDEPROPERTIES(self):
            return self.getToken(sqlParser.SERDEPROPERTIES, 0)

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

        def SETS(self):
            return self.getToken(sqlParser.SETS, 0)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)

        def SKEWED(self):
            return self.getToken(sqlParser.SKEWED, 0)

        def SORT(self):
            return self.getToken(sqlParser.SORT, 0)

        def SORTED(self):
            return self.getToken(sqlParser.SORTED, 0)

        def START(self):
            return self.getToken(sqlParser.START, 0)

        def STATISTICS(self):
            return self.getToken(sqlParser.STATISTICS, 0)

        def STORED(self):
            return self.getToken(sqlParser.STORED, 0)

        def STRATIFY(self):
            return self.getToken(sqlParser.STRATIFY, 0)

        def STRUCT(self):
            return self.getToken(sqlParser.STRUCT, 0)

        def SUBSTR(self):
            return self.getToken(sqlParser.SUBSTR, 0)

        def SUBSTRING(self):
            return self.getToken(sqlParser.SUBSTRING, 0)

        def TABLES(self):
            return self.getToken(sqlParser.TABLES, 0)

        def TABLESAMPLE(self):
            return self.getToken(sqlParser.TABLESAMPLE, 0)

        def TBLPROPERTIES(self):
            return self.getToken(sqlParser.TBLPROPERTIES, 0)

        def TEMPORARY(self):
            return self.getToken(sqlParser.TEMPORARY, 0)

        def TERMINATED(self):
            return self.getToken(sqlParser.TERMINATED, 0)

        def TOUCH(self):
            return self.getToken(sqlParser.TOUCH, 0)

        def TRANSACTION(self):
            return self.getToken(sqlParser.TRANSACTION, 0)

        def TRANSACTIONS(self):
            return self.getToken(sqlParser.TRANSACTIONS, 0)

        def TRANSFORM(self):
            return self.getToken(sqlParser.TRANSFORM, 0)

        def TRIM(self):
            return self.getToken(sqlParser.TRIM, 0)

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

        def TRUNCATE(self):
            return self.getToken(sqlParser.TRUNCATE, 0)

        def UNARCHIVE(self):
            return self.getToken(sqlParser.UNARCHIVE, 0)

        def UNBOUNDED(self):
            return self.getToken(sqlParser.UNBOUNDED, 0)

        def UNCACHE(self):
            return self.getToken(sqlParser.UNCACHE, 0)

        def UNLOCK(self):
            return self.getToken(sqlParser.UNLOCK, 0)

        def UNSET(self):
            return self.getToken(sqlParser.UNSET, 0)

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

        def USE(self):
            return self.getToken(sqlParser.USE, 0)

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

        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)

        def VIEWS(self):
            return self.getToken(sqlParser.VIEWS, 0)

        def WINDOW(self):
            return self.getToken(sqlParser.WINDOW, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_ansiNonReserved

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




    def ansiNonReserved(self):

        localctx = sqlParser.AnsiNonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_ansiNonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2990
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << sqlParser.ADD) | (1 << sqlParser.AFTER) | (1 << sqlParser.ALTER) | (1 << sqlParser.ANALYZE) | (1 << sqlParser.ARCHIVE) | (1 << sqlParser.ARRAY) | (1 << sqlParser.ASC) | (1 << sqlParser.AT) | (1 << sqlParser.BETWEEN) | (1 << sqlParser.BUCKET) | (1 << sqlParser.BUCKETS) | (1 << sqlParser.BY) | (1 << sqlParser.CACHE) | (1 << sqlParser.CASCADE) | (1 << sqlParser.CHANGE) | (1 << sqlParser.CLEAR) | (1 << sqlParser.CLUSTER) | (1 << sqlParser.CLUSTERED) | (1 << sqlParser.CODEGEN) | (1 << sqlParser.COLLECTION) | (1 << sqlParser.COLUMNS) | (1 << sqlParser.COMMENT) | (1 << sqlParser.COMMIT) | (1 << sqlParser.COMPACT) | (1 << sqlParser.COMPACTIONS) | (1 << sqlParser.COMPUTE) | (1 << sqlParser.CONCATENATE) | (1 << sqlParser.COST) | (1 << sqlParser.CUBE) | (1 << sqlParser.CURRENT) | (1 << sqlParser.DATA) | (1 << sqlParser.DATABASE) | (1 << sqlParser.DATABASES))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (sqlParser.DBPROPERTIES - 65)) | (1 << (sqlParser.DEFINED - 65)) | (1 << (sqlParser.DELETE - 65)) | (1 << (sqlParser.DELIMITED - 65)) | (1 << (sqlParser.DESC - 65)) | (1 << (sqlParser.DESCRIBE - 65)) | (1 << (sqlParser.DFS - 65)) | (1 << (sqlParser.DIRECTORIES - 65)) | (1 << (sqlParser.DIRECTORY - 65)) | (1 << (sqlParser.DISTRIBUTE - 65)) | (1 << (sqlParser.DROP - 65)) | (1 << (sqlParser.ESCAPED - 65)) | (1 << (sqlParser.EXCHANGE - 65)) | (1 << (sqlParser.EXISTS - 65)) | (1 << (sqlParser.EXPLAIN - 65)) | (1 << (sqlParser.EXPORT - 65)) | (1 << (sqlParser.EXTENDED - 65)) | (1 << (sqlParser.EXTERNAL - 65)) | (1 << (sqlParser.EXTRACT - 65)) | (1 << (sqlParser.FIELDS - 65)) | (1 << (sqlParser.FILEFORMAT - 65)) | (1 << (sqlParser.FIRST - 65)) | (1 << (sqlParser.FOLLOWING - 65)) | (1 << (sqlParser.FORMAT - 65)) | (1 << (sqlParser.FORMATTED - 65)) | (1 << (sqlParser.FUNCTION - 65)) | (1 << (sqlParser.FUNCTIONS - 65)) | (1 << (sqlParser.GLOBAL - 65)) | (1 << (sqlParser.GROUPING - 65)) | (1 << (sqlParser.IF - 65)) | (1 << (sqlParser.IGNORE - 65)) | (1 << (sqlParser.IMPORT - 65)) | (1 << (sqlParser.INDEX - 65)) | (1 << (sqlParser.INDEXES - 65)) | (1 << (sqlParser.INPATH - 65)) | (1 << (sqlParser.INPUTFORMAT - 65)) | (1 << (sqlParser.INSERT - 65)) | (1 << (sqlParser.INTERVAL - 65)) | (1 << (sqlParser.ITEMS - 65)) | (1 << (sqlParser.KEYS - 65)) | (1 << (sqlParser.LAST - 65)) | (1 << (sqlParser.LATERAL - 65)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (sqlParser.LAZY - 129)) | (1 << (sqlParser.LIKE - 129)) | (1 << (sqlParser.LIMIT - 129)) | (1 << (sqlParser.LINES - 129)) | (1 << (sqlParser.LIST - 129)) | (1 << (sqlParser.LOAD - 129)) | (1 << (sqlParser.LOCAL - 129)) | (1 << (sqlParser.LOCATION - 129)) | (1 << (sqlParser.LOCK - 129)) | (1 << (sqlParser.LOCKS - 129)) | (1 << (sqlParser.LOGICAL - 129)) | (1 << (sqlParser.MACRO - 129)) | (1 << (sqlParser.MAP - 129)) | (1 << (sqlParser.MATCHED - 129)) | (1 << (sqlParser.MERGE - 129)) | (1 << (sqlParser.MSCK - 129)) | (1 << (sqlParser.NAMESPACE - 129)) | (1 << (sqlParser.NAMESPACES - 129)) | (1 << (sqlParser.NO - 129)) | (1 << (sqlParser.NULLS - 129)) | (1 << (sqlParser.OF - 129)) | (1 << (sqlParser.OPTION - 129)) | (1 << (sqlParser.OPTIONS - 129)) | (1 << (sqlParser.OUT - 129)) | (1 << (sqlParser.OUTPUTFORMAT - 129)) | (1 << (sqlParser.OVER - 129)) | (1 << (sqlParser.OVERLAY - 129)) | (1 << (sqlParser.OVERWRITE - 129)) | (1 << (sqlParser.PARTITION - 129)) | (1 << (sqlParser.PARTITIONED - 129)) | (1 << (sqlParser.PARTITIONS - 129)) | (1 << (sqlParser.PERCENTLIT - 129)) | (1 << (sqlParser.PIVOT - 129)) | (1 << (sqlParser.PLACING - 129)) | (1 << (sqlParser.POSITION - 129)) | (1 << (sqlParser.PRECEDING - 129)) | (1 << (sqlParser.PRINCIPALS - 129)) | (1 << (sqlParser.PROPERTIES - 129)) | (1 << (sqlParser.PURGE - 129)) | (1 << (sqlParser.QUERY - 129)) | (1 << (sqlParser.RANGE - 129)) | (1 << (sqlParser.RECORDREADER - 129)) | (1 << (sqlParser.RECORDWRITER - 129)) | (1 << (sqlParser.RECOVER - 129)) | (1 << (sqlParser.REDUCE - 129)) | (1 << (sqlParser.REFRESH - 129)) | (1 << (sqlParser.RENAME - 129)) | (1 << (sqlParser.REPAIR - 129)) | (1 << (sqlParser.REPLACE - 129)))) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & ((1 << (sqlParser.RESET - 193)) | (1 << (sqlParser.RESTRICT - 193)) | (1 << (sqlParser.REVOKE - 193)) | (1 << (sqlParser.RLIKE - 193)) | (1 << (sqlParser.ROLE - 193)) | (1 << (sqlParser.ROLES - 193)) | (1 << (sqlParser.ROLLBACK - 193)) | (1 << (sqlParser.ROLLUP - 193)) | (1 << (sqlParser.ROW - 193)) | (1 << (sqlParser.ROWS - 193)) | (1 << (sqlParser.SCHEMA - 193)) | (1 << (sqlParser.SEPARATED - 193)) | (1 << (sqlParser.SERDE - 193)) | (1 << (sqlParser.SERDEPROPERTIES - 193)) | (1 << (sqlParser.SET - 193)) | (1 << (sqlParser.SETS - 193)) | (1 << (sqlParser.SHOW - 193)) | (1 << (sqlParser.SKEWED - 193)) | (1 << (sqlParser.SORT - 193)) | (1 << (sqlParser.SORTED - 193)) | (1 << (sqlParser.START - 193)) | (1 << (sqlParser.STATISTICS - 193)) | (1 << (sqlParser.STORED - 193)) | (1 << (sqlParser.STRATIFY - 193)) | (1 << (sqlParser.STRUCT - 193)) | (1 << (sqlParser.SUBSTR - 193)) | (1 << (sqlParser.SUBSTRING - 193)) | (1 << (sqlParser.TABLES - 193)) | (1 << (sqlParser.TABLESAMPLE - 193)) | (1 << (sqlParser.TBLPROPERTIES - 193)) | (1 << (sqlParser.TEMPORARY - 193)) | (1 << (sqlParser.TERMINATED - 193)) | (1 << (sqlParser.TOUCH - 193)) | (1 << (sqlParser.TRANSACTION - 193)) | (1 << (sqlParser.TRANSACTIONS - 193)) | (1 << (sqlParser.TRANSFORM - 193)) | (1 << (sqlParser.TRIM - 193)) | (1 << (sqlParser.TRUE - 193)) | (1 << (sqlParser.TRUNCATE - 193)) | (1 << (sqlParser.UNARCHIVE - 193)) | (1 << (sqlParser.UNBOUNDED - 193)) | (1 << (sqlParser.UNCACHE - 193)) | (1 << (sqlParser.UNLOCK - 193)) | (1 << (sqlParser.UNSET - 193)) | (1 << (sqlParser.UPDATE - 193)) | (1 << (sqlParser.USE - 193)) | (1 << (sqlParser.VALUES - 193)))) != 0) or ((((_la - 257)) & ~0x3f) == 0 and ((1 << (_la - 257)) & ((1 << (sqlParser.VIEW - 257)) | (1 << (sqlParser.VIEWS - 257)) | (1 << (sqlParser.WINDOW - 257)) | (1 << (sqlParser.DIV - 257)))) != 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 StrictNonReservedContext(ParserRuleContext):

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

        def ANTI(self):
            return self.getToken(sqlParser.ANTI, 0)

        def CROSS(self):
            return self.getToken(sqlParser.CROSS, 0)

        def EXCEPT(self):
            return self.getToken(sqlParser.EXCEPT, 0)

        def FULL(self):
            return self.getToken(sqlParser.FULL, 0)

        def INNER(self):
            return self.getToken(sqlParser.INNER, 0)

        def INTERSECT(self):
            return self.getToken(sqlParser.INTERSECT, 0)

        def JOIN(self):
            return self.getToken(sqlParser.JOIN, 0)

        def LEFT(self):
            return self.getToken(sqlParser.LEFT, 0)

        def NATURAL(self):
            return self.getToken(sqlParser.NATURAL, 0)

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

        def RIGHT(self):
            return self.getToken(sqlParser.RIGHT, 0)

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

        def SETMINUS(self):
            return self.getToken(sqlParser.SETMINUS, 0)

        def UNION(self):
            return self.getToken(sqlParser.UNION, 0)

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

        def getRuleIndex(self):
            return sqlParser.RULE_strictNonReserved

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




    def strictNonReserved(self):

        localctx = sqlParser.StrictNonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_strictNonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2992
            _la = self._input.LA(1)
            if not(((((_la - 18)) & ~0x3f) == 0 and ((1 << (_la - 18)) & ((1 << (sqlParser.ANTI - 18)) | (1 << (sqlParser.CROSS - 18)) | (1 << (sqlParser.EXCEPT - 18)))) != 0) or ((((_la - 101)) & ~0x3f) == 0 and ((1 << (_la - 101)) & ((1 << (sqlParser.FULL - 101)) | (1 << (sqlParser.INNER - 101)) | (1 << (sqlParser.INTERSECT - 101)) | (1 << (sqlParser.JOIN - 101)) | (1 << (sqlParser.LEFT - 101)) | (1 << (sqlParser.NATURAL - 101)) | (1 << (sqlParser.ON - 101)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (sqlParser.RIGHT - 196)) | (1 << (sqlParser.SEMI - 196)) | (1 << (sqlParser.SETMINUS - 196)) | (1 << (sqlParser.UNION - 196)) | (1 << (sqlParser.USING - 196)))) != 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 NonReservedContext(ParserRuleContext):

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

        def ADD(self):
            return self.getToken(sqlParser.ADD, 0)

        def AFTER(self):
            return self.getToken(sqlParser.AFTER, 0)

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

        def ALTER(self):
            return self.getToken(sqlParser.ALTER, 0)

        def ANALYZE(self):
            return self.getToken(sqlParser.ANALYZE, 0)

        def AND(self):
            return self.getToken(sqlParser.AND, 0)

        def ANY(self):
            return self.getToken(sqlParser.ANY, 0)

        def ARCHIVE(self):
            return self.getToken(sqlParser.ARCHIVE, 0)

        def ARRAY(self):
            return self.getToken(sqlParser.ARRAY, 0)

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

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

        def AT(self):
            return self.getToken(sqlParser.AT, 0)

        def AUTHORIZATION(self):
            return self.getToken(sqlParser.AUTHORIZATION, 0)

        def BETWEEN(self):
            return self.getToken(sqlParser.BETWEEN, 0)

        def BOTH(self):
            return self.getToken(sqlParser.BOTH, 0)

        def BUCKET(self):
            return self.getToken(sqlParser.BUCKET, 0)

        def BUCKETS(self):
            return self.getToken(sqlParser.BUCKETS, 0)

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

        def CACHE(self):
            return self.getToken(sqlParser.CACHE, 0)

        def CASCADE(self):
            return self.getToken(sqlParser.CASCADE, 0)

        def CASE(self):
            return self.getToken(sqlParser.CASE, 0)

        def CAST(self):
            return self.getToken(sqlParser.CAST, 0)

        def CHANGE(self):
            return self.getToken(sqlParser.CHANGE, 0)

        def CHECK(self):
            return self.getToken(sqlParser.CHECK, 0)

        def CLEAR(self):
            return self.getToken(sqlParser.CLEAR, 0)

        def CLUSTER(self):
            return self.getToken(sqlParser.CLUSTER, 0)

        def CLUSTERED(self):
            return self.getToken(sqlParser.CLUSTERED, 0)

        def CODEGEN(self):
            return self.getToken(sqlParser.CODEGEN, 0)

        def COLLATE(self):
            return self.getToken(sqlParser.COLLATE, 0)

        def COLLECTION(self):
            return self.getToken(sqlParser.COLLECTION, 0)

        def COLUMN(self):
            return self.getToken(sqlParser.COLUMN, 0)

        def COLUMNS(self):
            return self.getToken(sqlParser.COLUMNS, 0)

        def COMMENT(self):
            return self.getToken(sqlParser.COMMENT, 0)

        def COMMIT(self):
            return self.getToken(sqlParser.COMMIT, 0)

        def COMPACT(self):
            return self.getToken(sqlParser.COMPACT, 0)

        def COMPACTIONS(self):
            return self.getToken(sqlParser.COMPACTIONS, 0)

        def COMPUTE(self):
            return self.getToken(sqlParser.COMPUTE, 0)

        def CONCATENATE(self):
            return self.getToken(sqlParser.CONCATENATE, 0)

        def CONSTRAINT(self):
            return self.getToken(sqlParser.CONSTRAINT, 0)

        def COST(self):
            return self.getToken(sqlParser.COST, 0)

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

        def CUBE(self):
            return self.getToken(sqlParser.CUBE, 0)

        def CURRENT(self):
            return self.getToken(sqlParser.CURRENT, 0)

        def CURRENT_DATE(self):
            return self.getToken(sqlParser.CURRENT_DATE, 0)

        def CURRENT_TIME(self):
            return self.getToken(sqlParser.CURRENT_TIME, 0)

        def CURRENT_TIMESTAMP(self):
            return self.getToken(sqlParser.CURRENT_TIMESTAMP, 0)

        def CURRENT_USER(self):
            return self.getToken(sqlParser.CURRENT_USER, 0)

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

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

        def DATABASES(self):
            return self.getToken(sqlParser.DATABASES, 0)

        def DAY(self):
            return self.getToken(sqlParser.DAY, 0)

        def DBPROPERTIES(self):
            return self.getToken(sqlParser.DBPROPERTIES, 0)

        def DEFINED(self):
            return self.getToken(sqlParser.DEFINED, 0)

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

        def DELIMITED(self):
            return self.getToken(sqlParser.DELIMITED, 0)

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

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

        def DFS(self):
            return self.getToken(sqlParser.DFS, 0)

        def DIRECTORIES(self):
            return self.getToken(sqlParser.DIRECTORIES, 0)

        def DIRECTORY(self):
            return self.getToken(sqlParser.DIRECTORY, 0)

        def DISTINCT(self):
            return self.getToken(sqlParser.DISTINCT, 0)

        def DISTRIBUTE(self):
            return self.getToken(sqlParser.DISTRIBUTE, 0)

        def DIV(self):
            return self.getToken(sqlParser.DIV, 0)

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

        def ELSE(self):
            return self.getToken(sqlParser.ELSE, 0)

        def END(self):
            return self.getToken(sqlParser.END, 0)

        def ESCAPE(self):
            return self.getToken(sqlParser.ESCAPE, 0)

        def ESCAPED(self):
            return self.getToken(sqlParser.ESCAPED, 0)

        def EXCHANGE(self):
            return self.getToken(sqlParser.EXCHANGE, 0)

        def EXISTS(self):
            return self.getToken(sqlParser.EXISTS, 0)

        def EXPLAIN(self):
            return self.getToken(sqlParser.EXPLAIN, 0)

        def EXPORT(self):
            return self.getToken(sqlParser.EXPORT, 0)

        def EXTENDED(self):
            return self.getToken(sqlParser.EXTENDED, 0)

        def EXTERNAL(self):
            return self.getToken(sqlParser.EXTERNAL, 0)

        def EXTRACT(self):
            return self.getToken(sqlParser.EXTRACT, 0)

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

        def FETCH(self):
            return self.getToken(sqlParser.FETCH, 0)

        def FILTER(self):
            return self.getToken(sqlParser.FILTER, 0)

        def FIELDS(self):
            return self.getToken(sqlParser.FIELDS, 0)

        def FILEFORMAT(self):
            return self.getToken(sqlParser.FILEFORMAT, 0)

        def FIRST(self):
            return self.getToken(sqlParser.FIRST, 0)

        def FOLLOWING(self):
            return self.getToken(sqlParser.FOLLOWING, 0)

        def FOR(self):
            return self.getToken(sqlParser.FOR, 0)

        def FOREIGN(self):
            return self.getToken(sqlParser.FOREIGN, 0)

        def FORMAT(self):
            return self.getToken(sqlParser.FORMAT, 0)

        def FORMATTED(self):
            return self.getToken(sqlParser.FORMATTED, 0)

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

        def FUNCTION(self):
            return self.getToken(sqlParser.FUNCTION, 0)

        def FUNCTIONS(self):
            return self.getToken(sqlParser.FUNCTIONS, 0)

        def GLOBAL(self):
            return self.getToken(sqlParser.GLOBAL, 0)

        def GRANT(self):
            return self.getToken(sqlParser.GRANT, 0)

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

        def GROUPING(self):
            return self.getToken(sqlParser.GROUPING, 0)

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

        def HOUR(self):
            return self.getToken(sqlParser.HOUR, 0)

        def IF(self):
            return self.getToken(sqlParser.IF, 0)

        def IGNORE(self):
            return self.getToken(sqlParser.IGNORE, 0)

        def IMPORT(self):
            return self.getToken(sqlParser.IMPORT, 0)

        def IN(self):
            return self.getToken(sqlParser.IN, 0)

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

        def INDEXES(self):
            return self.getToken(sqlParser.INDEXES, 0)

        def INPATH(self):
            return self.getToken(sqlParser.INPATH, 0)

        def INPUTFORMAT(self):
            return self.getToken(sqlParser.INPUTFORMAT, 0)

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

        def INTERVAL(self):
            return self.getToken(sqlParser.INTERVAL, 0)

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

        def IS(self):
            return self.getToken(sqlParser.IS, 0)

        def ITEMS(self):
            return self.getToken(sqlParser.ITEMS, 0)

        def KEYS(self):
            return self.getToken(sqlParser.KEYS, 0)

        def LAST(self):
            return self.getToken(sqlParser.LAST, 0)

        def LATERAL(self):
            return self.getToken(sqlParser.LATERAL, 0)

        def LAZY(self):
            return self.getToken(sqlParser.LAZY, 0)

        def LEADING(self):
            return self.getToken(sqlParser.LEADING, 0)

        def LIKE(self):
            return self.getToken(sqlParser.LIKE, 0)

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

        def LINES(self):
            return self.getToken(sqlParser.LINES, 0)

        def LIST(self):
            return self.getToken(sqlParser.LIST, 0)

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

        def LOCAL(self):
            return self.getToken(sqlParser.LOCAL, 0)

        def LOCATION(self):
            return self.getToken(sqlParser.LOCATION, 0)

        def LOCK(self):
            return self.getToken(sqlParser.LOCK, 0)

        def LOCKS(self):
            return self.getToken(sqlParser.LOCKS, 0)

        def LOGICAL(self):
            return self.getToken(sqlParser.LOGICAL, 0)

        def MACRO(self):
            return self.getToken(sqlParser.MACRO, 0)

        def MAP(self):
            return self.getToken(sqlParser.MAP, 0)

        def MATCHED(self):
            return self.getToken(sqlParser.MATCHED, 0)

        def MERGE(self):
            return self.getToken(sqlParser.MERGE, 0)

        def MINUTE(self):
            return self.getToken(sqlParser.MINUTE, 0)

        def MONTH(self):
            return self.getToken(sqlParser.MONTH, 0)

        def MSCK(self):
            return self.getToken(sqlParser.MSCK, 0)

        def NAMESPACE(self):
            return self.getToken(sqlParser.NAMESPACE, 0)

        def NAMESPACES(self):
            return self.getToken(sqlParser.NAMESPACES, 0)

        def NO(self):
            return self.getToken(sqlParser.NO, 0)

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

        def NULL(self):
            return self.getToken(sqlParser.NULL, 0)

        def NULLS(self):
            return self.getToken(sqlParser.NULLS, 0)

        def OF(self):
            return self.getToken(sqlParser.OF, 0)

        def ONLY(self):
            return self.getToken(sqlParser.ONLY, 0)

        def OPTION(self):
            return self.getToken(sqlParser.OPTION, 0)

        def OPTIONS(self):
            return self.getToken(sqlParser.OPTIONS, 0)

        def OR(self):
            return self.getToken(sqlParser.OR, 0)

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

        def OUT(self):
            return self.getToken(sqlParser.OUT, 0)

        def OUTER(self):
            return self.getToken(sqlParser.OUTER, 0)

        def OUTPUTFORMAT(self):
            return self.getToken(sqlParser.OUTPUTFORMAT, 0)

        def OVER(self):
            return self.getToken(sqlParser.OVER, 0)

        def OVERLAPS(self):
            return self.getToken(sqlParser.OVERLAPS, 0)

        def OVERLAY(self):
            return self.getToken(sqlParser.OVERLAY, 0)

        def OVERWRITE(self):
            return self.getToken(sqlParser.OVERWRITE, 0)

        def PARTITION(self):
            return self.getToken(sqlParser.PARTITION, 0)

        def PARTITIONED(self):
            return self.getToken(sqlParser.PARTITIONED, 0)

        def PARTITIONS(self):
            return self.getToken(sqlParser.PARTITIONS, 0)

        def PERCENTLIT(self):
            return self.getToken(sqlParser.PERCENTLIT, 0)

        def PIVOT(self):
            return self.getToken(sqlParser.PIVOT, 0)

        def PLACING(self):
            return self.getToken(sqlParser.PLACING, 0)

        def POSITION(self):
            return self.getToken(sqlParser.POSITION, 0)

        def PRECEDING(self):
            return self.getToken(sqlParser.PRECEDING, 0)

        def PRIMARY(self):
            return self.getToken(sqlParser.PRIMARY, 0)

        def PRINCIPALS(self):
            return self.getToken(sqlParser.PRINCIPALS, 0)

        def PROPERTIES(self):
            return self.getToken(sqlParser.PROPERTIES, 0)

        def PURGE(self):
            return self.getToken(sqlParser.PURGE, 0)

        def QUERY(self):
            return self.getToken(sqlParser.QUERY, 0)

        def RANGE(self):
            return self.getToken(sqlParser.RANGE, 0)

        def RECORDREADER(self):
            return self.getToken(sqlParser.RECORDREADER, 0)

        def RECORDWRITER(self):
            return self.getToken(sqlParser.RECORDWRITER, 0)

        def RECOVER(self):
            return self.getToken(sqlParser.RECOVER, 0)

        def REDUCE(self):
            return self.getToken(sqlParser.REDUCE, 0)

        def REFERENCES(self):
            return self.getToken(sqlParser.REFERENCES, 0)

        def REFRESH(self):
            return self.getToken(sqlParser.REFRESH, 0)

        def RENAME(self):
            return self.getToken(sqlParser.RENAME, 0)

        def REPAIR(self):
            return self.getToken(sqlParser.REPAIR, 0)

        def REPLACE(self):
            return self.getToken(sqlParser.REPLACE, 0)

        def RESET(self):
            return self.getToken(sqlParser.RESET, 0)

        def RESTRICT(self):
            return self.getToken(sqlParser.RESTRICT, 0)

        def REVOKE(self):
            return self.getToken(sqlParser.REVOKE, 0)

        def RLIKE(self):
            return self.getToken(sqlParser.RLIKE, 0)

        def ROLE(self):
            return self.getToken(sqlParser.ROLE, 0)

        def ROLES(self):
            return self.getToken(sqlParser.ROLES, 0)

        def ROLLBACK(self):
            return self.getToken(sqlParser.ROLLBACK, 0)

        def ROLLUP(self):
            return self.getToken(sqlParser.ROLLUP, 0)

        def ROW(self):
            return self.getToken(sqlParser.ROW, 0)

        def ROWS(self):
            return self.getToken(sqlParser.ROWS, 0)

        def SCHEMA(self):
            return self.getToken(sqlParser.SCHEMA, 0)

        def SECOND(self):
            return self.getToken(sqlParser.SECOND, 0)

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

        def SEPARATED(self):
            return self.getToken(sqlParser.SEPARATED, 0)

        def SERDE(self):
            return self.getToken(sqlParser.SERDE, 0)

        def SERDEPROPERTIES(self):
            return self.getToken(sqlParser.SERDEPROPERTIES, 0)

        def SESSION_USER(self):
            return self.getToken(sqlParser.SESSION_USER, 0)

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

        def SETS(self):
            return self.getToken(sqlParser.SETS, 0)

        def SHOW(self):
            return self.getToken(sqlParser.SHOW, 0)

        def SKEWED(self):
            return self.getToken(sqlParser.SKEWED, 0)

        def SOME(self):
            return self.getToken(sqlParser.SOME, 0)

        def SORT(self):
            return self.getToken(sqlParser.SORT, 0)

        def SORTED(self):
            return self.getToken(sqlParser.SORTED, 0)

        def START(self):
            return self.getToken(sqlParser.START, 0)

        def STATISTICS(self):
            return self.getToken(sqlParser.STATISTICS, 0)

        def STORED(self):
            return self.getToken(sqlParser.STORED, 0)

        def STRATIFY(self):
            return self.getToken(sqlParser.STRATIFY, 0)

        def STRUCT(self):
            return self.getToken(sqlParser.STRUCT, 0)

        def SUBSTR(self):
            return self.getToken(sqlParser.SUBSTR, 0)

        def SUBSTRING(self):
            return self.getToken(sqlParser.SUBSTRING, 0)

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

        def TABLES(self):
            return self.getToken(sqlParser.TABLES, 0)

        def TABLESAMPLE(self):
            return self.getToken(sqlParser.TABLESAMPLE, 0)

        def TBLPROPERTIES(self):
            return self.getToken(sqlParser.TBLPROPERTIES, 0)

        def TEMPORARY(self):
            return self.getToken(sqlParser.TEMPORARY, 0)

        def TERMINATED(self):
            return self.getToken(sqlParser.TERMINATED, 0)

        def THEN(self):
            return self.getToken(sqlParser.THEN, 0)

        def TO(self):
            return self.getToken(sqlParser.TO, 0)

        def TOUCH(self):
            return self.getToken(sqlParser.TOUCH, 0)

        def TRAILING(self):
            return self.getToken(sqlParser.TRAILING, 0)

        def TRANSACTION(self):
            return self.getToken(sqlParser.TRANSACTION, 0)

        def TRANSACTIONS(self):
            return self.getToken(sqlParser.TRANSACTIONS, 0)

        def TRANSFORM(self):
            return self.getToken(sqlParser.TRANSFORM, 0)

        def TRIM(self):
            return self.getToken(sqlParser.TRIM, 0)

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

        def TRUNCATE(self):
            return self.getToken(sqlParser.TRUNCATE, 0)

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

        def UNARCHIVE(self):
            return self.getToken(sqlParser.UNARCHIVE, 0)

        def UNBOUNDED(self):
            return self.getToken(sqlParser.UNBOUNDED, 0)

        def UNCACHE(self):
            return self.getToken(sqlParser.UNCACHE, 0)

        def UNIQUE(self):
            return self.getToken(sqlParser.UNIQUE, 0)

        def UNKNOWN(self):
            return self.getToken(sqlParser.UNKNOWN, 0)

        def UNLOCK(self):
            return self.getToken(sqlParser.UNLOCK, 0)

        def UNSET(self):
            return self.getToken(sqlParser.UNSET, 0)

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

        def USE(self):
            return self.getToken(sqlParser.USE, 0)

        def USER(self):
            return self.getToken(sqlParser.USER, 0)

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

        def VIEW(self):
            return self.getToken(sqlParser.VIEW, 0)

        def VIEWS(self):
            return self.getToken(sqlParser.VIEWS, 0)

        def WHEN(self):
            return self.getToken(sqlParser.WHEN, 0)

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

        def WINDOW(self):
            return self.getToken(sqlParser.WINDOW, 0)

        def WITH(self):
            return self.getToken(sqlParser.WITH, 0)

        def YEAR(self):
            return self.getToken(sqlParser.YEAR, 0)

        def getRuleIndex(self):
            return sqlParser.RULE_nonReserved

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




    def nonReserved(self):

        localctx = sqlParser.NonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_nonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2994
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << sqlParser.ADD) | (1 << sqlParser.AFTER) | (1 << sqlParser.ALL) | (1 << sqlParser.ALTER) | (1 << sqlParser.ANALYZE) | (1 << sqlParser.AND) | (1 << sqlParser.ANY) | (1 << sqlParser.ARCHIVE) | (1 << sqlParser.ARRAY) | (1 << sqlParser.AS) | (1 << sqlParser.ASC) | (1 << sqlParser.AT) | (1 << sqlParser.AUTHORIZATION) | (1 << sqlParser.BETWEEN) | (1 << sqlParser.BOTH) | (1 << sqlParser.BUCKET) | (1 << sqlParser.BUCKETS) | (1 << sqlParser.BY) | (1 << sqlParser.CACHE) | (1 << sqlParser.CASCADE) | (1 << sqlParser.CASE) | (1 << sqlParser.CAST) | (1 << sqlParser.CHANGE) | (1 << sqlParser.CHECK) | (1 << sqlParser.CLEAR) | (1 << sqlParser.CLUSTER) | (1 << sqlParser.CLUSTERED) | (1 << sqlParser.CODEGEN) | (1 << sqlParser.COLLATE) | (1 << sqlParser.COLLECTION) | (1 << sqlParser.COLUMN) | (1 << sqlParser.COLUMNS) | (1 << sqlParser.COMMENT) | (1 << sqlParser.COMMIT) | (1 << sqlParser.COMPACT) | (1 << sqlParser.COMPACTIONS) | (1 << sqlParser.COMPUTE) | (1 << sqlParser.CONCATENATE) | (1 << sqlParser.CONSTRAINT) | (1 << sqlParser.COST) | (1 << sqlParser.CREATE) | (1 << sqlParser.CUBE) | (1 << sqlParser.CURRENT) | (1 << sqlParser.CURRENT_DATE) | (1 << sqlParser.CURRENT_TIME) | (1 << sqlParser.CURRENT_TIMESTAMP) | (1 << sqlParser.CURRENT_USER) | (1 << sqlParser.DATA) | (1 << sqlParser.DATABASE) | (1 << sqlParser.DATABASES))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (sqlParser.DAY - 64)) | (1 << (sqlParser.DBPROPERTIES - 64)) | (1 << (sqlParser.DEFINED - 64)) | (1 << (sqlParser.DELETE - 64)) | (1 << (sqlParser.DELIMITED - 64)) | (1 << (sqlParser.DESC - 64)) | (1 << (sqlParser.DESCRIBE - 64)) | (1 << (sqlParser.DFS - 64)) | (1 << (sqlParser.DIRECTORIES - 64)) | (1 << (sqlParser.DIRECTORY - 64)) | (1 << (sqlParser.DISTINCT - 64)) | (1 << (sqlParser.DISTRIBUTE - 64)) | (1 << (sqlParser.DROP - 64)) | (1 << (sqlParser.ELSE - 64)) | (1 << (sqlParser.END - 64)) | (1 << (sqlParser.ESCAPE - 64)) | (1 << (sqlParser.ESCAPED - 64)) | (1 << (sqlParser.EXCHANGE - 64)) | (1 << (sqlParser.EXISTS - 64)) | (1 << (sqlParser.EXPLAIN - 64)) | (1 << (sqlParser.EXPORT - 64)) | (1 << (sqlParser.EXTENDED - 64)) | (1 << (sqlParser.EXTERNAL - 64)) | (1 << (sqlParser.EXTRACT - 64)) | (1 << (sqlParser.FALSE - 64)) | (1 << (sqlParser.FETCH - 64)) | (1 << (sqlParser.FIELDS - 64)) | (1 << (sqlParser.FILTER - 64)) | (1 << (sqlParser.FILEFORMAT - 64)) | (1 << (sqlParser.FIRST - 64)) | (1 << (sqlParser.FOLLOWING - 64)) | (1 << (sqlParser.FOR - 64)) | (1 << (sqlParser.FOREIGN - 64)) | (1 << (sqlParser.FORMAT - 64)) | (1 << (sqlParser.FORMATTED - 64)) | (1 << (sqlParser.FROM - 64)) | (1 << (sqlParser.FUNCTION - 64)) | (1 << (sqlParser.FUNCTIONS - 64)) | (1 << (sqlParser.GLOBAL - 64)) | (1 << (sqlParser.GRANT - 64)) | (1 << (sqlParser.GROUP - 64)) | (1 << (sqlParser.GROUPING - 64)) | (1 << (sqlParser.HAVING - 64)) | (1 << (sqlParser.HOUR - 64)) | (1 << (sqlParser.IF - 64)) | (1 << (sqlParser.IGNORE - 64)) | (1 << (sqlParser.IMPORT - 64)) | (1 << (sqlParser.IN - 64)) | (1 << (sqlParser.INDEX - 64)) | (1 << (sqlParser.INDEXES - 64)) | (1 << (sqlParser.INPATH - 64)) | (1 << (sqlParser.INPUTFORMAT - 64)) | (1 << (sqlParser.INSERT - 64)) | (1 << (sqlParser.INTERVAL - 64)) | (1 << (sqlParser.INTO - 64)) | (1 << (sqlParser.IS - 64)) | (1 << (sqlParser.ITEMS - 64)) | (1 << (sqlParser.KEYS - 64)) | (1 << (sqlParser.LAST - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (sqlParser.LATERAL - 128)) | (1 << (sqlParser.LAZY - 128)) | (1 << (sqlParser.LEADING - 128)) | (1 << (sqlParser.LIKE - 128)) | (1 << (sqlParser.LIMIT - 128)) | (1 << (sqlParser.LINES - 128)) | (1 << (sqlParser.LIST - 128)) | (1 << (sqlParser.LOAD - 128)) | (1 << (sqlParser.LOCAL - 128)) | (1 << (sqlParser.LOCATION - 128)) | (1 << (sqlParser.LOCK - 128)) | (1 << (sqlParser.LOCKS - 128)) | (1 << (sqlParser.LOGICAL - 128)) | (1 << (sqlParser.MACRO - 128)) | (1 << (sqlParser.MAP - 128)) | (1 << (sqlParser.MATCHED - 128)) | (1 << (sqlParser.MERGE - 128)) | (1 << (sqlParser.MINUTE - 128)) | (1 << (sqlParser.MONTH - 128)) | (1 << (sqlParser.MSCK - 128)) | (1 << (sqlParser.NAMESPACE - 128)) | (1 << (sqlParser.NAMESPACES - 128)) | (1 << (sqlParser.NO - 128)) | (1 << (sqlParser.NOT - 128)) | (1 << (sqlParser.NULL - 128)) | (1 << (sqlParser.NULLS - 128)) | (1 << (sqlParser.OF - 128)) | (1 << (sqlParser.ONLY - 128)) | (1 << (sqlParser.OPTION - 128)) | (1 << (sqlParser.OPTIONS - 128)) | (1 << (sqlParser.OR - 128)) | (1 << (sqlParser.ORDER - 128)) | (1 << (sqlParser.OUT - 128)) | (1 << (sqlParser.OUTER - 128)) | (1 << (sqlParser.OUTPUTFORMAT - 128)) | (1 << (sqlParser.OVER - 128)) | (1 << (sqlParser.OVERLAPS - 128)) | (1 << (sqlParser.OVERLAY - 128)) | (1 << (sqlParser.OVERWRITE - 128)) | (1 << (sqlParser.PARTITION - 128)) | (1 << (sqlParser.PARTITIONED - 128)) | (1 << (sqlParser.PARTITIONS - 128)) | (1 << (sqlParser.PERCENTLIT - 128)) | (1 << (sqlParser.PIVOT - 128)) | (1 << (sqlParser.PLACING - 128)) | (1 << (sqlParser.POSITION - 128)) | (1 << (sqlParser.PRECEDING - 128)) | (1 << (sqlParser.PRIMARY - 128)) | (1 << (sqlParser.PRINCIPALS - 128)) | (1 << (sqlParser.PROPERTIES - 128)) | (1 << (sqlParser.PURGE - 128)) | (1 << (sqlParser.QUERY - 128)) | (1 << (sqlParser.RANGE - 128)) | (1 << (sqlParser.RECORDREADER - 128)) | (1 << (sqlParser.RECORDWRITER - 128)) | (1 << (sqlParser.RECOVER - 128)) | (1 << (sqlParser.REDUCE - 128)) | (1 << (sqlParser.REFERENCES - 128)) | (1 << (sqlParser.REFRESH - 128)) | (1 << (sqlParser.RENAME - 128)) | (1 << (sqlParser.REPAIR - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (sqlParser.REPLACE - 192)) | (1 << (sqlParser.RESET - 192)) | (1 << (sqlParser.RESTRICT - 192)) | (1 << (sqlParser.REVOKE - 192)) | (1 << (sqlParser.RLIKE - 192)) | (1 << (sqlParser.ROLE - 192)) | (1 << (sqlParser.ROLES - 192)) | (1 << (sqlParser.ROLLBACK - 192)) | (1 << (sqlParser.ROLLUP - 192)) | (1 << (sqlParser.ROW - 192)) | (1 << (sqlParser.ROWS - 192)) | (1 << (sqlParser.SCHEMA - 192)) | (1 << (sqlParser.SECOND - 192)) | (1 << (sqlParser.SELECT - 192)) | (1 << (sqlParser.SEPARATED - 192)) | (1 << (sqlParser.SERDE - 192)) | (1 << (sqlParser.SERDEPROPERTIES - 192)) | (1 << (sqlParser.SESSION_USER - 192)) | (1 << (sqlParser.SET - 192)) | (1 << (sqlParser.SETS - 192)) | (1 << (sqlParser.SHOW - 192)) | (1 << (sqlParser.SKEWED - 192)) | (1 << (sqlParser.SOME - 192)) | (1 << (sqlParser.SORT - 192)) | (1 << (sqlParser.SORTED - 192)) | (1 << (sqlParser.START - 192)) | (1 << (sqlParser.STATISTICS - 192)) | (1 << (sqlParser.STORED - 192)) | (1 << (sqlParser.STRATIFY - 192)) | (1 << (sqlParser.STRUCT - 192)) | (1 << (sqlParser.SUBSTR - 192)) | (1 << (sqlParser.SUBSTRING - 192)) | (1 << (sqlParser.TABLE - 192)) | (1 << (sqlParser.TABLES - 192)) | (1 << (sqlParser.TABLESAMPLE - 192)) | (1 << (sqlParser.TBLPROPERTIES - 192)) | (1 << (sqlParser.TEMPORARY - 192)) | (1 << (sqlParser.TERMINATED - 192)) | (1 << (sqlParser.THEN - 192)) | (1 << (sqlParser.TO - 192)) | (1 << (sqlParser.TOUCH - 192)) | (1 << (sqlParser.TRAILING - 192)) | (1 << (sqlParser.TRANSACTION - 192)) | (1 << (sqlParser.TRANSACTIONS - 192)) | (1 << (sqlParser.TRANSFORM - 192)) | (1 << (sqlParser.TRIM - 192)) | (1 << (sqlParser.TRUE - 192)) | (1 << (sqlParser.TRUNCATE - 192)) | (1 << (sqlParser.TYPE - 192)) | (1 << (sqlParser.UNARCHIVE - 192)) | (1 << (sqlParser.UNBOUNDED - 192)) | (1 << (sqlParser.UNCACHE - 192)) | (1 << (sqlParser.UNIQUE - 192)) | (1 << (sqlParser.UNKNOWN - 192)) | (1 << (sqlParser.UNLOCK - 192)) | (1 << (sqlParser.UNSET - 192)) | (1 << (sqlParser.UPDATE - 192)) | (1 << (sqlParser.USE - 192)) | (1 << (sqlParser.USER - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (sqlParser.VALUES - 256)) | (1 << (sqlParser.VIEW - 256)) | (1 << (sqlParser.VIEWS - 256)) | (1 << (sqlParser.WHEN - 256)) | (1 << (sqlParser.WHERE - 256)) | (1 << (sqlParser.WINDOW - 256)) | (1 << (sqlParser.WITH - 256)) | (1 << (sqlParser.YEAR - 256)) | (1 << (sqlParser.DIV - 256)))) != 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[40] = self.queryTerm_sempred
        self._predicates[94] = self.booleanExpression_sempred
        self._predicates[96] = self.valueExpression_sempred
        self._predicates[97] = self.primaryExpression_sempred
        self._predicates[129] = self.identifier_sempred
        self._predicates[130] = self.strictIdentifier_sempred
        self._predicates[132] = self.number_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 queryTerm_sempred(self, localctx:QueryTermContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 1:
                return self.legacy_setops_precedence_enbled
         

            if predIndex == 2:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 3:
                return not self.legacy_setops_precedence_enbled
         

            if predIndex == 4:
                return self.precpred(self._ctx, 1)
         

            if predIndex == 5:
                return not self.legacy_setops_precedence_enbled
         

    def booleanExpression_sempred(self, localctx:BooleanExpressionContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 1)
         

    def valueExpression_sempred(self, localctx:ValueExpressionContext, predIndex:int):
            if predIndex == 8:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 1)
         

    def primaryExpression_sempred(self, localctx:PrimaryExpressionContext, predIndex:int):
            if predIndex == 14:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 6)
         

    def identifier_sempred(self, localctx:IdentifierContext, predIndex:int):
            if predIndex == 16:
                return not self.SQL_standard_keyword_behavior
         

    def strictIdentifier_sempred(self, localctx:StrictIdentifierContext, predIndex:int):
            if predIndex == 17:
                return self.SQL_standard_keyword_behavior
         

            if predIndex == 18:
                return not self.SQL_standard_keyword_behavior
         

    def number_sempred(self, localctx:NumberContext, predIndex:int):
            if predIndex == 19:
                return not self.legacy_exponent_literal_as_decimal_enabled
         

            if predIndex == 20:
                return not self.legacy_exponent_literal_as_decimal_enabled
         

            if predIndex == 21:
                return self.legacy_exponent_literal_as_decimal_enabled
         




