# Generated from fugue_sql/_antlr/fugue_sql.g4 by ANTLR 4.9
# 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\u0156")
        buf.write("\u0eed\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\4\u008b")
        buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
        buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
        buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
        buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
        buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
        buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
        buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
        buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
        buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
        buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
        buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
        buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
        buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
        buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
        buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
        buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
        buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
        buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
        buf.write("\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd\t\u00cd")
        buf.write("\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1")
        buf.write("\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4")
        buf.write("\4\u00d5\t\u00d5\4\u00d6\t\u00d6\3\2\6\2\u01ae\n\2\r\2")
        buf.write("\16\2\u01af\3\2\3\2\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3")
        buf.write("\4\5\4\u01bd\n\4\3\5\5\5\u01c0\n\5\3\5\3\5\5\5\u01c4\n")
        buf.write("\5\3\5\5\5\u01c7\n\5\3\5\5\5\u01ca\n\5\3\6\3\6\3\6\3\6")
        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u01da\n\6")
        buf.write("\3\7\3\7\5\7\u01de\n\7\3\7\5\7\u01e1\n\7\3\7\3\7\3\7\5")
        buf.write("\7\u01e6\n\7\3\b\3\b\5\b\u01ea\n\b\3\b\5\b\u01ed\n\b\3")
        buf.write("\b\3\b\3\t\3\t\3\t\3\t\5\t\u01f5\n\t\3\t\5\t\u01f8\n\t")
        buf.write("\3\t\3\t\5\t\u01fc\n\t\3\t\5\t\u01ff\n\t\3\t\3\t\5\t\u0203")
        buf.write("\n\t\3\n\3\n\3\n\3\n\3\n\5\n\u020a\n\n\3\13\3\13\3\13")
        buf.write("\3\13\3\13\5\13\u0211\n\13\3\f\3\f\3\f\3\f\3\f\5\f\u0218")
        buf.write("\n\f\3\f\3\f\5\f\u021c\n\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r")
        buf.write("\5\r\u0225\n\r\3\r\3\r\5\r\u0229\n\r\3\16\3\16\3\16\3")
        buf.write("\16\3\16\5\16\u0230\n\16\3\17\3\17\5\17\u0234\n\17\3\17")
        buf.write("\3\17\3\17\5\17\u0239\n\17\3\17\3\17\5\17\u023d\n\17\3")
        buf.write("\20\3\20\3\20\5\20\u0242\n\20\3\20\3\20\5\20\u0246\n\20")
        buf.write("\3\20\3\20\3\20\5\20\u024b\n\20\3\20\3\20\5\20\u024f\n")
        buf.write("\20\3\21\3\21\3\21\5\21\u0254\n\21\3\21\3\21\5\21\u0258")
        buf.write("\n\21\3\21\3\21\5\21\u025c\n\21\3\22\3\22\3\22\3\23\3")
        buf.write("\23\5\23\u0263\n\23\3\23\3\23\3\23\3\23\3\24\3\24\5\24")
        buf.write("\u026b\n\24\3\24\3\24\5\24\u026f\n\24\3\24\3\24\5\24\u0273")
        buf.write("\n\24\3\25\3\25\5\25\u0277\n\25\3\25\5\25\u027a\n\25\3")
        buf.write("\25\3\25\3\25\5\25\u027f\n\25\3\26\3\26\3\26\3\26\3\26")
        buf.write("\5\26\u0286\n\26\3\26\5\26\u0289\n\26\3\26\3\26\5\26\u028d")
        buf.write("\n\26\3\26\3\26\5\26\u0291\n\26\3\26\5\26\u0294\n\26\3")
        buf.write("\26\3\26\5\26\u0298\n\26\5\26\u029a\n\26\3\27\3\27\5\27")
        buf.write("\u029e\n\27\3\27\5\27\u02a1\n\27\3\27\3\27\5\27\u02a5")
        buf.write("\n\27\3\27\5\27\u02a8\n\27\3\27\3\27\5\27\u02ac\n\27\3")
        buf.write("\30\3\30\5\30\u02b0\n\30\3\30\5\30\u02b3\n\30\3\30\3\30")
        buf.write("\3\30\5\30\u02b8\n\30\3\30\3\30\5\30\u02bc\n\30\3\31\5")
        buf.write("\31\u02bf\n\31\3\31\3\31\5\31\u02c3\n\31\3\31\3\31\3\31")
        buf.write("\5\31\u02c8\n\31\3\32\3\32\3\32\5\32\u02cd\n\32\3\33\3")
        buf.write("\33\3\34\3\34\5\34\u02d3\n\34\3\35\3\35\3\36\3\36\3\37")
        buf.write("\3\37\3 \5 \u02dc\n \3 \3 \3 \5 \u02e1\n \3 \5 \u02e4")
        buf.write("\n \3 \5 \u02e7\n \3 \5 \u02ea\n \3 \3 \5 \u02ee\n \3")
        buf.write(" \5 \u02f1\n \3 \5 \u02f4\n \3 \5 \u02f7\n \3 \3 \3 \5")
        buf.write(" \u02fc\n \3 \5 \u02ff\n \3 \5 \u0302\n \3 \5 \u0305\n")
        buf.write(" \5 \u0307\n \3!\3!\3\"\3\"\3\"\3\"\5\"\u030f\n\"\3#\3")
        buf.write("#\3$\3$\3$\7$\u0316\n$\f$\16$\u0319\13$\3$\3$\3$\7$\u031e")
        buf.write("\n$\f$\16$\u0321\13$\5$\u0323\n$\3%\3%\3%\3%\3&\3&\5&")
        buf.write("\u032b\n&\3&\3&\3&\3&\5&\u0331\n&\3\'\3\'\3\'\5\'\u0336")
        buf.write("\n\'\3\'\3\'\3(\3(\3(\3)\3)\3)\5)\u0340\n)\3*\3*\3*\5")
        buf.write("*\u0345\n*\3*\3*\5*\u0349\n*\3+\3+\3+\5+\u034e\n+\3+\3")
        buf.write("+\5+\u0352\n+\3,\3,\3,\7,\u0357\n,\f,\16,\u035a\13,\3")
        buf.write("-\3-\3-\3-\5-\u0360\n-\3.\3.\3.\3.\3.\3.\3.\3.\5.\u036a")
        buf.write("\n.\3/\5/\u036d\n/\3/\3/\3/\3/\5/\u0373\n/\3/\3/\5/\u0377")
        buf.write("\n/\3/\5/\u037a\n/\3/\3/\3/\3/\3/\5/\u0381\n/\5/\u0383")
        buf.write("\n/\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\5\61\u038d")
        buf.write("\n\61\3\61\3\61\3\61\7\61\u0392\n\61\f\61\16\61\u0395")
        buf.write("\13\61\3\62\5\62\u0398\n\62\3\62\3\62\5\62\u039c\n\62")
        buf.write("\3\62\3\62\3\62\5\62\u03a1\n\62\3\63\3\63\3\63\5\63\u03a6")
        buf.write("\n\63\3\63\5\63\u03a9\n\63\3\64\3\64\3\64\7\64\u03ae\n")
        buf.write("\64\f\64\16\64\u03b1\13\64\3\65\3\65\3\65\7\65\u03b6\n")
        buf.write("\65\f\65\16\65\u03b9\13\65\3\66\3\66\5\66\u03bd\n\66\3")
        buf.write("\67\3\67\38\38\38\78\u03c4\n8\f8\168\u03c7\138\39\39\3")
        buf.write("9\79\u03cc\n9\f9\169\u03cf\139\3:\3:\5:\u03d3\n:\3;\3")
        buf.write(";\3;\7;\u03d8\n;\f;\16;\u03db\13;\3<\3<\3<\3<\3=\3=\3")
        buf.write(">\3>\3>\3>\3>\3>\3>\3>\3>\5>\u03ec\n>\3?\3?\3?\3?\3@\3")
        buf.write("@\3A\3A\3A\5A\u03f7\nA\3A\3A\3A\3A\3A\3A\3A\5A\u0400\n")
        buf.write("A\3A\3A\3A\3A\5A\u0406\nA\3B\3B\3B\7B\u040b\nB\fB\16B")
        buf.write("\u040e\13B\3C\3C\3C\3C\3D\3D\5D\u0416\nD\3E\3E\3E\3E\7")
        buf.write("E\u041c\nE\fE\16E\u041f\13E\3E\5E\u0422\nE\3E\3E\3E\3")
        buf.write("E\5E\u0428\nE\3F\3F\3F\3F\3F\3F\5F\u0430\nF\3G\3G\3H\3")
        buf.write("H\3I\3I\3J\3J\3K\3K\3L\3L\7L\u043e\nL\fL\16L\u0441\13")
        buf.write("L\3L\3L\3M\3M\3M\3N\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3")
        buf.write("R\3R\3R\3S\3S\5S\u0459\nS\3S\3S\3S\5S\u045e\nS\3S\3S\3")
        buf.write("S\3S\3S\3S\5S\u0466\nS\3S\3S\3S\3S\3S\3S\7S\u046e\nS\f")
        buf.write("S\16S\u0471\13S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\3S\3S\3S\5S\u0484\nS\3S\3S\5S\u0488\nS\3S\3S\3S\3")
        buf.write("S\5S\u048e\nS\3S\5S\u0491\nS\3S\5S\u0494\nS\3S\3S\3S\3")
        buf.write("S\3S\5S\u049b\nS\3S\3S\3S\5S\u04a0\nS\3S\5S\u04a3\nS\3")
        buf.write("S\3S\3S\3S\3S\5S\u04aa\nS\3S\3S\3S\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\5S\u04b6\nS\3S\3S\3S\3S\3S\3S\3S\7S\u04bf\nS\fS\16S")
        buf.write("\u04c2\13S\3S\5S\u04c5\nS\3S\5S\u04c8\nS\3S\3S\3S\3S\3")
        buf.write("S\5S\u04cf\nS\3S\3S\3S\3S\3S\3S\3S\3S\3S\7S\u04da\nS\f")
        buf.write("S\16S\u04dd\13S\3S\3S\3S\3S\3S\5S\u04e4\nS\3S\3S\3S\5")
        buf.write("S\u04e9\nS\3S\5S\u04ec\nS\3S\3S\3S\3S\5S\u04f2\nS\3S\3")
        buf.write("S\3S\3S\3S\3S\3S\3S\3S\5S\u04fd\nS\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\5S\u053d\nS\3S\3S\3S\3S\3S\3S\3S\5S\u0546\nS\3S\3")
        buf.write("S\5S\u054a\nS\3S\3S\3S\3S\5S\u0550\nS\3S\3S\5S\u0554\n")
        buf.write("S\3S\3S\3S\5S\u0559\nS\3S\3S\3S\3S\5S\u055f\nS\3S\3S\3")
        buf.write("S\3S\3S\3S\3S\3S\3S\3S\5S\u056b\nS\3S\3S\3S\3S\3S\3S\5")
        buf.write("S\u0573\nS\3S\3S\3S\3S\5S\u0579\nS\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\3S\3S\3S\5S\u0586\nS\3S\6S\u0589\nS\rS\16S\u058a")
        buf.write("\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\5S\u059b\n")
        buf.write("S\3S\3S\3S\7S\u05a0\nS\fS\16S\u05a3\13S\3S\5S\u05a6\n")
        buf.write("S\3S\3S\3S\3S\5S\u05ac\nS\3S\3S\3S\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\3S\3S\5S\u05bb\nS\3S\3S\5S\u05bf\nS\3S\3S\3S\3S\5")
        buf.write("S\u05c5\nS\3S\3S\3S\3S\5S\u05cb\nS\3S\5S\u05ce\nS\3S\5")
        buf.write("S\u05d1\nS\3S\3S\3S\3S\5S\u05d7\nS\3S\3S\5S\u05db\nS\3")
        buf.write("S\3S\3S\3S\3S\3S\7S\u05e3\nS\fS\16S\u05e6\13S\3S\3S\3")
        buf.write("S\3S\3S\3S\5S\u05ee\nS\3S\5S\u05f1\nS\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\5S\u05fa\nS\3S\3S\3S\5S\u05ff\nS\3S\3S\3S\3S\5S\u0605")
        buf.write("\nS\3S\3S\3S\3S\3S\5S\u060c\nS\3S\5S\u060f\nS\3S\3S\3")
        buf.write("S\3S\5S\u0615\nS\3S\3S\3S\3S\3S\3S\3S\7S\u061e\nS\fS\16")
        buf.write("S\u0621\13S\5S\u0623\nS\3S\3S\5S\u0627\nS\3S\3S\3S\5S")
        buf.write("\u062c\nS\3S\3S\3S\5S\u0631\nS\3S\3S\3S\3S\3S\5S\u0638")
        buf.write("\nS\3S\5S\u063b\nS\3S\5S\u063e\nS\3S\3S\3S\3S\3S\5S\u0645")
        buf.write("\nS\3S\3S\3S\5S\u064a\nS\3S\3S\3S\3S\3S\3S\3S\5S\u0653")
        buf.write("\nS\3S\3S\3S\3S\3S\3S\5S\u065b\nS\3S\3S\3S\3S\5S\u0661")
        buf.write("\nS\3S\5S\u0664\nS\3S\5S\u0667\nS\3S\3S\3S\3S\5S\u066d")
        buf.write("\nS\3S\3S\5S\u0671\nS\3S\3S\5S\u0675\nS\3S\3S\5S\u0679")
        buf.write("\nS\5S\u067b\nS\3S\3S\3S\3S\3S\3S\5S\u0683\nS\3S\3S\3")
        buf.write("S\3S\3S\3S\5S\u068b\nS\3S\3S\3S\3S\5S\u0691\nS\3S\3S\3")
        buf.write("S\3S\5S\u0697\nS\3S\5S\u069a\nS\3S\3S\5S\u069e\nS\3S\5")
        buf.write("S\u06a1\nS\3S\3S\5S\u06a5\nS\3S\3S\3S\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\7S\u06bc\nS\fS\16")
        buf.write("S\u06bf\13S\5S\u06c1\nS\3S\3S\5S\u06c5\nS\3S\3S\3S\3S")
        buf.write("\5S\u06cb\nS\3S\5S\u06ce\nS\3S\5S\u06d1\nS\3S\3S\3S\3")
        buf.write("S\5S\u06d7\nS\3S\3S\3S\3S\3S\3S\5S\u06df\nS\3S\3S\3S\5")
        buf.write("S\u06e4\nS\3S\3S\3S\3S\5S\u06ea\nS\3S\3S\3S\3S\5S\u06f0")
        buf.write("\nS\3S\3S\3S\3S\3S\3S\3S\3S\7S\u06fa\nS\fS\16S\u06fd\13")
        buf.write("S\5S\u06ff\nS\3S\3S\3S\7S\u0704\nS\fS\16S\u0707\13S\3")
        buf.write("S\3S\7S\u070b\nS\fS\16S\u070e\13S\3S\3S\3S\7S\u0713\n")
        buf.write("S\fS\16S\u0716\13S\5S\u0718\nS\3T\3T\3T\3T\3T\3T\5T\u0720")
        buf.write("\nT\3T\3T\5T\u0724\nT\3T\3T\3T\3T\3T\5T\u072b\nT\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\5T\u079f\nT\3T\3T\3T\3T\3T\3T\5T\u07a7\n")
        buf.write("T\3T\3T\3T\3T\3T\3T\5T\u07af\nT\3T\3T\3T\3T\3T\3T\3T\5")
        buf.write("T\u07b8\nT\3T\3T\3T\3T\3T\3T\3T\3T\5T\u07c2\nT\3U\3U\5")
        buf.write("U\u07c6\nU\3U\5U\u07c9\nU\3U\3U\3U\3U\5U\u07cf\nU\3U\3")
        buf.write("U\3V\3V\5V\u07d5\nV\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\5W\u07e1")
        buf.write("\nW\3W\3W\3W\3W\3X\3X\3X\3X\3X\3X\5X\u07ed\nX\3X\3X\3")
        buf.write("X\5X\u07f2\nX\3Y\3Y\3Y\3Z\3Z\3Z\3[\5[\u07fb\n[\3[\5[\u07fe")
        buf.write("\n[\3[\3[\3[\3\\\3\\\3\\\5\\\u0806\n\\\3\\\3\\\3\\\3\\")
        buf.write("\3\\\5\\\u080d\n\\\5\\\u080f\n\\\3\\\3\\\3\\\5\\\u0814")
        buf.write("\n\\\3\\\3\\\5\\\u0818\n\\\3\\\3\\\3\\\5\\\u081d\n\\\3")
        buf.write("\\\3\\\3\\\5\\\u0822\n\\\3\\\3\\\3\\\5\\\u0827\n\\\3\\")
        buf.write("\5\\\u082a\n\\\3\\\3\\\3\\\5\\\u082f\n\\\3\\\3\\\5\\\u0833")
        buf.write("\n\\\3\\\3\\\3\\\5\\\u0838\n\\\5\\\u083a\n\\\3]\3]\5]")
        buf.write("\u083e\n]\3^\3^\3^\3^\3^\7^\u0845\n^\f^\16^\u0848\13^")
        buf.write("\3^\3^\3_\3_\3_\5_\u084f\n_\3`\3`\3a\3a\3a\3a\3a\5a\u0858")
        buf.write("\na\3b\3b\3b\7b\u085d\nb\fb\16b\u0860\13b\3c\3c\3c\3c")
        buf.write("\7c\u0866\nc\fc\16c\u0869\13c\3d\3d\5d\u086d\nd\3d\5d")
        buf.write("\u0870\nd\3d\3d\3d\3d\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3")
        buf.write("f\3f\3f\7f\u0883\nf\ff\16f\u0886\13f\3g\3g\3g\3g\7g\u088c")
        buf.write("\ng\fg\16g\u088f\13g\3g\3g\3h\3h\5h\u0895\nh\3h\5h\u0898")
        buf.write("\nh\3i\3i\3i\7i\u089d\ni\fi\16i\u08a0\13i\3i\5i\u08a3")
        buf.write("\ni\3j\3j\3j\3j\5j\u08a9\nj\3k\3k\3k\3k\7k\u08af\nk\f")
        buf.write("k\16k\u08b2\13k\3k\3k\3l\3l\3l\3l\7l\u08ba\nl\fl\16l\u08bd")
        buf.write("\13l\3l\3l\3m\3m\3m\3m\3m\3m\5m\u08c7\nm\3n\3n\3n\3n\3")
        buf.write("n\5n\u08ce\nn\3o\3o\3o\3o\5o\u08d4\no\3p\3p\3p\3q\3q\3")
        buf.write("q\3q\3q\3q\6q\u08df\nq\rq\16q\u08e0\3q\3q\3q\3q\3q\5q")
        buf.write("\u08e8\nq\3q\3q\3q\3q\3q\5q\u08ef\nq\3q\3q\3q\3q\3q\3")
        buf.write("q\3q\3q\3q\3q\5q\u08fb\nq\3q\3q\3q\3q\7q\u0901\nq\fq\16")
        buf.write("q\u0904\13q\3q\7q\u0907\nq\fq\16q\u090a\13q\5q\u090c\n")
        buf.write("q\3r\3r\3r\3r\3r\7r\u0913\nr\fr\16r\u0916\13r\5r\u0918")
        buf.write("\nr\3r\3r\3r\3r\3r\7r\u091f\nr\fr\16r\u0922\13r\5r\u0924")
        buf.write("\nr\3r\3r\3r\3r\3r\7r\u092b\nr\fr\16r\u092e\13r\5r\u0930")
        buf.write("\nr\3r\3r\3r\3r\3r\7r\u0937\nr\fr\16r\u093a\13r\5r\u093c")
        buf.write("\nr\3r\5r\u093f\nr\3r\3r\3r\5r\u0944\nr\5r\u0946\nr\3")
        buf.write("s\3s\3s\3t\3t\3t\5t\u094e\nt\3t\3t\3t\3t\5t\u0954\nt\3")
        buf.write("t\3t\3t\3t\3t\5t\u095b\nt\3t\3t\3t\3t\3t\5t\u0962\nt\3")
        buf.write("t\7t\u0965\nt\ft\16t\u0968\13t\3u\3u\3u\3u\3u\5u\u096f")
        buf.write("\nu\3v\3v\5v\u0973\nv\3v\3v\5v\u0977\nv\3w\3w\6w\u097b")
        buf.write("\nw\rw\16w\u097c\3x\3x\5x\u0981\nx\3x\3x\3x\3x\7x\u0987")
        buf.write("\nx\fx\16x\u098a\13x\3x\5x\u098d\nx\3x\5x\u0990\nx\3x")
        buf.write("\5x\u0993\nx\3x\5x\u0996\nx\3x\3x\5x\u099a\nx\3y\3y\3")
        buf.write("y\5y\u099f\ny\3y\3y\3y\7y\u09a4\ny\fy\16y\u09a7\13y\3")
        buf.write("y\5y\u09aa\ny\3y\5y\u09ad\ny\3y\5y\u09b0\ny\3y\5y\u09b3")
        buf.write("\ny\5y\u09b5\ny\3z\5z\u09b8\nz\3{\3{\3{\3{\3{\3{\3{\3")
        buf.write("{\3{\3{\5{\u09c4\n{\3{\5{\u09c7\n{\3{\3{\5{\u09cb\n{\3")
        buf.write("{\3{\3{\3{\3{\3{\3{\3{\5{\u09d5\n{\3{\3{\5{\u09d9\n{\5")
        buf.write("{\u09db\n{\3{\5{\u09de\n{\3{\3{\5{\u09e2\n{\3|\3|\7|\u09e6")
        buf.write("\n|\f|\16|\u09e9\13|\3|\5|\u09ec\n|\3|\3|\3}\3}\3}\3~")
        buf.write("\3~\3~\3~\5~\u09f7\n~\3~\3~\3~\3\177\3\177\3\177\3\177")
        buf.write("\3\177\5\177\u0a01\n\177\3\177\3\177\3\177\3\u0080\3\u0080")
        buf.write("\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\5\u0080\u0a0d")
        buf.write("\n\u0080\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081")
        buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\7\u0081\u0a1a")
        buf.write("\n\u0081\f\u0081\16\u0081\u0a1d\13\u0081\3\u0081\3\u0081")
        buf.write("\5\u0081\u0a21\n\u0081\3\u0082\3\u0082\3\u0082\7\u0082")
        buf.write("\u0a26\n\u0082\f\u0082\16\u0082\u0a29\13\u0082\3\u0083")
        buf.write("\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084\3\u0085")
        buf.write("\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\5\u0086\u0a38")
        buf.write("\n\u0086\3\u0086\7\u0086\u0a3b\n\u0086\f\u0086\16\u0086")
        buf.write("\u0a3e\13\u0086\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087")
        buf.write("\3\u0087\3\u0087\3\u0087\7\u0087\u0a48\n\u0087\f\u0087")
        buf.write("\16\u0087\u0a4b\13\u0087\3\u0087\3\u0087\5\u0087\u0a4f")
        buf.write("\n\u0087\3\u0088\3\u0088\3\u0088\3\u0088\7\u0088\u0a55")
        buf.write("\n\u0088\f\u0088\16\u0088\u0a58\13\u0088\3\u0088\7\u0088")
        buf.write("\u0a5b\n\u0088\f\u0088\16\u0088\u0a5e\13\u0088\3\u0088")
        buf.write("\5\u0088\u0a61\n\u0088\3\u0089\3\u0089\3\u0089\3\u0089")
        buf.write("\3\u0089\7\u0089\u0a68\n\u0089\f\u0089\16\u0089\u0a6b")
        buf.write("\13\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089")
        buf.write("\3\u0089\3\u0089\3\u0089\3\u0089\7\u0089\u0a77\n\u0089")
        buf.write("\f\u0089\16\u0089\u0a7a\13\u0089\3\u0089\3\u0089\5\u0089")
        buf.write("\u0a7e\n\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089")
        buf.write("\3\u0089\3\u0089\3\u0089\7\u0089\u0a88\n\u0089\f\u0089")
        buf.write("\16\u0089\u0a8b\13\u0089\3\u0089\3\u0089\5\u0089\u0a8f")
        buf.write("\n\u0089\3\u008a\3\u008a\3\u008a\3\u008a\7\u008a\u0a95")
        buf.write("\n\u008a\f\u008a\16\u008a\u0a98\13\u008a\5\u008a\u0a9a")
        buf.write("\n\u008a\3\u008a\3\u008a\5\u008a\u0a9e\n\u008a\3\u008b")
        buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
        buf.write("\3\u008b\3\u008b\7\u008b\u0aaa\n\u008b\f\u008b\16\u008b")
        buf.write("\u0aad\13\u008b\3\u008b\3\u008b\3\u008b\3\u008c\3\u008c")
        buf.write("\3\u008c\3\u008c\3\u008c\7\u008c\u0ab7\n\u008c\f\u008c")
        buf.write("\16\u008c\u0aba\13\u008c\3\u008c\3\u008c\5\u008c\u0abe")
        buf.write("\n\u008c\3\u008d\3\u008d\5\u008d\u0ac2\n\u008d\3\u008d")
        buf.write("\5\u008d\u0ac5\n\u008d\3\u008e\3\u008e\3\u008e\5\u008e")
        buf.write("\u0aca\n\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e")
        buf.write("\7\u008e\u0ad1\n\u008e\f\u008e\16\u008e\u0ad4\13\u008e")
        buf.write("\5\u008e\u0ad6\n\u008e\3\u008e\3\u008e\3\u008e\5\u008e")
        buf.write("\u0adb\n\u008e\3\u008e\3\u008e\3\u008e\7\u008e\u0ae0\n")
        buf.write("\u008e\f\u008e\16\u008e\u0ae3\13\u008e\5\u008e\u0ae5\n")
        buf.write("\u008e\3\u008f\3\u008f\3\u0090\3\u0090\7\u0090\u0aeb\n")
        buf.write("\u0090\f\u0090\16\u0090\u0aee\13\u0090\3\u0091\3\u0091")
        buf.write("\3\u0091\3\u0091\5\u0091\u0af4\n\u0091\3\u0091\3\u0091")
        buf.write("\3\u0091\3\u0091\3\u0091\5\u0091\u0afb\n\u0091\3\u0092")
        buf.write("\5\u0092\u0afe\n\u0092\3\u0092\3\u0092\3\u0092\5\u0092")
        buf.write("\u0b03\n\u0092\3\u0092\5\u0092\u0b06\n\u0092\3\u0092\3")
        buf.write("\u0092\3\u0092\5\u0092\u0b0b\n\u0092\3\u0092\3\u0092\5")
        buf.write("\u0092\u0b0f\n\u0092\3\u0092\5\u0092\u0b12\n\u0092\3\u0092")
        buf.write("\5\u0092\u0b15\n\u0092\3\u0093\3\u0093\3\u0093\3\u0093")
        buf.write("\5\u0093\u0b1b\n\u0093\3\u0094\3\u0094\3\u0094\5\u0094")
        buf.write("\u0b20\n\u0094\3\u0094\3\u0094\3\u0095\5\u0095\u0b25\n")
        buf.write("\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095")
        buf.write("\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095")
        buf.write("\3\u0095\3\u0095\3\u0095\5\u0095\u0b37\n\u0095\5\u0095")
        buf.write("\u0b39\n\u0095\3\u0095\5\u0095\u0b3c\n\u0095\3\u0096\3")
        buf.write("\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097\7\u0097")
        buf.write("\u0b45\n\u0097\f\u0097\16\u0097\u0b48\13\u0097\3\u0098")
        buf.write("\3\u0098\3\u0098\3\u0098\7\u0098\u0b4e\n\u0098\f\u0098")
        buf.write("\16\u0098\u0b51\13\u0098\3\u0098\3\u0098\3\u0099\3\u0099")
        buf.write("\5\u0099\u0b57\n\u0099\3\u009a\3\u009a\3\u009a\3\u009a")
        buf.write("\7\u009a\u0b5d\n\u009a\f\u009a\16\u009a\u0b60\13\u009a")
        buf.write("\3\u009a\3\u009a\3\u009b\3\u009b\5\u009b\u0b66\n\u009b")
        buf.write("\3\u009c\3\u009c\5\u009c\u0b6a\n\u009c\3\u009c\5\u009c")
        buf.write("\u0b6d\n\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c")
        buf.write("\3\u009c\5\u009c\u0b75\n\u009c\3\u009c\3\u009c\3\u009c")
        buf.write("\3\u009c\3\u009c\3\u009c\5\u009c\u0b7d\n\u009c\3\u009c")
        buf.write("\3\u009c\3\u009c\3\u009c\5\u009c\u0b83\n\u009c\3\u009d")
        buf.write("\3\u009d\3\u009d\3\u009d\7\u009d\u0b89\n\u009d\f\u009d")
        buf.write("\16\u009d\u0b8c\13\u009d\3\u009d\3\u009d\3\u009e\3\u009e")
        buf.write("\3\u009e\3\u009e\3\u009e\7\u009e\u0b95\n\u009e\f\u009e")
        buf.write("\16\u009e\u0b98\13\u009e\5\u009e\u0b9a\n\u009e\3\u009e")
        buf.write("\3\u009e\3\u009e\3\u009f\5\u009f\u0ba0\n\u009f\3\u009f")
        buf.write("\3\u009f\5\u009f\u0ba4\n\u009f\5\u009f\u0ba6\n\u009f\3")
        buf.write("\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0")
        buf.write("\5\u00a0\u0baf\n\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0")
        buf.write("\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0")
        buf.write("\u0bbb\n\u00a0\5\u00a0\u0bbd\n\u00a0\3\u00a0\3\u00a0\3")
        buf.write("\u00a0\3\u00a0\3\u00a0\5\u00a0\u0bc4\n\u00a0\3\u00a0\3")
        buf.write("\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u0bcb\n\u00a0\3")
        buf.write("\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u0bd1\n\u00a0\3")
        buf.write("\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u0bd7\n\u00a0\5")
        buf.write("\u00a0\u0bd9\n\u00a0\3\u00a1\3\u00a1\3\u00a1\7\u00a1\u0bde")
        buf.write("\n\u00a1\f\u00a1\16\u00a1\u0be1\13\u00a1\3\u00a2\3\u00a2")
        buf.write("\3\u00a2\7\u00a2\u0be6\n\u00a2\f\u00a2\16\u00a2\u0be9")
        buf.write("\13\u00a2\3\u00a3\3\u00a3\3\u00a3\5\u00a3\u0bee\n\u00a3")
        buf.write("\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\5\u00a4\u0bf5")
        buf.write("\n\u00a4\3\u00a4\3\u00a4\3\u00a5\3\u00a5\5\u00a5\u0bfb")
        buf.write("\n\u00a5\3\u00a5\3\u00a5\5\u00a5\u0bff\n\u00a5\5\u00a5")
        buf.write("\u0c01\n\u00a5\3\u00a6\3\u00a6\3\u00a6\7\u00a6\u0c06\n")
        buf.write("\u00a6\f\u00a6\16\u00a6\u0c09\13\u00a6\3\u00a7\3\u00a7")
        buf.write("\3\u00a7\3\u00a7\7\u00a7\u0c0f\n\u00a7\f\u00a7\16\u00a7")
        buf.write("\u0c12\13\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8")
        buf.write("\3\u00a8\3\u00a8\3\u00a8\7\u00a8\u0c1c\n\u00a8\f\u00a8")
        buf.write("\16\u00a8\u0c1f\13\u00a8\3\u00a8\3\u00a8\5\u00a8\u0c23")
        buf.write("\n\u00a8\3\u00a9\3\u00a9\5\u00a9\u0c27\n\u00a9\3\u00aa")
        buf.write("\3\u00aa\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab")
        buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0c35\n\u00ab")
        buf.write("\5\u00ab\u0c37\n\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab")
        buf.write("\3\u00ab\3\u00ab\7\u00ab\u0c3f\n\u00ab\f\u00ab\16\u00ab")
        buf.write("\u0c42\13\u00ab\3\u00ac\5\u00ac\u0c45\n\u00ac\3\u00ac")
        buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\5\u00ac\u0c4d")
        buf.write("\n\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\7\u00ac")
        buf.write("\u0c54\n\u00ac\f\u00ac\16\u00ac\u0c57\13\u00ac\3\u00ac")
        buf.write("\3\u00ac\3\u00ac\5\u00ac\u0c5c\n\u00ac\3\u00ac\3\u00ac")
        buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\5\u00ac\u0c64\n\u00ac")
        buf.write("\3\u00ac\3\u00ac\3\u00ac\5\u00ac\u0c69\n\u00ac\3\u00ac")
        buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac")
        buf.write("\7\u00ac\u0c73\n\u00ac\f\u00ac\16\u00ac\u0c76\13\u00ac")
        buf.write("\3\u00ac\3\u00ac\5\u00ac\u0c7a\n\u00ac\3\u00ac\5\u00ac")
        buf.write("\u0c7d\n\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\5\u00ac")
        buf.write("\u0c83\n\u00ac\3\u00ac\3\u00ac\5\u00ac\u0c87\n\u00ac\3")
        buf.write("\u00ac\3\u00ac\3\u00ac\5\u00ac\u0c8c\n\u00ac\3\u00ac\3")
        buf.write("\u00ac\3\u00ac\5\u00ac\u0c91\n\u00ac\3\u00ac\3\u00ac\3")
        buf.write("\u00ac\5\u00ac\u0c96\n\u00ac\3\u00ad\3\u00ad\3\u00ad\3")
        buf.write("\u00ad\5\u00ad\u0c9c\n\u00ad\3\u00ad\3\u00ad\3\u00ad\3")
        buf.write("\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad")
        buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad")
        buf.write("\3\u00ad\3\u00ad\7\u00ad\u0cb1\n\u00ad\f\u00ad\16\u00ad")
        buf.write("\u0cb4\13\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae\6\u00ae")
        buf.write("\u0cba\n\u00ae\r\u00ae\16\u00ae\u0cbb\3\u00ae\3\u00ae")
        buf.write("\5\u00ae\u0cc0\n\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\6\u00ae\u0cc7\n\u00ae\r\u00ae\16\u00ae\u0cc8")
        buf.write("\3\u00ae\3\u00ae\5\u00ae\u0ccd\n\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\7\u00ae\u0cdd")
        buf.write("\n\u00ae\f\u00ae\16\u00ae\u0ce0\13\u00ae\5\u00ae\u0ce2")
        buf.write("\n\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\5\u00ae\u0cea\n\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u0cf3\n\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\6\u00ae\u0d08\n\u00ae")
        buf.write("\r\u00ae\16\u00ae\u0d09\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u0d15")
        buf.write("\n\u00ae\3\u00ae\3\u00ae\3\u00ae\7\u00ae\u0d1a\n\u00ae")
        buf.write("\f\u00ae\16\u00ae\u0d1d\13\u00ae\5\u00ae\u0d1f\n\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\5\u00ae\u0d28\n\u00ae\3\u00ae\3\u00ae\5\u00ae\u0d2c\n")
        buf.write("\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\6\u00ae\u0d36\n\u00ae\r\u00ae\16\u00ae")
        buf.write("\u0d37\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u0d51\n\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u0d58\n\u00ae")
        buf.write("\3\u00ae\5\u00ae\u0d5b\n\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u0d6a\n\u00ae\3\u00ae")
        buf.write("\3\u00ae\5\u00ae\u0d6e\n\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\7\u00ae\u0d78")
        buf.write("\n\u00ae\f\u00ae\16\u00ae\u0d7b\13\u00ae\3\u00af\3\u00af")
        buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\6\u00af")
        buf.write("\u0d85\n\u00af\r\u00af\16\u00af\u0d86\5\u00af\u0d89\n")
        buf.write("\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0")
        buf.write("\3\u00b0\3\u00b0\5\u00b0\u0d93\n\u00b0\3\u00b1\3\u00b1")
        buf.write("\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b4\3\u00b4\3\u00b5")
        buf.write("\3\u00b5\3\u00b5\5\u00b5\u0da0\n\u00b5\3\u00b6\3\u00b6")
        buf.write("\5\u00b6\u0da4\n\u00b6\3\u00b7\3\u00b7\3\u00b7\6\u00b7")
        buf.write("\u0da9\n\u00b7\r\u00b7\16\u00b7\u0daa\3\u00b8\3\u00b8")
        buf.write("\3\u00b8\5\u00b8\u0db0\n\u00b8\3\u00b9\3\u00b9\3\u00b9")
        buf.write("\3\u00b9\3\u00b9\3\u00ba\5\u00ba\u0db8\n\u00ba\3\u00ba")
        buf.write("\3\u00ba\5\u00ba\u0dbc\n\u00ba\3\u00bb\3\u00bb\3\u00bb")
        buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb\u0dc5\n\u00bb")
        buf.write("\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u0dca\n\u00bc\3\u00bd")
        buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd")
        buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd")
        buf.write("\5\u00bd\u0ddb\n\u00bd\3\u00bd\3\u00bd\5\u00bd\u0ddf\n")
        buf.write("\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\7\u00bd")
        buf.write("\u0de6\n\u00bd\f\u00bd\16\u00bd\u0de9\13\u00bd\3\u00bd")
        buf.write("\5\u00bd\u0dec\n\u00bd\5\u00bd\u0dee\n\u00bd\3\u00be\3")
        buf.write("\u00be\3\u00be\7\u00be\u0df3\n\u00be\f\u00be\16\u00be")
        buf.write("\u0df6\13\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\5\u00bf")
        buf.write("\u0dfc\n\u00bf\3\u00bf\5\u00bf\u0dff\n\u00bf\3\u00bf\5")
        buf.write("\u00bf\u0e02\n\u00bf\3\u00c0\3\u00c0\3\u00c0\7\u00c0\u0e07")
        buf.write("\n\u00c0\f\u00c0\16\u00c0\u0e0a\13\u00c0\3\u00c1\3\u00c1")
        buf.write("\3\u00c1\3\u00c1\5\u00c1\u0e10\n\u00c1\3\u00c1\5\u00c1")
        buf.write("\u0e13\n\u00c1\3\u00c2\3\u00c2\3\u00c2\7\u00c2\u0e18\n")
        buf.write("\u00c2\f\u00c2\16\u00c2\u0e1b\13\u00c2\3\u00c3\3\u00c3")
        buf.write("\3\u00c3\3\u00c3\3\u00c3\5\u00c3\u0e22\n\u00c3\3\u00c3")
        buf.write("\5\u00c3\u0e25\n\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
        buf.write("\3\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5\7\u00c5\u0e30")
        buf.write("\n\u00c5\f\u00c5\16\u00c5\u0e33\13\u00c5\3\u00c6\3\u00c6")
        buf.write("\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
        buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\7\u00c7")
        buf.write("\u0e44\n\u00c7\f\u00c7\16\u00c7\u0e47\13\u00c7\3\u00c7")
        buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\7\u00c7\u0e4e\n\u00c7")
        buf.write("\f\u00c7\16\u00c7\u0e51\13\u00c7\5\u00c7\u0e53\n\u00c7")
        buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\7\u00c7\u0e5a")
        buf.write("\n\u00c7\f\u00c7\16\u00c7\u0e5d\13\u00c7\5\u00c7\u0e5f")
        buf.write("\n\u00c7\5\u00c7\u0e61\n\u00c7\3\u00c7\5\u00c7\u0e64\n")
        buf.write("\u00c7\3\u00c7\5\u00c7\u0e67\n\u00c7\3\u00c8\3\u00c8\3")
        buf.write("\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8")
        buf.write("\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8")
        buf.write("\5\u00c8\u0e79\n\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9")
        buf.write("\3\u00c9\3\u00c9\3\u00c9\5\u00c9\u0e82\n\u00c9\3\u00ca")
        buf.write("\3\u00ca\3\u00ca\7\u00ca\u0e87\n\u00ca\f\u00ca\16\u00ca")
        buf.write("\u0e8a\13\u00ca\3\u00cb\3\u00cb\3\u00cb\3\u00cb\5\u00cb")
        buf.write("\u0e90\n\u00cb\3\u00cc\3\u00cc\3\u00cc\7\u00cc\u0e95\n")
        buf.write("\u00cc\f\u00cc\16\u00cc\u0e98\13\u00cc\3\u00cd\3\u00cd")
        buf.write("\3\u00cd\3\u00ce\3\u00ce\6\u00ce\u0e9f\n\u00ce\r\u00ce")
        buf.write("\16\u00ce\u0ea0\3\u00ce\5\u00ce\u0ea4\n\u00ce\3\u00cf")
        buf.write("\3\u00cf\3\u00cf\5\u00cf\u0ea9\n\u00cf\3\u00d0\3\u00d0")
        buf.write("\3\u00d0\3\u00d0\3\u00d0\3\u00d0\5\u00d0\u0eb1\n\u00d0")
        buf.write("\3\u00d1\3\u00d1\3\u00d2\3\u00d2\5\u00d2\u0eb7\n\u00d2")
        buf.write("\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u0ebc\n\u00d2\3\u00d2")
        buf.write("\3\u00d2\3\u00d2\5\u00d2\u0ec1\n\u00d2\3\u00d2\3\u00d2")
        buf.write("\5\u00d2\u0ec5\n\u00d2\3\u00d2\3\u00d2\5\u00d2\u0ec9\n")
        buf.write("\u00d2\3\u00d2\3\u00d2\5\u00d2\u0ecd\n\u00d2\3\u00d2\3")
        buf.write("\u00d2\5\u00d2\u0ed1\n\u00d2\3\u00d2\3\u00d2\5\u00d2\u0ed5")
        buf.write("\n\u00d2\3\u00d2\3\u00d2\5\u00d2\u0ed9\n\u00d2\3\u00d2")
        buf.write("\5\u00d2\u0edc\n\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3")
        buf.write("\3\u00d3\3\u00d3\3\u00d3\5\u00d3\u0ee5\n\u00d3\3\u00d4")
        buf.write("\3\u00d4\3\u00d5\3\u00d5\3\u00d6\3\u00d6\3\u00d6\7\u06bd")
        buf.write("\u06fb\u0705\u070c\u0714\7`\u00e6\u0154\u0158\u015a\u00d7")
        buf.write("\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62")
        buf.write("\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082")
        buf.write("\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094")
        buf.write("\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6")
        buf.write("\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8")
        buf.write("\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca")
        buf.write("\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc")
        buf.write("\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee")
        buf.write("\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100")
        buf.write("\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112")
        buf.write("\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124")
        buf.write("\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136")
        buf.write("\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148")
        buf.write("\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a")
        buf.write("\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c")
        buf.write("\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e")
        buf.write("\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190")
        buf.write("\u0192\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2")
        buf.write("\u01a4\u01a6\u01a8\u01aa\2\67\4\2::??\3\2\u00c6\u00c7")
        buf.write("\3\2\u00f6\u00f7\4\2\u008a\u008a\u00ab\u00ab\5\2&&\u00d5")
        buf.write("\u00d5\u0116\u0116\3\2\')\3\2\66\67\4\2\4\4\u0134\u0134")
        buf.write("\4\2\u014c\u014c\u014e\u014e\3\2\25\27\3\2\u013d\u0140")
        buf.write("\4\2CCqq\5\2\f\r\u0085\u0085\u011d\u011d\4\2\16\16\u00c6")
        buf.write("\u00c6\4\2mm\u00e0\u00e0\4\2LL\u00ee\u00ee\4\2kk\u00c2")
        buf.write("\u00c2\4\2\u0090\u0090\u009d\u009d\3\2WX\4\2\u010f\u010f")
        buf.write("\u012d\u012d\4\2;;OO\7\2TT``\u0082\u0082\u008f\u008f\u00b9")
        buf.write("\u00b9\3\2qr\4\2\u0082\u0082\u008f\u008f\4\2\u00c6\u00c6")
        buf.write("\u0148\u0148\4\288\u00b3\u00b3\5\2jj\u00c1\u00c1\u00f8")
        buf.write("\u00f8\6\2}}\u00a4\u00a4\u0101\u0101\u0123\u0123\5\2}")
        buf.write("}\u0101\u0101\u0123\u0123\4\2::vv\5\2::??\u0105\u0105")
        buf.write("\5\2\u0085\u0085\u011d\u011d\u0125\u0125\4\2\u013d\u013e")
        buf.write("\u0143\u0143\3\2\u013f\u0142\4\2\u013d\u013e\u0146\u0146")
        buf.write("\4\2eegg\3\2\u010d\u010e\4\2\3\3\u0090\u0090\4\2\3\3\u008c")
        buf.write("\u008c\5\2GG\u00ae\u00ae\u0118\u0118\3\2\u0134\u0135\3")
        buf.write("\2\u013d\u0147\6\2==\u009d\u009d\u00c5\u00c5\u00cd\u00cd")
        buf.write("\4\2\u0085\u0085\u011d\u011d\3\2\u013d\u013e\4\2ww\u00d6")
        buf.write("\u00d6\4\2\u00ce\u00ce\u0106\u0106\4\2\u008b\u008b\u00dd")
        buf.write("\u00dd\3\2\u014d\u014e\4\2xx\u0100\u0100\65\289;<@ACD")
        buf.write("FFHLOOQTVVX^``cdikmuwx||~\u0084\u0087\u0087\u0089\u008b")
        buf.write("\u008e\u008f\u0092\u0094\u0097\u0097\u009a\u009c\u009e")
        buf.write("\u009f\u00a1\u00a3\u00a5\u00a5\u00a8\u00a8\u00aa\u00ad")
        buf.write("\u00b0\u00bd\u00c0\u00c2\u00c4\u00c4\u00c7\u00c8\u00cb")
        buf.write("\u00cc\u00cf\u00cf\u00d1\u00d2\u00d4\u00dd\u00df\u00e7")
        buf.write("\u00e9\u00ef\u00f1\u00f8\u00fc\u00fe\u0100\u0100\u0102")
        buf.write("\u0104\u0106\u010e\u0110\u0114\u0117\u0117\u0119\u011e")
        buf.write("\u0120\u0122\u0126\u0129\u012c\u012e\u0131\u0131\u0142")
        buf.write("\u0142\21\2>>bb}}\u0091\u0091\u00a0\u00a0\u00a4\u00a4")
        buf.write("\u00a9\u00a9\u00af\u00af\u00c3\u00c3\u00c9\u00c9\u00f0")
        buf.write("\u00f0\u00fb\u00fb\u0101\u0101\u0123\u0123\u012b\u012b")
        buf.write("\23\28=?ac|~\u0090\u0092\u009f\u00a1\u00a3\u00a5\u00a8")
        buf.write("\u00aa\u00ae\u00b0\u00c2\u00c4\u00c8\u00ca\u00ef\u00f1")
        buf.write("\u00fa\u00fc\u0100\u0102\u0122\u0124\u012a\u012c\u0133")
        buf.write("\u0142\u0142\2\u1113\2\u01ad\3\2\2\2\4\u01b3\3\2\2\2\6")
        buf.write("\u01bc\3\2\2\2\b\u01bf\3\2\2\2\n\u01d9\3\2\2\2\f\u01db")
        buf.write("\3\2\2\2\16\u01e7\3\2\2\2\20\u01f0\3\2\2\2\22\u0204\3")
        buf.write("\2\2\2\24\u020b\3\2\2\2\26\u0212\3\2\2\2\30\u021d\3\2")
        buf.write("\2\2\32\u022a\3\2\2\2\34\u0231\3\2\2\2\36\u023e\3\2\2")
        buf.write("\2 \u0250\3\2\2\2\"\u025d\3\2\2\2$\u0260\3\2\2\2&\u0268")
        buf.write("\3\2\2\2(\u0274\3\2\2\2*\u0299\3\2\2\2,\u029b\3\2\2\2")
        buf.write(".\u02ad\3\2\2\2\60\u02be\3\2\2\2\62\u02c9\3\2\2\2\64\u02ce")
        buf.write("\3\2\2\2\66\u02d2\3\2\2\28\u02d4\3\2\2\2:\u02d6\3\2\2")
        buf.write("\2<\u02d8\3\2\2\2>\u0306\3\2\2\2@\u0308\3\2\2\2B\u030a")
        buf.write("\3\2\2\2D\u0310\3\2\2\2F\u0322\3\2\2\2H\u0324\3\2\2\2")
        buf.write("J\u0330\3\2\2\2L\u0332\3\2\2\2N\u0339\3\2\2\2P\u033f\3")
        buf.write("\2\2\2R\u0341\3\2\2\2T\u034a\3\2\2\2V\u0353\3\2\2\2X\u035f")
        buf.write("\3\2\2\2Z\u0369\3\2\2\2\\\u0382\3\2\2\2^\u0384\3\2\2\2")
        buf.write("`\u038c\3\2\2\2b\u03a0\3\2\2\2d\u03a8\3\2\2\2f\u03aa\3")
        buf.write("\2\2\2h\u03b2\3\2\2\2j\u03ba\3\2\2\2l\u03be\3\2\2\2n\u03c0")
        buf.write("\3\2\2\2p\u03c8\3\2\2\2r\u03d2\3\2\2\2t\u03d4\3\2\2\2")
        buf.write("v\u03dc\3\2\2\2x\u03e0\3\2\2\2z\u03eb\3\2\2\2|\u03ed\3")
        buf.write("\2\2\2~\u03f1\3\2\2\2\u0080\u0405\3\2\2\2\u0082\u0407")
        buf.write("\3\2\2\2\u0084\u040f\3\2\2\2\u0086\u0415\3\2\2\2\u0088")
        buf.write("\u0427\3\2\2\2\u008a\u042f\3\2\2\2\u008c\u0431\3\2\2\2")
        buf.write("\u008e\u0433\3\2\2\2\u0090\u0435\3\2\2\2\u0092\u0437\3")
        buf.write("\2\2\2\u0094\u0439\3\2\2\2\u0096\u043b\3\2\2\2\u0098\u0444")
        buf.write("\3\2\2\2\u009a\u0447\3\2\2\2\u009c\u044a\3\2\2\2\u009e")
        buf.write("\u044d\3\2\2\2\u00a0\u0450\3\2\2\2\u00a2\u0453\3\2\2\2")
        buf.write("\u00a4\u0717\3\2\2\2\u00a6\u07c1\3\2\2\2\u00a8\u07c3\3")
        buf.write("\2\2\2\u00aa\u07d4\3\2\2\2\u00ac\u07da\3\2\2\2\u00ae\u07e6")
        buf.write("\3\2\2\2\u00b0\u07f3\3\2\2\2\u00b2\u07f6\3\2\2\2\u00b4")
        buf.write("\u07fa\3\2\2\2\u00b6\u0839\3\2\2\2\u00b8\u083b\3\2\2\2")
        buf.write("\u00ba\u083f\3\2\2\2\u00bc\u084b\3\2\2\2\u00be\u0850\3")
        buf.write("\2\2\2\u00c0\u0857\3\2\2\2\u00c2\u0859\3\2\2\2\u00c4\u0861")
        buf.write("\3\2\2\2\u00c6\u086a\3\2\2\2\u00c8\u0875\3\2\2\2\u00ca")
        buf.write("\u0884\3\2\2\2\u00cc\u0887\3\2\2\2\u00ce\u0892\3\2\2\2")
        buf.write("\u00d0\u08a2\3\2\2\2\u00d2\u08a8\3\2\2\2\u00d4\u08aa\3")
        buf.write("\2\2\2\u00d6\u08b5\3\2\2\2\u00d8\u08c6\3\2\2\2\u00da\u08cd")
        buf.write("\3\2\2\2\u00dc\u08cf\3\2\2\2\u00de\u08d5\3\2\2\2\u00e0")
        buf.write("\u090b\3\2\2\2\u00e2\u0917\3\2\2\2\u00e4\u0947\3\2\2\2")
        buf.write("\u00e6\u094d\3\2\2\2\u00e8\u096e\3\2\2\2\u00ea\u0970\3")
        buf.write("\2\2\2\u00ec\u0978\3\2\2\2\u00ee\u0999\3\2\2\2\u00f0\u09b4")
        buf.write("\3\2\2\2\u00f2\u09b7\3\2\2\2\u00f4\u09c3\3\2\2\2\u00f6")
        buf.write("\u09e3\3\2\2\2\u00f8\u09ef\3\2\2\2\u00fa\u09f2\3\2\2\2")
        buf.write("\u00fc\u09fb\3\2\2\2\u00fe\u0a0c\3\2\2\2\u0100\u0a20\3")
        buf.write("\2\2\2\u0102\u0a22\3\2\2\2\u0104\u0a2a\3\2\2\2\u0106\u0a2e")
        buf.write("\3\2\2\2\u0108\u0a31\3\2\2\2\u010a\u0a34\3\2\2\2\u010c")
        buf.write("\u0a4e\3\2\2\2\u010e\u0a50\3\2\2\2\u0110\u0a8e\3\2\2\2")
        buf.write("\u0112\u0a9d\3\2\2\2\u0114\u0a9f\3\2\2\2\u0116\u0abd\3")
        buf.write("\2\2\2\u0118\u0abf\3\2\2\2\u011a\u0ac6\3\2\2\2\u011c\u0ae6")
        buf.write("\3\2\2\2\u011e\u0ae8\3\2\2\2\u0120\u0afa\3\2\2\2\u0122")
        buf.write("\u0b14\3\2\2\2\u0124\u0b1a\3\2\2\2\u0126\u0b1c\3\2\2\2")
        buf.write("\u0128\u0b3b\3\2\2\2\u012a\u0b3d\3\2\2\2\u012c\u0b41\3")
        buf.write("\2\2\2\u012e\u0b49\3\2\2\2\u0130\u0b54\3\2\2\2\u0132\u0b58")
        buf.write("\3\2\2\2\u0134\u0b63\3\2\2\2\u0136\u0b82\3\2\2\2\u0138")
        buf.write("\u0b84\3\2\2\2\u013a\u0b8f\3\2\2\2\u013c\u0ba5\3\2\2\2")
        buf.write("\u013e\u0bd8\3\2\2\2\u0140\u0bda\3\2\2\2\u0142\u0be2\3")
        buf.write("\2\2\2\u0144\u0bed\3\2\2\2\u0146\u0bf4\3\2\2\2\u0148\u0bf8")
        buf.write("\3\2\2\2\u014a\u0c02\3\2\2\2\u014c\u0c0a\3\2\2\2\u014e")
        buf.write("\u0c22\3\2\2\2\u0150\u0c26\3\2\2\2\u0152\u0c28\3\2\2\2")
        buf.write("\u0154\u0c36\3\2\2\2\u0156\u0c95\3\2\2\2\u0158\u0c9b\3")
        buf.write("\2\2\2\u015a\u0d6d\3\2\2\2\u015c\u0d88\3\2\2\2\u015e\u0d92")
        buf.write("\3\2\2\2\u0160\u0d94\3\2\2\2\u0162\u0d96\3\2\2\2\u0164")
        buf.write("\u0d98\3\2\2\2\u0166\u0d9a\3\2\2\2\u0168\u0d9c\3\2\2\2")
        buf.write("\u016a\u0da1\3\2\2\2\u016c\u0da8\3\2\2\2\u016e\u0dac\3")
        buf.write("\2\2\2\u0170\u0db1\3\2\2\2\u0172\u0dbb\3\2\2\2\u0174\u0dc4")
        buf.write("\3\2\2\2\u0176\u0dc9\3\2\2\2\u0178\u0ded\3\2\2\2\u017a")
        buf.write("\u0def\3\2\2\2\u017c\u0df7\3\2\2\2\u017e\u0e03\3\2\2\2")
        buf.write("\u0180\u0e0b\3\2\2\2\u0182\u0e14\3\2\2\2\u0184\u0e1c\3")
        buf.write("\2\2\2\u0186\u0e26\3\2\2\2\u0188\u0e2b\3\2\2\2\u018a\u0e34")
        buf.write("\3\2\2\2\u018c\u0e66\3\2\2\2\u018e\u0e78\3\2\2\2\u0190")
        buf.write("\u0e81\3\2\2\2\u0192\u0e83\3\2\2\2\u0194\u0e8f\3\2\2\2")
        buf.write("\u0196\u0e91\3\2\2\2\u0198\u0e99\3\2\2\2\u019a\u0ea3\3")
        buf.write("\2\2\2\u019c\u0ea8\3\2\2\2\u019e\u0eb0\3\2\2\2\u01a0\u0eb2")
        buf.write("\3\2\2\2\u01a2\u0edb\3\2\2\2\u01a4\u0ee4\3\2\2\2\u01a6")
        buf.write("\u0ee6\3\2\2\2\u01a8\u0ee8\3\2\2\2\u01aa\u0eea\3\2\2\2")
        buf.write("\u01ac\u01ae\5\6\4\2\u01ad\u01ac\3\2\2\2\u01ae\u01af\3")
        buf.write("\2\2\2\u01af\u01ad\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b1")
        buf.write("\3\2\2\2\u01b1\u01b2\7\2\2\3\u01b2\3\3\2\2\2\u01b3\u01b4")
        buf.write("\5\6\4\2\u01b4\u01b5\7\2\2\3\u01b5\5\3\2\2\2\u01b6\u01bd")
        buf.write("\5\b\5\2\u01b7\u01bd\5.\30\2\u01b8\u01bd\5(\25\2\u01b9")
        buf.write("\u01bd\5*\26\2\u01ba\u01bd\5,\27\2\u01bb\u01bd\5\60\31")
        buf.write("\2\u01bc\u01b6\3\2\2\2\u01bc\u01b7\3\2\2\2\u01bc\u01b8")
        buf.write("\3\2\2\2\u01bc\u01b9\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc")
        buf.write("\u01bb\3\2\2\2\u01bd\7\3\2\2\2\u01be\u01c0\5N(\2\u01bf")
        buf.write("\u01be\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01c1\3\2\2\2")
        buf.write("\u01c1\u01c3\5\u00b4[\2\u01c2\u01c4\5> \2\u01c3\u01c2")
        buf.write("\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c6\3\2\2\2\u01c5")
        buf.write("\u01c7\5D#\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7")
        buf.write("\u01c9\3\2\2\2\u01c8\u01ca\5B\"\2\u01c9\u01c8\3\2\2\2")
        buf.write("\u01c9\u01ca\3\2\2\2\u01ca\t\3\2\2\2\u01cb\u01da\5\f\7")
        buf.write("\2\u01cc\u01da\5\16\b\2\u01cd\u01da\5 \21\2\u01ce\u01da")
        buf.write("\5\"\22\2\u01cf\u01da\5$\23\2\u01d0\u01da\5&\24\2\u01d1")
        buf.write("\u01da\5\20\t\2\u01d2\u01da\5\22\n\2\u01d3\u01da\5\24")
        buf.write("\13\2\u01d4\u01da\5\26\f\2\u01d5\u01da\5\30\r\2\u01d6")
        buf.write("\u01da\5\32\16\2\u01d7\u01da\5\34\17\2\u01d8\u01da\5\36")
        buf.write("\20\2\u01d9\u01cb\3\2\2\2\u01d9\u01cc\3\2\2\2\u01d9\u01cd")
        buf.write("\3\2\2\2\u01d9\u01ce\3\2\2\2\u01d9\u01cf\3\2\2\2\u01d9")
        buf.write("\u01d0\3\2\2\2\u01d9\u01d1\3\2\2\2\u01d9\u01d2\3\2\2\2")
        buf.write("\u01d9\u01d3\3\2\2\2\u01d9\u01d4\3\2\2\2\u01d9\u01d5\3")
        buf.write("\2\2\2\u01d9\u01d6\3\2\2\2\u01d9\u01d7\3\2\2\2\u01d9\u01d8")
        buf.write("\3\2\2\2\u01da\13\3\2\2\2\u01db\u01dd\7\u011b\2\2\u01dc")
        buf.write("\u01de\5F$\2\u01dd\u01dc\3\2\2\2\u01dd\u01de\3\2\2\2\u01de")
        buf.write("\u01e0\3\2\2\2\u01df\u01e1\5\\/\2\u01e0\u01df\3\2\2\2")
        buf.write("\u01e0\u01e1\3\2\2\2\u01e1\u01e2\3\2\2\2\u01e2\u01e5\5")
        buf.write("R*\2\u01e3\u01e4\7\65\2\2\u01e4\u01e6\5V,\2\u01e5\u01e3")
        buf.write("\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6\r\3\2\2\2\u01e7\u01e9")
        buf.write("\7\34\2\2\u01e8\u01ea\5F$\2\u01e9\u01e8\3\2\2\2\u01e9")
        buf.write("\u01ea\3\2\2\2\u01ea\u01ec\3\2\2\2\u01eb\u01ed\5\\/\2")
        buf.write("\u01ec\u01eb\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee\3")
        buf.write("\2\2\2\u01ee\u01ef\5T+\2\u01ef\17\3\2\2\2\u01f0\u01f1")
        buf.write("\7%\2\2\u01f1\u01f2\7=\2\2\u01f2\u01f4\7\u0129\2\2\u01f3")
        buf.write("\u01f5\5J&\2\u01f4\u01f3\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5")
        buf.write("\u01f7\3\2\2\2\u01f6\u01f8\5\\/\2\u01f7\u01f6\3\2\2\2")
        buf.write("\u01f7\u01f8\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9\u01fb\5")
        buf.write("8\35\2\u01fa\u01fc\5\64\33\2\u01fb\u01fa\3\2\2\2\u01fb")
        buf.write("\u01fc\3\2\2\2\u01fc\u01fe\3\2\2\2\u01fd\u01ff\5:\36\2")
        buf.write("\u01fe\u01fd\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0200\3")
        buf.write("\2\2\2\u0200\u0202\5<\37\2\u0201\u0203\5d\63\2\u0202\u0201")
        buf.write("\3\2\2\2\u0202\u0203\3\2\2\2\u0203\21\3\2\2\2\u0204\u0205")
        buf.write("\7\u00ea\2\2\u0205\u0206\7X\2\2\u0206\u0209\5n8\2\u0207")
        buf.write("\u0208\7\u0090\2\2\u0208\u020a\5J&\2\u0209\u0207\3\2\2")
        buf.write("\2\u0209\u020a\3\2\2\2\u020a\23\3\2\2\2\u020b\u020c\7")
        buf.write(";\2\2\u020c\u020d\7X\2\2\u020d\u0210\5t;\2\u020e\u020f")
        buf.write("\7\u0090\2\2\u020f\u0211\5J&\2\u0210\u020e\3\2\2\2\u0210")
        buf.write("\u0211\3\2\2\2\u0211\25\3\2\2\2\u0212\u0213\7x\2\2\u0213")
        buf.write("\u0214\7X\2\2\u0214\u0217\5f\64\2\u0215\u0216\7\u009a")
        buf.write("\2\2\u0216\u0218\7\177\2\2\u0217\u0215\3\2\2\2\u0217\u0218")
        buf.write("\3\2\2\2\u0218\u021b\3\2\2\2\u0219\u021a\7\u0090\2\2\u021a")
        buf.write("\u021c\5J&\2\u021b\u0219\3\2\2\2\u021b\u021c\3\2\2\2\u021c")
        buf.write("\27\3\2\2\2\u021d\u021e\7x\2\2\u021e\u021f\7\u00f7\2\2")
        buf.write("\u021f\u0220\7\u009a\2\2\u0220\u0221\t\2\2\2\u0221\u0224")
        buf.write("\t\3\2\2\u0222\u0223\7\u00c9\2\2\u0223\u0225\5f\64\2\u0224")
        buf.write("\u0222\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u0228\3\2\2\2")
        buf.write("\u0226\u0227\7\u0090\2\2\u0227\u0229\5J&\2\u0228\u0226")
        buf.write("\3\2\2\2\u0228\u0229\3\2\2\2\u0229\31\3\2\2\2\u022a\u022b")
        buf.write("\7\23\2\2\u022b\u022c\t\3\2\2\u022c\u022f\5d\63\2\u022d")
        buf.write("\u022e\7\u0090\2\2\u022e\u0230\5J&\2\u022f\u022d\3\2\2")
        buf.write("\2\u022f\u0230\3\2\2\2\u0230\33\3\2\2\2\u0231\u0233\7")
        buf.write("\62\2\2\u0232\u0234\7\u00ec\2\2\u0233\u0232\3\2\2\2\u0233")
        buf.write("\u0234\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0238\5X-\2\u0236")
        buf.write("\u0237\7\63\2\2\u0237\u0239\7\u014c\2\2\u0238\u0236\3")
        buf.write("\2\2\2\u0238\u0239\3\2\2\2\u0239\u023c\3\2\2\2\u023a\u023b")
        buf.write("\7\u0090\2\2\u023b\u023d\5J&\2\u023c\u023a\3\2\2\2\u023c")
        buf.write("\u023d\3\2\2\2\u023d\35\3\2\2\2\u023e\u0241\7\24\2\2\u023f")
        buf.write("\u0240\7\u014c\2\2\u0240\u0242\t\4\2\2\u0241\u023f\3\2")
        buf.write("\2\2\u0241\u0242\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0244")
        buf.write("\7\u0090\2\2\u0244\u0246\5J&\2\u0245\u0243\3\2\2\2\u0245")
        buf.write("\u0246\3\2\2\2\u0246\u024a\3\2\2\2\u0247\u024b\5\\/\2")
        buf.write("\u0248\u0249\7\30\2\2\u0249\u024b\5h\65\2\u024a\u0247")
        buf.write("\3\2\2\2\u024a\u0248\3\2\2\2\u024a\u024b\3\2\2\2\u024b")
        buf.write("\u024e\3\2\2\2\u024c\u024d\t\3\2\2\u024d\u024f\t\5\2\2")
        buf.write("\u024e\u024c\3\2\2\2\u024e\u024f\3\2\2\2\u024f\37\3\2")
        buf.write("\2\2\u0250\u0251\7\"\2\2\u0251\u0253\5F$\2\u0252\u0254")
        buf.write("\5Z.\2\u0253\u0252\3\2\2\2\u0253\u0254\3\2\2\2\u0254\u0257")
        buf.write("\3\2\2\2\u0255\u0256\7J\2\2\u0256\u0258\5f\64\2\u0257")
        buf.write("\u0255\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u025b\3\2\2\2")
        buf.write("\u0259\u025a\7\30\2\2\u025a\u025c\5h\65\2\u025b\u0259")
        buf.write("\3\2\2\2\u025b\u025c\3\2\2\2\u025c!\3\2\2\2\u025d\u025e")
        buf.write("\7a\2\2\u025e\u025f\5T+\2\u025f#\3\2\2\2\u0260\u0262\7")
        buf.write("a\2\2\u0261\u0263\7i\2\2\u0262\u0261\3\2\2\2\u0262\u0263")
        buf.write("\3\2\2\2\u0263\u0264\3\2\2\2\u0264\u0265\5\u0088E\2\u0265")
        buf.write("\u0266\7\u00f8\2\2\u0266\u0267\5t;\2\u0267%\3\2\2\2\u0268")
        buf.write("\u026a\7\u00b4\2\2\u0269\u026b\5:\36\2\u026a\u0269\3\2")
        buf.write("\2\2\u026a\u026b\3\2\2\2\u026b\u026c\3\2\2\2\u026c\u026e")
        buf.write("\5<\37\2\u026d\u026f\5d\63\2\u026e\u026d\3\2\2\2\u026e")
        buf.write("\u026f\3\2\2\2\u026f\u0272\3\2\2\2\u0270\u0271\7X\2\2")
        buf.write("\u0271\u0273\5\66\34\2\u0272\u0270\3\2\2\2\u0272\u0273")
        buf.write("\3\2\2\2\u0273\'\3\2\2\2\u0274\u0276\7\35\2\2\u0275\u0277")
        buf.write("\5F$\2\u0276\u0275\3\2\2\2\u0276\u0277\3\2\2\2\u0277\u0279")
        buf.write("\3\2\2\2\u0278\u027a\5\\/\2\u0279\u0278\3\2\2\2\u0279")
        buf.write("\u027a\3\2\2\2\u027a\u027b\3\2\2\2\u027b\u027c\7\u012b")
        buf.write("\2\2\u027c\u027e\5V,\2\u027d\u027f\5d\63\2\u027e\u027d")
        buf.write("\3\2\2\2\u027e\u027f\3\2\2\2\u027f)\3\2\2\2\u0280\u0281")
        buf.write("\7#\2\2\u0281\u0282\7\u014c\2\2\u0282\u0285\t\4\2\2\u0283")
        buf.write("\u0284\7\u0090\2\2\u0284\u0286\5F$\2\u0285\u0283\3\2\2")
        buf.write("\2\u0285\u0286\3\2\2\2\u0286\u0288\3\2\2\2\u0287\u0289")
        buf.write("\7\37\2\2\u0288\u0287\3\2\2\2\u0288\u0289\3\2\2\2\u0289")
        buf.write("\u028c\3\2\2\2\u028a\u028b\7$\2\2\u028b\u028d\7\u0148")
        buf.write("\2\2\u028c\u028a\3\2\2\2\u028c\u028d\3\2\2\2\u028d\u029a")
        buf.write("\3\2\2\2\u028e\u0290\7#\2\2\u028f\u0291\5F$\2\u0290\u028f")
        buf.write("\3\2\2\2\u0290\u0291\3\2\2\2\u0291\u0293\3\2\2\2\u0292")
        buf.write("\u0294\7\37\2\2\u0293\u0292\3\2\2\2\u0293\u0294\3\2\2")
        buf.write("\2\u0294\u0297\3\2\2\2\u0295\u0296\7$\2\2\u0296\u0298")
        buf.write("\7\u0148\2\2\u0297\u0295\3\2\2\2\u0297\u0298\3\2\2\2\u0298")
        buf.write("\u029a\3\2\2\2\u0299\u0280\3\2\2\2\u0299\u028e\3\2\2\2")
        buf.write("\u029a+\3\2\2\2\u029b\u029d\7%\2\2\u029c\u029e\5J&\2\u029d")
        buf.write("\u029c\3\2\2\2\u029d\u029e\3\2\2\2\u029e\u02a0\3\2\2\2")
        buf.write("\u029f\u02a1\5\\/\2\u02a0\u029f\3\2\2\2\u02a0\u02a1\3")
        buf.write("\2\2\2\u02a1\u02a2\3\2\2\2\u02a2\u02a4\58\35\2\u02a3\u02a5")
        buf.write("\5\64\33\2\u02a4\u02a3\3\2\2\2\u02a4\u02a5\3\2\2\2\u02a5")
        buf.write("\u02a7\3\2\2\2\u02a6\u02a8\5:\36\2\u02a7\u02a6\3\2\2\2")
        buf.write("\u02a7\u02a8\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9\u02ab\5")
        buf.write("<\37\2\u02aa\u02ac\5d\63\2\u02ab\u02aa\3\2\2\2\u02ab\u02ac")
        buf.write("\3\2\2\2\u02ac-\3\2\2\2\u02ad\u02af\7\36\2\2\u02ae\u02b0")
        buf.write("\5F$\2\u02af\u02ae\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2")
        buf.write("\3\2\2\2\u02b1\u02b3\5\\/\2\u02b2\u02b1\3\2\2\2\u02b2")
        buf.write("\u02b3\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02b5\7\u012b")
        buf.write("\2\2\u02b5\u02b7\5V,\2\u02b6\u02b8\5d\63\2\u02b7\u02b6")
        buf.write("\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8\u02bb\3\2\2\2\u02b9")
        buf.write("\u02ba\7\65\2\2\u02ba\u02bc\5V,\2\u02bb\u02b9\3\2\2\2")
        buf.write("\u02bb\u02bc\3\2\2\2\u02bc/\3\2\2\2\u02bd\u02bf\5N(\2")
        buf.write("\u02be\u02bd\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c0\3")
        buf.write("\2\2\2\u02c0\u02c2\7\64\2\2\u02c1\u02c3\5F$\2\u02c2\u02c1")
        buf.write("\3\2\2\2\u02c2\u02c3\3\2\2\2\u02c3\u02c4\3\2\2\2\u02c4")
        buf.write("\u02c5\7\u012b\2\2\u02c5\u02c7\5V,\2\u02c6\u02c8\5d\63")
        buf.write("\2\u02c7\u02c6\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8\61\3")
        buf.write("\2\2\2\u02c9\u02ca\7\61\2\2\u02ca\u02cc\5V,\2\u02cb\u02cd")
        buf.write("\5d\63\2\u02cc\u02cb\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd")
        buf.write("\63\3\2\2\2\u02ce\u02cf\7*\2\2\u02cf\65\3\2\2\2\u02d0")
        buf.write("\u02d3\5t;\2\u02d1\u02d3\5f\64\2\u02d2\u02d0\3\2\2\2\u02d2")
        buf.write("\u02d1\3\2\2\2\u02d3\67\3\2\2\2\u02d4\u02d5\t\6\2\2\u02d5")
        buf.write("9\3\2\2\2\u02d6\u02d7\t\7\2\2\u02d7;\3\2\2\2\u02d8\u02d9")
        buf.write("\7\u0148\2\2\u02d9=\3\2\2\2\u02da\u02dc\7\u00ad\2\2\u02db")
        buf.write("\u02da\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02e0\3\2\2\2")
        buf.write("\u02dd\u02e1\7\31\2\2\u02de\u02df\7-\2\2\u02df\u02e1\7")
        buf.write(",\2\2\u02e0\u02dd\3\2\2\2\u02e0\u02de\3\2\2\2\u02e1\u02e3")
        buf.write("\3\2\2\2\u02e2\u02e4\5d\63\2\u02e3\u02e2\3\2\2\2\u02e3")
        buf.write("\u02e4\3\2\2\2\u02e4\u0307\3\2\2\2\u02e5\u02e7\7\u00ad")
        buf.write("\2\2\u02e6\u02e5\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e9")
        buf.write("\3\2\2\2\u02e8\u02ea\7.\2\2\u02e9\u02e8\3\2\2\2\u02e9")
        buf.write("\u02ea\3\2\2\2\u02ea\u02eb\3\2\2\2\u02eb\u02ed\7,\2\2")
        buf.write("\u02ec\u02ee\5\\/\2\u02ed\u02ec\3\2\2\2\u02ed\u02ee\3")
        buf.write("\2\2\2\u02ee\u02f0\3\2\2\2\u02ef\u02f1\5\64\33\2\u02f0")
        buf.write("\u02ef\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1\u02f3\3\2\2\2")
        buf.write("\u02f2\u02f4\5d\63\2\u02f3\u02f2\3\2\2\2\u02f3\u02f4\3")
        buf.write("\2\2\2\u02f4\u0307\3\2\2\2\u02f5\u02f7\7\u00ad\2\2\u02f6")
        buf.write("\u02f5\3\2\2\2\u02f6\u02f7\3\2\2\2\u02f7\u02f8\3\2\2\2")
        buf.write("\u02f8\u02f9\7/\2\2\u02f9\u02fb\7,\2\2\u02fa\u02fc\5@")
        buf.write("!\2\u02fb\u02fa\3\2\2\2\u02fb\u02fc\3\2\2\2\u02fc\u02fe")
        buf.write("\3\2\2\2\u02fd\u02ff\5\\/\2\u02fe\u02fd\3\2\2\2\u02fe")
        buf.write("\u02ff\3\2\2\2\u02ff\u0301\3\2\2\2\u0300\u0302\5\64\33")
        buf.write("\2\u0301\u0300\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0304")
        buf.write("\3\2\2\2\u0303\u0305\5d\63\2\u0304\u0303\3\2\2\2\u0304")
        buf.write("\u0305\3\2\2\2\u0305\u0307\3\2\2\2\u0306\u02db\3\2\2\2")
        buf.write("\u0306\u02e6\3\2\2\2\u0306\u02f6\3\2\2\2\u0307?\3\2\2")
        buf.write("\2\u0308\u0309\7\u0148\2\2\u0309A\3\2\2\2\u030a\u030b")
        buf.write("\7\60\2\2\u030b\u030e\t\b\2\2\u030c\u030d\7B\2\2\u030d")
        buf.write("\u030f\5\u0094K\2\u030e\u030c\3\2\2\2\u030e\u030f\3\2")
        buf.write("\2\2\u030fC\3\2\2\2\u0310\u0311\7\32\2\2\u0311E\3\2\2")
        buf.write("\2\u0312\u0317\5J&\2\u0313\u0314\7\3\2\2\u0314\u0316\5")
        buf.write("J&\2\u0315\u0313\3\2\2\2\u0316\u0319\3\2\2\2\u0317\u0315")
        buf.write("\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u0323\3\2\2\2\u0319")
        buf.write("\u0317\3\2\2\2\u031a\u031f\5H%\2\u031b\u031c\7\3\2\2\u031c")
        buf.write("\u031e\5H%\2\u031d\u031b\3\2\2\2\u031e\u0321\3\2\2\2\u031f")
        buf.write("\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0323\3\2\2\2")
        buf.write("\u0321\u031f\3\2\2\2\u0322\u0312\3\2\2\2\u0322\u031a\3")
        buf.write("\2\2\2\u0323G\3\2\2\2\u0324\u0325\5\u0094K\2\u0325\u0326")
        buf.write("\t\t\2\2\u0326\u0327\5J&\2\u0327I\3\2\2\2\u0328\u032a")
        buf.write("\5\u0094K\2\u0329\u032b\5L\'\2\u032a\u0329\3\2\2\2\u032a")
        buf.write("\u032b\3\2\2\2\u032b\u0331\3\2\2\2\u032c\u032d\7\5\2\2")
        buf.write("\u032d\u032e\5\b\5\2\u032e\u032f\7\6\2\2\u032f\u0331\3")
        buf.write("\2\2\2\u0330\u0328\3\2\2\2\u0330\u032c\3\2\2\2\u0331K")
        buf.write("\3\2\2\2\u0332\u0335\7\7\2\2\u0333\u0336\7\u014c\2\2\u0334")
        buf.write("\u0336\5\u0094K\2\u0335\u0333\3\2\2\2\u0335\u0334\3\2")
        buf.write("\2\2\u0336\u0337\3\2\2\2\u0337\u0338\7\b\2\2\u0338M\3")
        buf.write("\2\2\2\u0339\u033a\5\u0094K\2\u033a\u033b\5P)\2\u033b")
        buf.write("O\3\2\2\2\u033c\u0340\7+\2\2\u033d\u033e\6)\2\2\u033e")
        buf.write("\u0340\7\u0134\2\2\u033f\u033c\3\2\2\2\u033f\u033d\3\2")
        buf.write("\2\2\u0340Q\3\2\2\2\u0341\u0342\7\u012b\2\2\u0342\u0344")
        buf.write("\5V,\2\u0343\u0345\5d\63\2\u0344\u0343\3\2\2\2\u0344\u0345")
        buf.write("\3\2\2\2\u0345\u0348\3\2\2\2\u0346\u0347\7\u00f8\2\2\u0347")
        buf.write("\u0349\5p9\2\u0348\u0346\3\2\2\2\u0348\u0349\3\2\2\2\u0349")
        buf.write("S\3\2\2\2\u034a\u034b\7\u012b\2\2\u034b\u034d\5V,\2\u034c")
        buf.write("\u034e\5d\63\2\u034d\u034c\3\2\2\2\u034d\u034e\3\2\2\2")
        buf.write("\u034e\u0351\3\2\2\2\u034f\u0350\7\u00f8\2\2\u0350\u0352")
        buf.write("\5t;\2\u0351\u034f\3\2\2\2\u0351\u0352\3\2\2\2\u0352U")
        buf.write("\3\2\2\2\u0353\u0358\5\u0094K\2\u0354\u0355\7\t\2\2\u0355")
        buf.write("\u0357\5\u0094K\2\u0356\u0354\3\2\2\2\u0357\u035a\3\2")
        buf.write("\2\2\u0358\u0356\3\2\2\2\u0358\u0359\3\2\2\2\u0359W\3")
        buf.write("\2\2\2\u035a\u0358\3\2\2\2\u035b\u035c\t\n\2\2\u035c\u0360")
        buf.write("\7\u00d9\2\2\u035d\u035e\7\u014c\2\2\u035e\u0360\7\u00f7")
        buf.write("\2\2\u035f\u035b\3\2\2\2\u035f\u035d\3\2\2\2\u0360Y\3")
        buf.write("\2\2\2\u0361\u036a\7b\2\2\u0362\u036a\7\u00a0\2\2\u0363")
        buf.write("\u0364\7\u00af\2\2\u0364\u036a\7\u00d0\2\2\u0365\u0366")
        buf.write("\7\u00f0\2\2\u0366\u036a\7\u00d0\2\2\u0367\u0368\7\u0091")
        buf.write("\2\2\u0368\u036a\7\u00d0\2\2\u0369\u0361\3\2\2\2\u0369")
        buf.write("\u0362\3\2\2\2\u0369\u0363\3\2\2\2\u0369\u0365\3\2\2\2")
        buf.write("\u0369\u0367\3\2\2\2\u036a[\3\2\2\2\u036b\u036d\5^\60")
        buf.write("\2\u036c\u036b\3\2\2\2\u036c\u036d\3\2\2\2\u036d\u036e")
        buf.write("\3\2\2\2\u036e\u036f\7!\2\2\u036f\u0372\5`\61\2\u0370")
        buf.write("\u0371\7J\2\2\u0371\u0373\5f\64\2\u0372\u0370\3\2\2\2")
        buf.write("\u0372\u0373\3\2\2\2\u0373\u0376\3\2\2\2\u0374\u0375\7")
        buf.write("\30\2\2\u0375\u0377\5h\65\2\u0376\u0374\3\2\2\2\u0376")
        buf.write("\u0377\3\2\2\2\u0377\u0383\3\2\2\2\u0378\u037a\5^\60\2")
        buf.write("\u0379\u0378\3\2\2\2\u0379\u037a\3\2\2\2\u037a\u037b\3")
        buf.write("\2\2\2\u037b\u037c\7!\2\2\u037c\u037d\7J\2\2\u037d\u0380")
        buf.write("\5f\64\2\u037e\u037f\7\30\2\2\u037f\u0381\5h\65\2\u0380")
        buf.write("\u037e\3\2\2\2\u0380\u0381\3\2\2\2\u0381\u0383\3\2\2\2")
        buf.write("\u0382\u036c\3\2\2\2\u0382\u0379\3\2\2\2\u0383]\3\2\2")
        buf.write("\2\u0384\u0385\t\13\2\2\u0385_\3\2\2\2\u0386\u0387\b\61")
        buf.write("\1\2\u0387\u038d\5b\62\2\u0388\u0389\7\5\2\2\u0389\u038a")
        buf.write("\5`\61\2\u038a\u038b\7\6\2\2\u038b\u038d\3\2\2\2\u038c")
        buf.write("\u0386\3\2\2\2\u038c\u0388\3\2\2\2\u038d\u0393\3\2\2\2")
        buf.write("\u038e\u038f\f\3\2\2\u038f\u0390\t\f\2\2\u0390\u0392\5")
        buf.write("`\61\4\u0391\u038e\3\2\2\2\u0392\u0395\3\2\2\2\u0393\u0391")
        buf.write("\3\2\2\2\u0393\u0394\3\2\2\2\u0394a\3\2\2\2\u0395\u0393")
        buf.write("\3\2\2\2\u0396\u0398\7\u013e\2\2\u0397\u0396\3\2\2\2\u0397")
        buf.write("\u0398\3\2\2\2\u0398\u0399\3\2\2\2\u0399\u03a1\7\u014e")
        buf.write("\2\2\u039a\u039c\7\u013e\2\2\u039b\u039a\3\2\2\2\u039b")
        buf.write("\u039c\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u03a1\7\u014c")
        buf.write("\2\2\u039e\u03a1\7\37\2\2\u039f\u03a1\7 \2\2\u03a0\u0397")
        buf.write("\3\2\2\2\u03a0\u039b\3\2\2\2\u03a0\u039e\3\2\2\2\u03a0")
        buf.write("\u039f\3\2\2\2\u03a1c\3\2\2\2\u03a2\u03a3\7\33\2\2\u03a3")
        buf.write("\u03a9\5\u0082B\2\u03a4\u03a6\7\33\2\2\u03a5\u03a4\3\2")
        buf.write("\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03a7\3\2\2\2\u03a7\u03a9")
        buf.write("\5\u0080A\2\u03a8\u03a2\3\2\2\2\u03a8\u03a5\3\2\2\2\u03a9")
        buf.write("e\3\2\2\2\u03aa\u03af\5l\67\2\u03ab\u03ac\7\3\2\2\u03ac")
        buf.write("\u03ae\5l\67\2\u03ad\u03ab\3\2\2\2\u03ae\u03b1\3\2\2\2")
        buf.write("\u03af\u03ad\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0g\3\2\2")
        buf.write("\2\u03b1\u03af\3\2\2\2\u03b2\u03b7\5j\66\2\u03b3\u03b4")
        buf.write("\7\3\2\2\u03b4\u03b6\5j\66\2\u03b5\u03b3\3\2\2\2\u03b6")
        buf.write("\u03b9\3\2\2\2\u03b7\u03b5\3\2\2\2\u03b7\u03b8\3\2\2\2")
        buf.write("\u03b8i\3\2\2\2\u03b9\u03b7\3\2\2\2\u03ba\u03bc\5l\67")
        buf.write("\2\u03bb\u03bd\t\r\2\2\u03bc\u03bb\3\2\2\2\u03bc\u03bd")
        buf.write("\3\2\2\2\u03bdk\3\2\2\2\u03be\u03bf\5\u0094K\2\u03bfm")
        buf.write("\3\2\2\2\u03c0\u03c5\5|?\2\u03c1\u03c2\7\3\2\2\u03c2\u03c4")
        buf.write("\5|?\2\u03c3\u03c1\3\2\2\2\u03c4\u03c7\3\2\2\2\u03c5\u03c3")
        buf.write("\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6o\3\2\2\2\u03c7\u03c5")
        buf.write("\3\2\2\2\u03c8\u03cd\5r:\2\u03c9\u03ca\7\3\2\2\u03ca\u03cc")
        buf.write("\5r:\2\u03cb\u03c9\3\2\2\2\u03cc\u03cf\3\2\2\2\u03cd\u03cb")
        buf.write("\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ceq\3\2\2\2\u03cf\u03cd")
        buf.write("\3\2\2\2\u03d0\u03d3\5v<\2\u03d1\u03d3\7\u013f\2\2\u03d2")
        buf.write("\u03d0\3\2\2\2\u03d2\u03d1\3\2\2\2\u03d3s\3\2\2\2\u03d4")
        buf.write("\u03d9\5v<\2\u03d5\u03d6\7\3\2\2\u03d6\u03d8\5v<\2\u03d7")
        buf.write("\u03d5\3\2\2\2\u03d8\u03db\3\2\2\2\u03d9\u03d7\3\2\2\2")
        buf.write("\u03d9\u03da\3\2\2\2\u03dau\3\2\2\2\u03db\u03d9\3\2\2")
        buf.write("\2\u03dc\u03dd\5x=\2\u03dd\u03de\7\4\2\2\u03de\u03df\5")
        buf.write("z>\2\u03dfw\3\2\2\2\u03e0\u03e1\5\u0094K\2\u03e1y\3\2")
        buf.write("\2\2\u03e2\u03ec\5\u0094K\2\u03e3\u03e4\7\7\2\2\u03e4")
        buf.write("\u03e5\5z>\2\u03e5\u03e6\7\b\2\2\u03e6\u03ec\3\2\2\2\u03e7")
        buf.write("\u03e8\7\n\2\2\u03e8\u03e9\5t;\2\u03e9\u03ea\7\13\2\2")
        buf.write("\u03ea\u03ec\3\2\2\2\u03eb\u03e2\3\2\2\2\u03eb\u03e3\3")
        buf.write("\2\2\2\u03eb\u03e7\3\2\2\2\u03ec{\3\2\2\2\u03ed\u03ee")
        buf.write("\5x=\2\u03ee\u03ef\7\4\2\2\u03ef\u03f0\5x=\2\u03f0}\3")
        buf.write("\2\2\2\u03f1\u03f2\5\u008aF\2\u03f2\177\3\2\2\2\u03f3")
        buf.write("\u03f4\7\n\2\2\u03f4\u03f6\5\u0082B\2\u03f5\u03f7\7\3")
        buf.write("\2\2\u03f6\u03f5\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7\u03f8")
        buf.write("\3\2\2\2\u03f8\u03f9\7\13\2\2\u03f9\u0406\3\2\2\2\u03fa")
        buf.write("\u03fb\7\n\2\2\u03fb\u0406\7\13\2\2\u03fc\u03fd\7\5\2")
        buf.write("\2\u03fd\u03ff\5\u0082B\2\u03fe\u0400\7\3\2\2\u03ff\u03fe")
        buf.write("\3\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0401\3\2\2\2\u0401")
        buf.write("\u0402\7\6\2\2\u0402\u0406\3\2\2\2\u0403\u0404\7\5\2\2")
        buf.write("\u0404\u0406\7\6\2\2\u0405\u03f3\3\2\2\2\u0405\u03fa\3")
        buf.write("\2\2\2\u0405\u03fc\3\2\2\2\u0405\u0403\3\2\2\2\u0406\u0081")
        buf.write("\3\2\2\2\u0407\u040c\5\u0084C\2\u0408\u0409\7\3\2\2\u0409")
        buf.write("\u040b\5\u0084C\2\u040a\u0408\3\2\2\2\u040b\u040e\3\2")
        buf.write("\2\2\u040c\u040a\3\2\2\2\u040c\u040d\3\2\2\2\u040d\u0083")
        buf.write("\3\2\2\2\u040e\u040c\3\2\2\2\u040f\u0410\5\u0086D\2\u0410")
        buf.write("\u0411\t\t\2\2\u0411\u0412\5\u008aF\2\u0412\u0085\3\2")
        buf.write("\2\2\u0413\u0416\5\u0094K\2\u0414\u0416\5\u008eH\2\u0415")
        buf.write("\u0413\3\2\2\2\u0415\u0414\3\2\2\2\u0416\u0087\3\2\2\2")
        buf.write("\u0417\u0418\7\7\2\2\u0418\u041d\5\u008aF\2\u0419\u041a")
        buf.write("\7\3\2\2\u041a\u041c\5\u008aF\2\u041b\u0419\3\2\2\2\u041c")
        buf.write("\u041f\3\2\2\2\u041d\u041b\3\2\2\2\u041d\u041e\3\2\2\2")
        buf.write("\u041e\u0421\3\2\2\2\u041f\u041d\3\2\2\2\u0420\u0422\7")
        buf.write("\3\2\2\u0421\u0420\3\2\2\2\u0421\u0422\3\2\2\2\u0422\u0423")
        buf.write("\3\2\2\2\u0423\u0424\7\b\2\2\u0424\u0428\3\2\2\2\u0425")
        buf.write("\u0426\7\7\2\2\u0426\u0428\7\b\2\2\u0427\u0417\3\2\2\2")
        buf.write("\u0427\u0425\3\2\2\2\u0428\u0089\3\2\2\2\u0429\u0430\5")
        buf.write("\u008eH\2\u042a\u0430\5\u008cG\2\u042b\u0430\5\u0080A")
        buf.write("\2\u042c\u0430\5\u0088E\2\u042d\u0430\5\u0090I\2\u042e")
        buf.write("\u0430\5\u0092J\2\u042f\u0429\3\2\2\2\u042f\u042a\3\2")
        buf.write("\2\2\u042f\u042b\3\2\2\2\u042f\u042c\3\2\2\2\u042f\u042d")
        buf.write("\3\2\2\2\u042f\u042e\3\2\2\2\u0430\u008b\3\2\2\2\u0431")
        buf.write("\u0432\5\u01a2\u00d2\2\u0432\u008d\3\2\2\2\u0433\u0434")
        buf.write("\7\u0148\2\2\u0434\u008f\3\2\2\2\u0435\u0436\t\16\2\2")
        buf.write("\u0436\u0091\3\2\2\2\u0437\u0438\t\17\2\2\u0438\u0093")
        buf.write("\3\2\2\2\u0439\u043a\5\u019c\u00cf\2\u043a\u0095\3\2\2")
        buf.write("\2\u043b\u043f\5\u00a4S\2\u043c\u043e\7\17\2\2\u043d\u043c")
        buf.write("\3\2\2\2\u043e\u0441\3\2\2\2\u043f\u043d\3\2\2\2\u043f")
        buf.write("\u0440\3\2\2\2\u0440\u0442\3\2\2\2\u0441\u043f\3\2\2\2")
        buf.write("\u0442\u0443\7\2\2\3\u0443\u0097\3\2\2\2\u0444\u0445\5")
        buf.write("\u0148\u00a5\2\u0445\u0446\7\2\2\3\u0446\u0099\3\2\2\2")
        buf.write("\u0447\u0448\5\u0144\u00a3\2\u0448\u0449\7\2\2\3\u0449")
        buf.write("\u009b\3\2\2\2\u044a\u044b\5\u0142\u00a2\2\u044b\u044c")
        buf.write("\7\2\2\3\u044c\u009d\3\2\2\2\u044d\u044e\5\u0146\u00a4")
        buf.write("\2\u044e\u044f\7\2\2\3\u044f\u009f\3\2\2\2\u0450\u0451")
        buf.write("\5\u0178\u00bd\2\u0451\u0452\7\2\2\3\u0452\u00a1\3\2\2")
        buf.write("\2\u0453\u0454\5\u017e\u00c0\2\u0454\u0455\7\2\2\3\u0455")
        buf.write("\u00a3\3\2\2\2\u0456\u0718\5\u00b4[\2\u0457\u0459\5\u00c4")
        buf.write("c\2\u0458\u0457\3\2\2\2\u0458\u0459\3\2\2\2\u0459\u045a")
        buf.write("\3\2\2\2\u045a\u0718\5\u00e0q\2\u045b\u045d\7\u0129\2")
        buf.write("\2\u045c\u045e\7\u00c1\2\2\u045d\u045c\3\2\2\2\u045d\u045e")
        buf.write("\3\2\2\2\u045e\u045f\3\2\2\2\u045f\u0718\5\u0142\u00a2")
        buf.write("\2\u0460\u0461\7a\2\2\u0461\u0465\5\u00be`\2\u0462\u0463")
        buf.write("\7\u009a\2\2\u0463\u0464\7\u00c5\2\2\u0464\u0466\7\177")
        buf.write("\2\2\u0465\u0462\3\2\2\2\u0465\u0466\3\2\2\2\u0466\u0467")
        buf.write("\3\2\2\2\u0467\u046f\5\u0142\u00a2\2\u0468\u046e\5\u00b2")
        buf.write("Z\2\u0469\u046e\5\u00b0Y\2\u046a\u046b\7\u0132\2\2\u046b")
        buf.write("\u046c\t\20\2\2\u046c\u046e\5\u00ccg\2\u046d\u0468\3\2")
        buf.write("\2\2\u046d\u0469\3\2\2\2\u046d\u046a\3\2\2\2\u046e\u0471")
        buf.write("\3\2\2\2\u046f\u046d\3\2\2\2\u046f\u0470\3\2\2\2\u0470")
        buf.write("\u0718\3\2\2\2\u0471\u046f\3\2\2\2\u0472\u0473\7;\2\2")
        buf.write("\u0473\u0474\5\u00be`\2\u0474\u0475\5\u0142\u00a2\2\u0475")
        buf.write("\u0476\7\u0100\2\2\u0476\u0477\t\20\2\2\u0477\u0478\5")
        buf.write("\u00ccg\2\u0478\u0718\3\2\2\2\u0479\u047a\7;\2\2\u047a")
        buf.write("\u047b\5\u00be`\2\u047b\u047c\5\u0142\u00a2\2\u047c\u047d")
        buf.write("\7\u0100\2\2\u047d\u047e\5\u00b0Y\2\u047e\u0718\3\2\2")
        buf.write("\2\u047f\u0480\7x\2\2\u0480\u0483\5\u00be`\2\u0481\u0482")
        buf.write("\7\u009a\2\2\u0482\u0484\7\177\2\2\u0483\u0481\3\2\2\2")
        buf.write("\u0483\u0484\3\2\2\2\u0484\u0485\3\2\2\2\u0485\u0487\5")
        buf.write("\u0142\u00a2\2\u0486\u0488\t\21\2\2\u0487\u0486\3\2\2")
        buf.write("\2\u0487\u0488\3\2\2\2\u0488\u0718\3\2\2\2\u0489\u048a")
        buf.write("\7\u0103\2\2\u048a\u048d\t\22\2\2\u048b\u048c\t\23\2\2")
        buf.write("\u048c\u048e\5\u0142\u00a2\2\u048d\u048b\3\2\2\2\u048d")
        buf.write("\u048e\3\2\2\2\u048e\u0493\3\2\2\2\u048f\u0491\7\u00b0")
        buf.write("\2\2\u0490\u048f\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0492")
        buf.write("\3\2\2\2\u0492\u0494\7\u0148\2\2\u0493\u0490\3\2\2\2\u0493")
        buf.write("\u0494\3\2\2\2\u0494\u0718\3\2\2\2\u0495\u049a\5\u00a8")
        buf.write("U\2\u0496\u0497\7\5\2\2\u0497\u0498\5\u017e\u00c0\2\u0498")
        buf.write("\u0499\7\6\2\2\u0499\u049b\3\2\2\2\u049a\u0496\3\2\2\2")
        buf.write("\u049a\u049b\3\2\2\2\u049b\u049c\3\2\2\2\u049c\u049d\5")
        buf.write("\u00c8e\2\u049d\u04a2\5\u00caf\2\u049e\u04a0\7B\2\2\u049f")
        buf.write("\u049e\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u04a1\3\2\2\2")
        buf.write("\u04a1\u04a3\5\u00b4[\2\u04a2\u049f\3\2\2\2\u04a2\u04a3")
        buf.write("\3\2\2\2\u04a3\u0718\3\2\2\2\u04a4\u04a9\5\u00a8U\2\u04a5")
        buf.write("\u04a6\7\5\2\2\u04a6\u04a7\5\u017e\u00c0\2\u04a7\u04a8")
        buf.write("\7\6\2\2\u04a8\u04aa\3\2\2\2\u04a9\u04a5\3\2\2\2\u04a9")
        buf.write("\u04aa\3\2\2\2\u04aa\u04c0\3\2\2\2\u04ab\u04bf\5\u00b2")
        buf.write("Z\2\u04ac\u04ad\7\u00d7\2\2\u04ad\u04ae\7J\2\2\u04ae\u04af")
        buf.write("\7\5\2\2\u04af\u04b0\5\u017e\u00c0\2\u04b0\u04b1\7\6\2")
        buf.write("\2\u04b1\u04b6\3\2\2\2\u04b2\u04b3\7\u00d7\2\2\u04b3\u04b4")
        buf.write("\7J\2\2\u04b4\u04b6\5\u012a\u0096\2\u04b5\u04ac\3\2\2")
        buf.write("\2\u04b5\u04b2\3\2\2\2\u04b6\u04bf\3\2\2\2\u04b7\u04bf")
        buf.write("\5\u00acW\2\u04b8\u04bf\5\u00aeX\2\u04b9\u04bf\5\u013e")
        buf.write("\u00a0\2\u04ba\u04bf\5\u00d8m\2\u04bb\u04bf\5\u00b0Y\2")
        buf.write("\u04bc\u04bd\7\u0112\2\2\u04bd\u04bf\5\u00ccg\2\u04be")
        buf.write("\u04ab\3\2\2\2\u04be\u04b5\3\2\2\2\u04be\u04b7\3\2\2\2")
        buf.write("\u04be\u04b8\3\2\2\2\u04be\u04b9\3\2\2\2\u04be\u04ba\3")
        buf.write("\2\2\2\u04be\u04bb\3\2\2\2\u04be\u04bc\3\2\2\2\u04bf\u04c2")
        buf.write("\3\2\2\2\u04c0\u04be\3\2\2\2\u04c0\u04c1\3\2\2\2\u04c1")
        buf.write("\u04c7\3\2\2\2\u04c2\u04c0\3\2\2\2\u04c3\u04c5\7B\2\2")
        buf.write("\u04c4\u04c3\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5\u04c6\3")
        buf.write("\2\2\2\u04c6\u04c8\5\u00b4[\2\u04c7\u04c4\3\2\2\2\u04c7")
        buf.write("\u04c8\3\2\2\2\u04c8\u0718\3\2\2\2\u04c9\u04ca\7a\2\2")
        buf.write("\u04ca\u04ce\7\u010f\2\2\u04cb\u04cc\7\u009a\2\2\u04cc")
        buf.write("\u04cd\7\u00c5\2\2\u04cd\u04cf\7\177\2\2\u04ce\u04cb\3")
        buf.write("\2\2\2\u04ce\u04cf\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\u04d1")
        buf.write("\5\u0144\u00a3\2\u04d1\u04d2\7\u00b0\2\2\u04d2\u04db\5")
        buf.write("\u0144\u00a3\2\u04d3\u04da\5\u00c8e\2\u04d4\u04da\5\u013e")
        buf.write("\u00a0\2\u04d5\u04da\5\u00d8m\2\u04d6\u04da\5\u00b0Y\2")
        buf.write("\u04d7\u04d8\7\u0112\2\2\u04d8\u04da\5\u00ccg\2\u04d9")
        buf.write("\u04d3\3\2\2\2\u04d9\u04d4\3\2\2\2\u04d9\u04d5\3\2\2\2")
        buf.write("\u04d9\u04d6\3\2\2\2\u04d9\u04d7\3\2\2\2\u04da\u04dd\3")
        buf.write("\2\2\2\u04db\u04d9\3\2\2\2\u04db\u04dc\3\2\2\2\u04dc\u0718")
        buf.write("\3\2\2\2\u04dd\u04db\3\2\2\2\u04de\u04e3\5\u00aaV\2\u04df")
        buf.write("\u04e0\7\5\2\2\u04e0\u04e1\5\u017e\u00c0\2\u04e1\u04e2")
        buf.write("\7\6\2\2\u04e2\u04e4\3\2\2\2\u04e3\u04df\3\2\2\2\u04e3")
        buf.write("\u04e4\3\2\2\2\u04e4\u04e5\3\2\2\2\u04e5\u04e6\5\u00c8")
        buf.write("e\2\u04e6\u04eb\5\u00caf\2\u04e7\u04e9\7B\2\2\u04e8\u04e7")
        buf.write("\3\2\2\2\u04e8\u04e9\3\2\2\2\u04e9\u04ea\3\2\2\2\u04ea")
        buf.write("\u04ec\5\u00b4[\2\u04eb\u04e8\3\2\2\2\u04eb\u04ec\3\2")
        buf.write("\2\2\u04ec\u0718\3\2\2\2\u04ed\u04ee\7<\2\2\u04ee\u04ef")
        buf.write("\7\u010f\2\2\u04ef\u04f1\5\u0142\u00a2\2\u04f0\u04f2\5")
        buf.write("\u00ba^\2\u04f1\u04f0\3\2\2\2\u04f1\u04f2\3\2\2\2\u04f2")
        buf.write("\u04f3\3\2\2\2\u04f3\u04f4\7]\2\2\u04f4\u04fc\7\u0109")
        buf.write("\2\2\u04f5\u04fd\5\u019c\u00cf\2\u04f6\u04f7\7\u008c\2")
        buf.write("\2\u04f7\u04f8\7X\2\2\u04f8\u04fd\5\u012c\u0097\2\u04f9")
        buf.write("\u04fa\7\u008c\2\2\u04fa\u04fb\7:\2\2\u04fb\u04fd\7X\2")
        buf.write("\2\u04fc\u04f5\3\2\2\2\u04fc\u04f6\3\2\2\2\u04fc\u04f9")
        buf.write("\3\2\2\2\u04fc\u04fd\3\2\2\2\u04fd\u0718\3\2\2\2\u04fe")
        buf.write("\u04ff\7;\2\2\u04ff\u0500\7\u010f\2\2\u0500\u0501\5\u0142")
        buf.write("\u00a2\2\u0501\u0502\78\2\2\u0502\u0503\t\24\2\2\u0503")
        buf.write("\u0504\5\u017a\u00be\2\u0504\u0718\3\2\2\2\u0505\u0506")
        buf.write("\7;\2\2\u0506\u0507\7\u010f\2\2\u0507\u0508\5\u0142\u00a2")
        buf.write("\2\u0508\u0509\78\2\2\u0509\u050a\t\24\2\2\u050a\u050b")
        buf.write("\7\5\2\2\u050b\u050c\5\u017a\u00be\2\u050c\u050d\7\6\2")
        buf.write("\2\u050d\u0718\3\2\2\2\u050e\u050f\7;\2\2\u050f\u0510")
        buf.write("\7\u010f\2\2\u0510\u0511\5\u0142\u00a2\2\u0511\u0512\7")
        buf.write("\u00ea\2\2\u0512\u0513\7W\2\2\u0513\u0514\5\u0142\u00a2")
        buf.write("\2\u0514\u0515\7\u0116\2\2\u0515\u0516\5\u0198\u00cd\2")
        buf.write("\u0516\u0718\3\2\2\2\u0517\u0518\7;\2\2\u0518\u0519\7")
        buf.write("\u010f\2\2\u0519\u051a\5\u0142\u00a2\2\u051a\u051b\7x")
        buf.write("\2\2\u051b\u051c\t\24\2\2\u051c\u051d\7\5\2\2\u051d\u051e")
        buf.write("\5\u0140\u00a1\2\u051e\u051f\7\6\2\2\u051f\u0718\3\2\2")
        buf.write("\2\u0520\u0521\7;\2\2\u0521\u0522\7\u010f\2\2\u0522\u0523")
        buf.write("\5\u0142\u00a2\2\u0523\u0524\7x\2\2\u0524\u0525\t\24\2")
        buf.write("\2\u0525\u0526\5\u0140\u00a1\2\u0526\u0718\3\2\2\2\u0527")
        buf.write("\u0528\7;\2\2\u0528\u0529\t\25\2\2\u0529\u052a\5\u0142")
        buf.write("\u00a2\2\u052a\u052b\7\u00ea\2\2\u052b\u052c\7\u0116\2")
        buf.write("\2\u052c\u052d\5\u0142\u00a2\2\u052d\u0718\3\2\2\2\u052e")
        buf.write("\u052f\7;\2\2\u052f\u0530\t\25\2\2\u0530\u0531\5\u0142")
        buf.write("\u00a2\2\u0531\u0532\7\u0100\2\2\u0532\u0533\7\u0112\2")
        buf.write("\2\u0533\u0534\5\u00ccg\2\u0534\u0718\3\2\2\2\u0535\u0536")
        buf.write("\7;\2\2\u0536\u0537\t\25\2\2\u0537\u0538\5\u0142\u00a2")
        buf.write("\2\u0538\u0539\7\u0127\2\2\u0539\u053c\7\u0112\2\2\u053a")
        buf.write("\u053b\7\u009a\2\2\u053b\u053d\7\177\2\2\u053c\u053a\3")
        buf.write("\2\2\2\u053c\u053d\3\2\2\2\u053d\u053e\3\2\2\2\u053e\u053f")
        buf.write("\5\u00ccg\2\u053f\u0718\3\2\2\2\u0540\u0541\7;\2\2\u0541")
        buf.write("\u0542\7\u010f\2\2\u0542\u0543\5\u0142\u00a2\2\u0543\u0545")
        buf.write("\t\26\2\2\u0544\u0546\7W\2\2\u0545\u0544\3\2\2\2\u0545")
        buf.write("\u0546\3\2\2\2\u0546\u0547\3\2\2\2\u0547\u0549\5\u0142")
        buf.write("\u00a2\2\u0548\u054a\5\u01a4\u00d3\2\u0549\u0548\3\2\2")
        buf.write("\2\u0549\u054a\3\2\2\2\u054a\u0718\3\2\2\2\u054b\u054c")
        buf.write("\7;\2\2\u054c\u054d\7\u010f\2\2\u054d\u054f\5\u0142\u00a2")
        buf.write("\2\u054e\u0550\5\u00ba^\2\u054f\u054e\3\2\2\2\u054f\u0550")
        buf.write("\3\2\2\2\u0550\u0551\3\2\2\2\u0551\u0553\7O\2\2\u0552")
        buf.write("\u0554\7W\2\2\u0553\u0552\3\2\2\2\u0553\u0554\3\2\2\2")
        buf.write("\u0554\u0555\3\2\2\2\u0555\u0556\5\u0142\u00a2\2\u0556")
        buf.write("\u0558\5\u0180\u00c1\2\u0557\u0559\5\u0176\u00bc\2\u0558")
        buf.write("\u0557\3\2\2\2\u0558\u0559\3\2\2\2\u0559\u0718\3\2\2\2")
        buf.write("\u055a\u055b\7;\2\2\u055b\u055c\7\u010f\2\2\u055c\u055e")
        buf.write("\5\u0142\u00a2\2\u055d\u055f\5\u00ba^\2\u055e\u055d\3")
        buf.write("\2\2\2\u055e\u055f\3\2\2\2\u055f\u0560\3\2\2\2\u0560\u0561")
        buf.write("\7\u00ec\2\2\u0561\u0562\7X\2\2\u0562\u0563\7\5\2\2\u0563")
        buf.write("\u0564\5\u017a\u00be\2\u0564\u0565\7\6\2\2\u0565\u0718")
        buf.write("\3\2\2\2\u0566\u0567\7;\2\2\u0567\u0568\7\u010f\2\2\u0568")
        buf.write("\u056a\5\u0142\u00a2\2\u0569\u056b\5\u00ba^\2\u056a\u0569")
        buf.write("\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u056c\3\2\2\2\u056c")
        buf.write("\u056d\7\u0100\2\2\u056d\u056e\7\u00fd\2\2\u056e\u0572")
        buf.write("\7\u0148\2\2\u056f\u0570\7\u0132\2\2\u0570\u0571\7\u00fe")
        buf.write("\2\2\u0571\u0573\5\u00ccg\2\u0572\u056f\3\2\2\2\u0572")
        buf.write("\u0573\3\2\2\2\u0573\u0718\3\2\2\2\u0574\u0575\7;\2\2")
        buf.write("\u0575\u0576\7\u010f\2\2\u0576\u0578\5\u0142\u00a2\2\u0577")
        buf.write("\u0579\5\u00ba^\2\u0578\u0577\3\2\2\2\u0578\u0579\3\2")
        buf.write("\2\2\u0579\u057a\3\2\2\2\u057a\u057b\7\u0100\2\2\u057b")
        buf.write("\u057c\7\u00fe\2\2\u057c\u057d\5\u00ccg\2\u057d\u0718")
        buf.write("\3\2\2\2\u057e\u057f\7;\2\2\u057f\u0580\t\25\2\2\u0580")
        buf.write("\u0581\5\u0142\u00a2\2\u0581\u0585\78\2\2\u0582\u0583")
        buf.write("\7\u009a\2\2\u0583\u0584\7\u00c5\2\2\u0584\u0586\7\177")
        buf.write("\2\2\u0585\u0582\3\2\2\2\u0585\u0586\3\2\2\2\u0586\u0588")
        buf.write("\3\2\2\2\u0587\u0589\5\u00b8]\2\u0588\u0587\3\2\2\2\u0589")
        buf.write("\u058a\3\2\2\2\u058a\u0588\3\2\2\2\u058a\u058b\3\2\2\2")
        buf.write("\u058b\u0718\3\2\2\2\u058c\u058d\7;\2\2\u058d\u058e\7")
        buf.write("\u010f\2\2\u058e\u058f\5\u0142\u00a2\2\u058f\u0590\5\u00ba")
        buf.write("^\2\u0590\u0591\7\u00ea\2\2\u0591\u0592\7\u0116\2\2\u0592")
        buf.write("\u0593\5\u00ba^\2\u0593\u0718\3\2\2\2\u0594\u0595\7;\2")
        buf.write("\2\u0595\u0596\t\25\2\2\u0596\u0597\5\u0142\u00a2\2\u0597")
        buf.write("\u059a\7x\2\2\u0598\u0599\7\u009a\2\2\u0599\u059b\7\177")
        buf.write("\2\2\u059a\u0598\3\2\2\2\u059a\u059b\3\2\2\2\u059b\u059c")
        buf.write("\3\2\2\2\u059c\u05a1\5\u00ba^\2\u059d\u059e\7\3\2\2\u059e")
        buf.write("\u05a0\5\u00ba^\2\u059f\u059d\3\2\2\2\u05a0\u05a3\3\2")
        buf.write("\2\2\u05a1\u059f\3\2\2\2\u05a1\u05a2\3\2\2\2\u05a2\u05a5")
        buf.write("\3\2\2\2\u05a3\u05a1\3\2\2\2\u05a4\u05a6\7\u00e1\2\2\u05a5")
        buf.write("\u05a4\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6\u0718\3\2\2\2")
        buf.write("\u05a7\u05a8\7;\2\2\u05a8\u05a9\7\u010f\2\2\u05a9\u05ab")
        buf.write("\5\u0142\u00a2\2\u05aa\u05ac\5\u00ba^\2\u05ab\u05aa\3")
        buf.write("\2\2\2\u05ab\u05ac\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad\u05ae")
        buf.write("\7\u0100\2\2\u05ae\u05af\5\u00b0Y\2\u05af\u0718\3\2\2")
        buf.write("\2\u05b0\u05b1\7;\2\2\u05b1\u05b2\7\u010f\2\2\u05b2\u05b3")
        buf.write("\5\u0142\u00a2\2\u05b3\u05b4\7\u00e6\2\2\u05b4\u05b5\7")
        buf.write("\u00d8\2\2\u05b5\u0718\3\2\2\2\u05b6\u05b7\7x\2\2\u05b7")
        buf.write("\u05ba\7\u010f\2\2\u05b8\u05b9\7\u009a\2\2\u05b9\u05bb")
        buf.write("\7\177\2\2\u05ba\u05b8\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb")
        buf.write("\u05bc\3\2\2\2\u05bc\u05be\5\u0142\u00a2\2\u05bd\u05bf")
        buf.write("\7\u00e1\2\2\u05be\u05bd\3\2\2\2\u05be\u05bf\3\2\2\2\u05bf")
        buf.write("\u0718\3\2\2\2\u05c0\u05c1\7x\2\2\u05c1\u05c4\7\u012d")
        buf.write("\2\2\u05c2\u05c3\7\u009a\2\2\u05c3\u05c5\7\177\2\2\u05c4")
        buf.write("\u05c2\3\2\2\2\u05c4\u05c5\3\2\2\2\u05c5\u05c6\3\2\2\2")
        buf.write("\u05c6\u0718\5\u0142\u00a2\2\u05c7\u05ca\7a\2\2\u05c8")
        buf.write("\u05c9\7\u00cd\2\2\u05c9\u05cb\7\u00ec\2\2\u05ca\u05c8")
        buf.write("\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05d0\3\2\2\2\u05cc")
        buf.write("\u05ce\7\u0094\2\2\u05cd\u05cc\3\2\2\2\u05cd\u05ce\3\2")
        buf.write("\2\2\u05ce\u05cf\3\2\2\2\u05cf\u05d1\7\u0113\2\2\u05d0")
        buf.write("\u05cd\3\2\2\2\u05d0\u05d1\3\2\2\2\u05d1\u05d2\3\2\2\2")
        buf.write("\u05d2\u05d6\7\u012d\2\2\u05d3\u05d4\7\u009a\2\2\u05d4")
        buf.write("\u05d5\7\u00c5\2\2\u05d5\u05d7\7\177\2\2\u05d6\u05d3\3")
        buf.write("\2\2\2\u05d6\u05d7\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8\u05da")
        buf.write("\5\u0142\u00a2\2\u05d9\u05db\5\u0132\u009a\2\u05da\u05d9")
        buf.write("\3\2\2\2\u05da\u05db\3\2\2\2\u05db\u05e4\3\2\2\2\u05dc")
        buf.write("\u05e3\5\u00b2Z\2\u05dd\u05de\7\u00d7\2\2\u05de\u05df")
        buf.write("\7\u00c9\2\2\u05df\u05e3\5\u012a\u0096\2\u05e0\u05e1\7")
        buf.write("\u0112\2\2\u05e1\u05e3\5\u00ccg\2\u05e2\u05dc\3\2\2\2")
        buf.write("\u05e2\u05dd\3\2\2\2\u05e2\u05e0\3\2\2\2\u05e3\u05e6\3")
        buf.write("\2\2\2\u05e4\u05e2\3\2\2\2\u05e4\u05e5\3\2\2\2\u05e5\u05e7")
        buf.write("\3\2\2\2\u05e6\u05e4\3\2\2\2\u05e7\u05e8\7B\2\2\u05e8")
        buf.write("\u05e9\5\u00b4[\2\u05e9\u0718\3\2\2\2\u05ea\u05ed\7a\2")
        buf.write("\2\u05eb\u05ec\7\u00cd\2\2\u05ec\u05ee\7\u00ec\2\2\u05ed")
        buf.write("\u05eb\3\2\2\2\u05ed\u05ee\3\2\2\2\u05ee\u05f0\3\2\2\2")
        buf.write("\u05ef\u05f1\7\u0094\2\2\u05f0\u05ef\3\2\2\2\u05f0\u05f1")
        buf.write("\3\2\2\2\u05f1\u05f2\3\2\2\2\u05f2\u05f3\7\u0113\2\2\u05f3")
        buf.write("\u05f4\7\u012d\2\2\u05f4\u05f9\5\u0144\u00a3\2\u05f5\u05f6")
        buf.write("\7\5\2\2\u05f6\u05f7\5\u017e\u00c0\2\u05f7\u05f8\7\6\2")
        buf.write("\2\u05f8\u05fa\3\2\2\2\u05f9\u05f5\3\2\2\2\u05f9\u05fa")
        buf.write("\3\2\2\2\u05fa\u05fb\3\2\2\2\u05fb\u05fe\5\u00c8e\2\u05fc")
        buf.write("\u05fd\7\u00cc\2\2\u05fd\u05ff\5\u00ccg\2\u05fe\u05fc")
        buf.write("\3\2\2\2\u05fe\u05ff\3\2\2\2\u05ff\u0718\3\2\2\2\u0600")
        buf.write("\u0601\7;\2\2\u0601\u0602\7\u012d\2\2\u0602\u0604\5\u0142")
        buf.write("\u00a2\2\u0603\u0605\7B\2\2\u0604\u0603\3\2\2\2\u0604")
        buf.write("\u0605\3\2\2\2\u0605\u0606\3\2\2\2\u0606\u0607\5\u00b4")
        buf.write("[\2\u0607\u0718\3\2\2\2\u0608\u060b\7a\2\2\u0609\u060a")
        buf.write("\7\u00cd\2\2\u060a\u060c\7\u00ec\2\2\u060b\u0609\3\2\2")
        buf.write("\2\u060b\u060c\3\2\2\2\u060c\u060e\3\2\2\2\u060d\u060f")
        buf.write("\7\u0113\2\2\u060e\u060d\3\2\2\2\u060e\u060f\3\2\2\2\u060f")
        buf.write("\u0610\3\2\2\2\u0610\u0614\7\u0092\2\2\u0611\u0612\7\u009a")
        buf.write("\2\2\u0612\u0613\7\u00c5\2\2\u0613\u0615\7\177\2\2\u0614")
        buf.write("\u0611\3\2\2\2\u0614\u0615\3\2\2\2\u0615\u0616\3\2\2\2")
        buf.write("\u0616\u0617\5\u0142\u00a2\2\u0617\u0618\7B\2\2\u0618")
        buf.write("\u0622\7\u0148\2\2\u0619\u061a\7\u012b\2\2\u061a\u061f")
        buf.write("\5\u00dep\2\u061b\u061c\7\3\2\2\u061c\u061e\5\u00dep\2")
        buf.write("\u061d\u061b\3\2\2\2\u061e\u0621\3\2\2\2\u061f\u061d\3")
        buf.write("\2\2\2\u061f\u0620\3\2\2\2\u0620\u0623\3\2\2\2\u0621\u061f")
        buf.write("\3\2\2\2\u0622\u0619\3\2\2\2\u0622\u0623\3\2\2\2\u0623")
        buf.write("\u0718\3\2\2\2\u0624\u0626\7x\2\2\u0625\u0627\7\u0113")
        buf.write("\2\2\u0626\u0625\3\2\2\2\u0626\u0627\3\2\2\2\u0627\u0628")
        buf.write("\3\2\2\2\u0628\u062b\7\u0092\2\2\u0629\u062a\7\u009a\2")
        buf.write("\2\u062a\u062c\7\177\2\2\u062b\u0629\3\2\2\2\u062b\u062c")
        buf.write("\3\2\2\2\u062c\u062d\3\2\2\2\u062d\u0718\5\u0142\u00a2")
        buf.write("\2\u062e\u0630\7\u0080\2\2\u062f\u0631\t\27\2\2\u0630")
        buf.write("\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0632\3\2\2\2")
        buf.write("\u0632\u0718\5\u00a4S\2\u0633\u0634\7\u0103\2\2\u0634")
        buf.write("\u0637\7\u0110\2\2\u0635\u0636\t\23\2\2\u0636\u0638\5")
        buf.write("\u0142\u00a2\2\u0637\u0635\3\2\2\2\u0637\u0638\3\2\2\2")
        buf.write("\u0638\u063d\3\2\2\2\u0639\u063b\7\u00b0\2\2\u063a\u0639")
        buf.write("\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063c\3\2\2\2\u063c")
        buf.write("\u063e\7\u0148\2\2\u063d\u063a\3\2\2\2\u063d\u063e\3\2")
        buf.write("\2\2\u063e\u0718\3\2\2\2\u063f\u0640\7\u0103\2\2\u0640")
        buf.write("\u0641\7\u010f\2\2\u0641\u0644\7\u0082\2\2\u0642\u0643")
        buf.write("\t\23\2\2\u0643\u0645\5\u0142\u00a2\2\u0644\u0642\3\2")
        buf.write("\2\2\u0644\u0645\3\2\2\2\u0645\u0646\3\2\2\2\u0646\u0647")
        buf.write("\7\u00b0\2\2\u0647\u0649\7\u0148\2\2\u0648\u064a\5\u00ba")
        buf.write("^\2\u0649\u0648\3\2\2\2\u0649\u064a\3\2\2\2\u064a\u0718")
        buf.write("\3\2\2\2\u064b\u064c\7\u0103\2\2\u064c\u064d\7\u0112\2")
        buf.write("\2\u064d\u0652\5\u0142\u00a2\2\u064e\u064f\7\5\2\2\u064f")
        buf.write("\u0650\5\u00d0i\2\u0650\u0651\7\6\2\2\u0651\u0653\3\2")
        buf.write("\2\2\u0652\u064e\3\2\2\2\u0652\u0653\3\2\2\2\u0653\u0718")
        buf.write("\3\2\2\2\u0654\u0655\7\u0103\2\2\u0655\u0656\7X\2\2\u0656")
        buf.write("\u0657\t\23\2\2\u0657\u065a\5\u0142\u00a2\2\u0658\u0659")
        buf.write("\t\23\2\2\u0659\u065b\5\u0142\u00a2\2\u065a\u0658\3\2")
        buf.write("\2\2\u065a\u065b\3\2\2\2\u065b\u0718\3\2\2\2\u065c\u065d")
        buf.write("\7\u0103\2\2\u065d\u0660\7\u012e\2\2\u065e\u065f\t\23")
        buf.write("\2\2\u065f\u0661\5\u0142\u00a2\2\u0660\u065e\3\2\2\2\u0660")
        buf.write("\u0661\3\2\2\2\u0661\u0666\3\2\2\2\u0662\u0664\7\u00b0")
        buf.write("\2\2\u0663\u0662\3\2\2\2\u0663\u0664\3\2\2\2\u0664\u0665")
        buf.write("\3\2\2\2\u0665\u0667\7\u0148\2\2\u0666\u0663\3\2\2\2\u0666")
        buf.write("\u0667\3\2\2\2\u0667\u0718\3\2\2\2\u0668\u0669\7\u0103")
        buf.write("\2\2\u0669\u066a\7\u00d8\2\2\u066a\u066c\5\u0142\u00a2")
        buf.write("\2\u066b\u066d\5\u00ba^\2\u066c\u066b\3\2\2\2\u066c\u066d")
        buf.write("\3\2\2\2\u066d\u0718\3\2\2\2\u066e\u0670\7\u0103\2\2\u066f")
        buf.write("\u0671\5\u019c\u00cf\2\u0670\u066f\3\2\2\2\u0670\u0671")
        buf.write("\3\2\2\2\u0671\u0672\3\2\2\2\u0672\u067a\7\u0093\2\2\u0673")
        buf.write("\u0675\7\u00b0\2\2\u0674\u0673\3\2\2\2\u0674\u0675\3\2")
        buf.write("\2\2\u0675\u0678\3\2\2\2\u0676\u0679\5\u0142\u00a2\2\u0677")
        buf.write("\u0679\7\u0148\2\2\u0678\u0676\3\2\2\2\u0678\u0677\3\2")
        buf.write("\2\2\u0679\u067b\3\2\2\2\u067a\u0674\3\2\2\2\u067a\u067b")
        buf.write("\3\2\2\2\u067b\u0718\3\2\2\2\u067c\u067d\7\u0103\2\2\u067d")
        buf.write("\u067e\7a\2\2\u067e\u067f\7\u010f\2\2\u067f\u0682\5\u0142")
        buf.write("\u00a2\2\u0680\u0681\7B\2\2\u0681\u0683\7\u00fd\2\2\u0682")
        buf.write("\u0680\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u0718\3\2\2\2")
        buf.write("\u0684\u0685\7\u0103\2\2\u0685\u0686\7d\2\2\u0686\u0718")
        buf.write("\7\u00c1\2\2\u0687\u0688\t\30\2\2\u0688\u068a\7\u0092")
        buf.write("\2\2\u0689\u068b\7\u0082\2\2\u068a\u0689\3\2\2\2\u068a")
        buf.write("\u068b\3\2\2\2\u068b\u068c\3\2\2\2\u068c\u0718\5\u00c0")
        buf.write("a\2\u068d\u068e\t\30\2\2\u068e\u0690\5\u00be`\2\u068f")
        buf.write("\u0691\7\u0082\2\2\u0690\u068f\3\2\2\2\u0690\u0691\3\2")
        buf.write("\2\2\u0691\u0692\3\2\2\2\u0692\u0693\5\u0142\u00a2\2\u0693")
        buf.write("\u0718\3\2\2\2\u0694\u0696\t\30\2\2\u0695\u0697\7\u010f")
        buf.write("\2\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u0699")
        buf.write("\3\2\2\2\u0698\u069a\t\31\2\2\u0699\u0698\3\2\2\2\u0699")
        buf.write("\u069a\3\2\2\2\u069a\u069b\3\2\2\2\u069b\u069d\5\u0142")
        buf.write("\u00a2\2\u069c\u069e\5\u00ba^\2\u069d\u069c\3\2\2\2\u069d")
        buf.write("\u069e\3\2\2\2\u069e\u06a0\3\2\2\2\u069f\u06a1\5\u00c2")
        buf.write("b\2\u06a0\u069f\3\2\2\2\u06a0\u06a1\3\2\2\2\u06a1\u0718")
        buf.write("\3\2\2\2\u06a2\u06a4\t\30\2\2\u06a3\u06a5\7\u00e2\2\2")
        buf.write("\u06a4\u06a3\3\2\2\2\u06a4\u06a5\3\2\2\2\u06a5\u06a6\3")
        buf.write("\2\2\2\u06a6\u0718\5\u00b4[\2\u06a7\u06a8\7Y\2\2\u06a8")
        buf.write("\u06a9\7\u00c9\2\2\u06a9\u06aa\5\u00be`\2\u06aa\u06ab")
        buf.write("\5\u0142\u00a2\2\u06ab\u06ac\7\u00a7\2\2\u06ac\u06ad\t")
        buf.write("\32\2\2\u06ad\u0718\3\2\2\2\u06ae\u06af\7Y\2\2\u06af\u06b0")
        buf.write("\7\u00c9\2\2\u06b0\u06b1\7\u010f\2\2\u06b1\u06b2\5\u0142")
        buf.write("\u00a2\2\u06b2\u06b3\7\u00a7\2\2\u06b3\u06b4\t\32\2\2")
        buf.write("\u06b4\u0718\3\2\2\2\u06b5\u06b6\7\u00e9\2\2\u06b6\u06b7")
        buf.write("\7\u010f\2\2\u06b7\u0718\5\u0142\u00a2\2\u06b8\u06c0\7")
        buf.write("\u00e9\2\2\u06b9\u06c1\7\u0148\2\2\u06ba\u06bc\13\2\2")
        buf.write("\2\u06bb\u06ba\3\2\2\2\u06bc\u06bf\3\2\2\2\u06bd\u06be")
        buf.write("\3\2\2\2\u06bd\u06bb\3\2\2\2\u06be\u06c1\3\2\2\2\u06bf")
        buf.write("\u06bd\3\2\2\2\u06c0\u06b9\3\2\2\2\u06c0\u06bd\3\2\2\2")
        buf.write("\u06c1\u0718\3\2\2\2\u06c2\u06c4\7K\2\2\u06c3\u06c5\7")
        buf.write("\u00ad\2\2\u06c4\u06c3\3\2\2\2\u06c4\u06c5\3\2\2\2\u06c5")
        buf.write("\u06c6\3\2\2\2\u06c6\u06c7\7\u010f\2\2\u06c7\u06ca\5\u0142")
        buf.write("\u00a2\2\u06c8\u06c9\7\u00cc\2\2\u06c9\u06cb\5\u00ccg")
        buf.write("\2\u06ca\u06c8\3\2\2\2\u06ca\u06cb\3\2\2\2\u06cb\u06d0")
        buf.write("\3\2\2\2\u06cc\u06ce\7B\2\2\u06cd\u06cc\3\2\2\2\u06cd")
        buf.write("\u06ce\3\2\2\2\u06ce\u06cf\3\2\2\2\u06cf\u06d1\5\u00b4")
        buf.write("[\2\u06d0\u06cd\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1\u0718")
        buf.write("\3\2\2\2\u06d2\u06d3\7\u0122\2\2\u06d3\u06d6\7\u010f\2")
        buf.write("\2\u06d4\u06d5\7\u009a\2\2\u06d5\u06d7\7\177\2\2\u06d6")
        buf.write("\u06d4\3\2\2\2\u06d6\u06d7\3\2\2\2\u06d7\u06d8\3\2\2\2")
        buf.write("\u06d8\u0718\5\u0142\u00a2\2\u06d9\u06da\7Q\2\2\u06da")
        buf.write("\u0718\7K\2\2\u06db\u06dc\7\u00b4\2\2\u06dc\u06de\7i\2")
        buf.write("\2\u06dd\u06df\7\u00b5\2\2\u06de\u06dd\3\2\2\2\u06de\u06df")
        buf.write("\3\2\2\2\u06df\u06e0\3\2\2\2\u06e0\u06e1\7\u00a1\2\2\u06e1")
        buf.write("\u06e3\7\u0148\2\2\u06e2\u06e4\7\u00d5\2\2\u06e3\u06e2")
        buf.write("\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u06e5\3\2\2\2\u06e5")
        buf.write("\u06e6\7\u00a6\2\2\u06e6\u06e7\7\u010f\2\2\u06e7\u06e9")
        buf.write("\5\u0142\u00a2\2\u06e8\u06ea\5\u00ba^\2\u06e9\u06e8\3")
        buf.write("\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u0718\3\2\2\2\u06eb\u06ec")
        buf.write("\7\u011e\2\2\u06ec\u06ed\7\u010f\2\2\u06ed\u06ef\5\u0142")
        buf.write("\u00a2\2\u06ee\u06f0\5\u00ba^\2\u06ef\u06ee\3\2\2\2\u06ef")
        buf.write("\u06f0\3\2\2\2\u06f0\u0718\3\2\2\2\u06f1\u06f2\7\u00c0")
        buf.write("\2\2\u06f2\u06f3\7\u00eb\2\2\u06f3\u06f4\7\u010f\2\2\u06f4")
        buf.write("\u0718\5\u0142\u00a2\2\u06f5\u06f6\t\33\2\2\u06f6\u06fe")
        buf.write("\5\u019c\u00cf\2\u06f7\u06ff\7\u0148\2\2\u06f8\u06fa\13")
        buf.write("\2\2\2\u06f9\u06f8\3\2\2\2\u06fa\u06fd\3\2\2\2\u06fb\u06fc")
        buf.write("\3\2\2\2\u06fb\u06f9\3\2\2\2\u06fc\u06ff\3\2\2\2\u06fd")
        buf.write("\u06fb\3\2\2\2\u06fe\u06f7\3\2\2\2\u06fe\u06fb\3\2\2\2")
        buf.write("\u06ff\u0718\3\2\2\2\u0700\u0701\7\u0100\2\2\u0701\u0705")
        buf.write("\7\u00f2\2\2\u0702\u0704\13\2\2\2\u0703\u0702\3\2\2\2")
        buf.write("\u0704\u0707\3\2\2\2\u0705\u0706\3\2\2\2\u0705\u0703\3")
        buf.write("\2\2\2\u0706\u0718\3\2\2\2\u0707\u0705\3\2\2\2\u0708\u070c")
        buf.write("\7\u0100\2\2\u0709\u070b\13\2\2\2\u070a\u0709\3\2\2\2")
        buf.write("\u070b\u070e\3\2\2\2\u070c\u070d\3\2\2\2\u070c\u070a\3")
        buf.write("\2\2\2\u070d\u0718\3\2\2\2\u070e\u070c\3\2\2\2\u070f\u0718")
        buf.write("\7\u00ed\2\2\u0710\u0714\5\u00a6T\2\u0711\u0713\13\2\2")
        buf.write("\2\u0712\u0711\3\2\2\2\u0713\u0716\3\2\2\2\u0714\u0715")
        buf.write("\3\2\2\2\u0714\u0712\3\2\2\2\u0715\u0718\3\2\2\2\u0716")
        buf.write("\u0714\3\2\2\2\u0717\u0456\3\2\2\2\u0717\u0458\3\2\2\2")
        buf.write("\u0717\u045b\3\2\2\2\u0717\u0460\3\2\2\2\u0717\u0472\3")
        buf.write("\2\2\2\u0717\u0479\3\2\2\2\u0717\u047f\3\2\2\2\u0717\u0489")
        buf.write("\3\2\2\2\u0717\u0495\3\2\2\2\u0717\u04a4\3\2\2\2\u0717")
        buf.write("\u04c9\3\2\2\2\u0717\u04de\3\2\2\2\u0717\u04ed\3\2\2\2")
        buf.write("\u0717\u04fe\3\2\2\2\u0717\u0505\3\2\2\2\u0717\u050e\3")
        buf.write("\2\2\2\u0717\u0517\3\2\2\2\u0717\u0520\3\2\2\2\u0717\u0527")
        buf.write("\3\2\2\2\u0717\u052e\3\2\2\2\u0717\u0535\3\2\2\2\u0717")
        buf.write("\u0540\3\2\2\2\u0717\u054b\3\2\2\2\u0717\u055a\3\2\2\2")
        buf.write("\u0717\u0566\3\2\2\2\u0717\u0574\3\2\2\2\u0717\u057e\3")
        buf.write("\2\2\2\u0717\u058c\3\2\2\2\u0717\u0594\3\2\2\2\u0717\u05a7")
        buf.write("\3\2\2\2\u0717\u05b0\3\2\2\2\u0717\u05b6\3\2\2\2\u0717")
        buf.write("\u05c0\3\2\2\2\u0717\u05c7\3\2\2\2\u0717\u05ea\3\2\2\2")
        buf.write("\u0717\u0600\3\2\2\2\u0717\u0608\3\2\2\2\u0717\u0624\3")
        buf.write("\2\2\2\u0717\u062e\3\2\2\2\u0717\u0633\3\2\2\2\u0717\u063f")
        buf.write("\3\2\2\2\u0717\u064b\3\2\2\2\u0717\u0654\3\2\2\2\u0717")
        buf.write("\u065c\3\2\2\2\u0717\u0668\3\2\2\2\u0717\u066e\3\2\2\2")
        buf.write("\u0717\u067c\3\2\2\2\u0717\u0684\3\2\2\2\u0717\u0687\3")
        buf.write("\2\2\2\u0717\u068d\3\2\2\2\u0717\u0694\3\2\2\2\u0717\u06a2")
        buf.write("\3\2\2\2\u0717\u06a7\3\2\2\2\u0717\u06ae\3\2\2\2\u0717")
        buf.write("\u06b5\3\2\2\2\u0717\u06b8\3\2\2\2\u0717\u06c2\3\2\2\2")
        buf.write("\u0717\u06d2\3\2\2\2\u0717\u06d9\3\2\2\2\u0717\u06db\3")
        buf.write("\2\2\2\u0717\u06eb\3\2\2\2\u0717\u06f1\3\2\2\2\u0717\u06f5")
        buf.write("\3\2\2\2\u0717\u0700\3\2\2\2\u0717\u0708\3\2\2\2\u0717")
        buf.write("\u070f\3\2\2\2\u0717\u0710\3\2\2\2\u0718\u00a5\3\2\2\2")
        buf.write("\u0719\u071a\7a\2\2\u071a\u07c2\7\u00f2\2\2\u071b\u071c")
        buf.write("\7x\2\2\u071c\u07c2\7\u00f2\2\2\u071d\u071f\7\u0095\2")
        buf.write("\2\u071e\u0720\7\u00f2\2\2\u071f\u071e\3\2\2\2\u071f\u0720")
        buf.write("\3\2\2\2\u0720\u07c2\3\2\2\2\u0721\u0723\7\u00ef\2\2\u0722")
        buf.write("\u0724\7\u00f2\2\2\u0723\u0722\3\2\2\2\u0723\u0724\3\2")
        buf.write("\2\2\u0724\u07c2\3\2\2\2\u0725\u0726\7\u0103\2\2\u0726")
        buf.write("\u07c2\7\u0095\2\2\u0727\u0728\7\u0103\2\2\u0728\u072a")
        buf.write("\7\u00f2\2\2\u0729\u072b\7\u0095\2\2\u072a\u0729\3\2\2")
        buf.write("\2\u072a\u072b\3\2\2\2\u072b\u07c2\3\2\2\2\u072c\u072d")
        buf.write("\7\u0103\2\2\u072d\u07c2\7\u00df\2\2\u072e\u072f\7\u0103")
        buf.write("\2\2\u072f\u07c2\7\u00f3\2\2\u0730\u0731\7\u0103\2\2\u0731")
        buf.write("\u0732\7d\2\2\u0732\u07c2\7\u00f3\2\2\u0733\u0734\7\u0081")
        buf.write("\2\2\u0734\u07c2\7\u010f\2\2\u0735\u0736\7\u009c\2\2\u0736")
        buf.write("\u07c2\7\u010f\2\2\u0737\u0738\7\u0103\2\2\u0738\u07c2")
        buf.write("\7\\\2\2\u0739\u073a\7\u0103\2\2\u073a\u073b\7a\2\2\u073b")
        buf.write("\u07c2\7\u010f\2\2\u073c\u073d\7\u0103\2\2\u073d\u07c2")
        buf.write("\7\u011a\2\2\u073e\u073f\7\u0103\2\2\u073f\u07c2\7\u009f")
        buf.write("\2\2\u0740\u0741\7\u0103\2\2\u0741\u07c2\7\u00b8\2\2\u0742")
        buf.write("\u0743\7a\2\2\u0743\u07c2\7\u009e\2\2\u0744\u0745\7x\2")
        buf.write("\2\u0745\u07c2\7\u009e\2\2\u0746\u0747\7;\2\2\u0747\u07c2")
        buf.write("\7\u009e\2\2\u0748\u0749\7\u00b7\2\2\u0749\u07c2\7\u010f")
        buf.write("\2\2\u074a\u074b\7\u00b7\2\2\u074b\u07c2\7j\2\2\u074c")
        buf.write("\u074d\7\u0126\2\2\u074d\u07c2\7\u010f\2\2\u074e\u074f")
        buf.write("\7\u0126\2\2\u074f\u07c2\7j\2\2\u0750\u0751\7a\2\2\u0751")
        buf.write("\u0752\7\u0113\2\2\u0752\u07c2\7\u00ba\2\2\u0753\u0754")
        buf.write("\7x\2\2\u0754\u0755\7\u0113\2\2\u0755\u07c2\7\u00ba\2")
        buf.write("\2\u0756\u0757\7;\2\2\u0757\u0758\7\u010f\2\2\u0758\u0759")
        buf.write("\5\u0144\u00a3\2\u0759\u075a\7\u00c5\2\2\u075a\u075b\7")
        buf.write("S\2\2\u075b\u07c2\3\2\2\2\u075c\u075d\7;\2\2\u075d\u075e")
        buf.write("\7\u010f\2\2\u075e\u075f\5\u0144\u00a3\2\u075f\u0760\7")
        buf.write("S\2\2\u0760\u0761\7J\2\2\u0761\u07c2\3\2\2\2\u0762\u0763")
        buf.write("\7;\2\2\u0763\u0764\7\u010f\2\2\u0764\u0765\5\u0144\u00a3")
        buf.write("\2\u0765\u0766\7\u00c5\2\2\u0766\u0767\7\u0107\2\2\u0767")
        buf.write("\u07c2\3\2\2\2\u0768\u0769\7;\2\2\u0769\u076a\7\u010f")
        buf.write("\2\2\u076a\u076b\5\u0144\u00a3\2\u076b\u076c\7\u0104\2")
        buf.write("\2\u076c\u076d\7J\2\2\u076d\u07c2\3\2\2\2\u076e\u076f")
        buf.write("\7;\2\2\u076f\u0770\7\u010f\2\2\u0770\u0771\5\u0144\u00a3")
        buf.write("\2\u0771\u0772\7\u00c5\2\2\u0772\u0773\7\u0104\2\2\u0773")
        buf.write("\u07c2\3\2\2\2\u0774\u0775\7;\2\2\u0775\u0776\7\u010f")
        buf.write("\2\2\u0776\u0777\5\u0144\u00a3\2\u0777\u0778\7\u00c5\2")
        buf.write("\2\u0778\u0779\7\u010a\2\2\u0779\u077a\7B\2\2\u077a\u077b")
        buf.write("\7t\2\2\u077b\u07c2\3\2\2\2\u077c\u077d\7;\2\2\u077d\u077e")
        buf.write("\7\u010f\2\2\u077e\u077f\5\u0144\u00a3\2\u077f\u0780\7")
        buf.write("\u0100\2\2\u0780\u0781\7\u0104\2\2\u0781\u0782\7\u00b6")
        buf.write("\2\2\u0782\u07c2\3\2\2\2\u0783\u0784\7;\2\2\u0784\u0785")
        buf.write("\7\u010f\2\2\u0785\u0786\5\u0144\u00a3\2\u0786\u0787\7")
        buf.write("~\2\2\u0787\u0788\7\u00d6\2\2\u0788\u07c2\3\2\2\2\u0789")
        buf.write("\u078a\7;\2\2\u078a\u078b\7\u010f\2\2\u078b\u078c\5\u0144")
        buf.write("\u00a3\2\u078c\u078d\7@\2\2\u078d\u078e\7\u00d6\2\2\u078e")
        buf.write("\u07c2\3\2\2\2\u078f\u0790\7;\2\2\u0790\u0791\7\u010f")
        buf.write("\2\2\u0791\u0792\5\u0144\u00a3\2\u0792\u0793\7\u0120\2")
        buf.write("\2\u0793\u0794\7\u00d6\2\2\u0794\u07c2\3\2\2\2\u0795\u0796")
        buf.write("\7;\2\2\u0796\u0797\7\u010f\2\2\u0797\u0798\5\u0144\u00a3")
        buf.write("\2\u0798\u0799\7\u0117\2\2\u0799\u07c2\3\2\2\2\u079a\u079b")
        buf.write("\7;\2\2\u079b\u079c\7\u010f\2\2\u079c\u079e\5\u0144\u00a3")
        buf.write("\2\u079d\u079f\5\u00ba^\2\u079e\u079d\3\2\2\2\u079e\u079f")
        buf.write("\3\2\2\2\u079f\u07a0\3\2\2\2\u07a0\u07a1\7[\2\2\u07a1")
        buf.write("\u07c2\3\2\2\2\u07a2\u07a3\7;\2\2\u07a3\u07a4\7\u010f")
        buf.write("\2\2\u07a4\u07a6\5\u0144\u00a3\2\u07a5\u07a7\5\u00ba^")
        buf.write("\2\u07a6\u07a5\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7\u07a8")
        buf.write("\3\2\2\2\u07a8\u07a9\7^\2\2\u07a9\u07c2\3\2\2\2\u07aa")
        buf.write("\u07ab\7;\2\2\u07ab\u07ac\7\u010f\2\2\u07ac\u07ae\5\u0144")
        buf.write("\u00a3\2\u07ad\u07af\5\u00ba^\2\u07ae\u07ad\3\2\2\2\u07ae")
        buf.write("\u07af\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b1\7\u0100")
        buf.write("\2\2\u07b1\u07b2\7\u0089\2\2\u07b2\u07c2\3\2\2\2\u07b3")
        buf.write("\u07b4\7;\2\2\u07b4\u07b5\7\u010f\2\2\u07b5\u07b7\5\u0144")
        buf.write("\u00a3\2\u07b6\u07b8\5\u00ba^\2\u07b7\u07b6\3\2\2\2\u07b7")
        buf.write("\u07b8\3\2\2\2\u07b8\u07b9\3\2\2\2\u07b9\u07ba\7\u00ec")
        buf.write("\2\2\u07ba\u07bb\7X\2\2\u07bb\u07c2\3\2\2\2\u07bc\u07bd")
        buf.write("\7\u0108\2\2\u07bd\u07c2\7\u0119\2\2\u07be\u07c2\7Z\2")
        buf.write("\2\u07bf\u07c2\7\u00f4\2\2\u07c0\u07c2\7s\2\2\u07c1\u0719")
        buf.write("\3\2\2\2\u07c1\u071b\3\2\2\2\u07c1\u071d\3\2\2\2\u07c1")
        buf.write("\u0721\3\2\2\2\u07c1\u0725\3\2\2\2\u07c1\u0727\3\2\2\2")
        buf.write("\u07c1\u072c\3\2\2\2\u07c1\u072e\3\2\2\2\u07c1\u0730\3")
        buf.write("\2\2\2\u07c1\u0733\3\2\2\2\u07c1\u0735\3\2\2\2\u07c1\u0737")
        buf.write("\3\2\2\2\u07c1\u0739\3\2\2\2\u07c1\u073c\3\2\2\2\u07c1")
        buf.write("\u073e\3\2\2\2\u07c1\u0740\3\2\2\2\u07c1\u0742\3\2\2\2")
        buf.write("\u07c1\u0744\3\2\2\2\u07c1\u0746\3\2\2\2\u07c1\u0748\3")
        buf.write("\2\2\2\u07c1\u074a\3\2\2\2\u07c1\u074c\3\2\2\2\u07c1\u074e")
        buf.write("\3\2\2\2\u07c1\u0750\3\2\2\2\u07c1\u0753\3\2\2\2\u07c1")
        buf.write("\u0756\3\2\2\2\u07c1\u075c\3\2\2\2\u07c1\u0762\3\2\2\2")
        buf.write("\u07c1\u0768\3\2\2\2\u07c1\u076e\3\2\2\2\u07c1\u0774\3")
        buf.write("\2\2\2\u07c1\u077c\3\2\2\2\u07c1\u0783\3\2\2\2\u07c1\u0789")
        buf.write("\3\2\2\2\u07c1\u078f\3\2\2\2\u07c1\u0795\3\2\2\2\u07c1")
        buf.write("\u079a\3\2\2\2\u07c1\u07a2\3\2\2\2\u07c1\u07aa\3\2\2\2")
        buf.write("\u07c1\u07b3\3\2\2\2\u07c1\u07bc\3\2\2\2\u07c1\u07be\3")
        buf.write("\2\2\2\u07c1\u07bf\3\2\2\2\u07c1\u07c0\3\2\2\2\u07c2\u00a7")
        buf.write("\3\2\2\2\u07c3\u07c5\7a\2\2\u07c4\u07c6\7\u0113\2\2\u07c5")
        buf.write("\u07c4\3\2\2\2\u07c5\u07c6\3\2\2\2\u07c6\u07c8\3\2\2\2")
        buf.write("\u07c7\u07c9\7\u0083\2\2\u07c8\u07c7\3\2\2\2\u07c8\u07c9")
        buf.write("\3\2\2\2\u07c9\u07ca\3\2\2\2\u07ca\u07ce\7\u010f\2\2\u07cb")
        buf.write("\u07cc\7\u009a\2\2\u07cc\u07cd\7\u00c5\2\2\u07cd\u07cf")
        buf.write("\7\177\2\2\u07ce\u07cb\3\2\2\2\u07ce\u07cf\3\2\2\2\u07cf")
        buf.write("\u07d0\3\2\2\2\u07d0\u07d1\5\u0142\u00a2\2\u07d1\u00a9")
        buf.write("\3\2\2\2\u07d2\u07d3\7a\2\2\u07d3\u07d5\7\u00cd\2\2\u07d4")
        buf.write("\u07d2\3\2\2\2\u07d4\u07d5\3\2\2\2\u07d5\u07d6\3\2\2\2")
        buf.write("\u07d6\u07d7\7\u00ec\2\2\u07d7\u07d8\7\u010f\2\2\u07d8")
        buf.write("\u07d9\5\u0142\u00a2\2\u07d9\u00ab\3\2\2\2\u07da\u07db")
        buf.write("\7S\2\2\u07db\u07dc\7J\2\2\u07dc\u07e0\5\u012a\u0096\2")
        buf.write("\u07dd\u07de\7\u0107\2\2\u07de\u07df\7J\2\2\u07df\u07e1")
        buf.write("\5\u012e\u0098\2\u07e0\u07dd\3\2\2\2\u07e0\u07e1\3\2\2")
        buf.write("\2\u07e1\u07e2\3\2\2\2\u07e2\u07e3\7\u00a6\2\2\u07e3\u07e4")
        buf.write("\7\u014c\2\2\u07e4\u07e5\7I\2\2\u07e5\u00ad\3\2\2\2\u07e6")
        buf.write("\u07e7\7\u0104\2\2\u07e7\u07e8\7J\2\2\u07e8\u07e9\5\u012a")
        buf.write("\u0096\2\u07e9\u07ec\7\u00c9\2\2\u07ea\u07ed\5\u00d4k")
        buf.write("\2\u07eb\u07ed\5\u00d6l\2\u07ec\u07ea\3\2\2\2\u07ec\u07eb")
        buf.write("\3\2\2\2\u07ed\u07f1\3\2\2\2\u07ee\u07ef\7\u010a\2\2\u07ef")
        buf.write("\u07f0\7B\2\2\u07f0\u07f2\7t\2\2\u07f1\u07ee\3\2\2\2\u07f1")
        buf.write("\u07f2\3\2\2\2\u07f2\u00af\3\2\2\2\u07f3\u07f4\7\u00b6")
        buf.write("\2\2\u07f4\u07f5\7\u0148\2\2\u07f5\u00b1\3\2\2\2\u07f6")
        buf.write("\u07f7\7Y\2\2\u07f7\u07f8\7\u0148\2\2\u07f8\u00b3\3\2")
        buf.write("\2\2\u07f9\u07fb\5\62\32\2\u07fa\u07f9\3\2\2\2\u07fa\u07fb")
        buf.write("\3\2\2\2\u07fb\u07fd\3\2\2\2\u07fc\u07fe\5\u00c4c\2\u07fd")
        buf.write("\u07fc\3\2\2\2\u07fd\u07fe\3\2\2\2\u07fe\u07ff\3\2\2\2")
        buf.write("\u07ff\u0800\5\u00e6t\2\u0800\u0801\5\u00e2r\2\u0801\u00b5")
        buf.write("\3\2\2\2\u0802\u0803\7\u00a3\2\2\u0803\u0805\7\u00d5\2")
        buf.write("\2\u0804\u0806\7\u010f\2\2\u0805\u0804\3\2\2\2\u0805\u0806")
        buf.write("\3\2\2\2\u0806\u0807\3\2\2\2\u0807\u080e\5\u0142\u00a2")
        buf.write("\2\u0808\u080c\5\u00ba^\2\u0809\u080a\7\u009a\2\2\u080a")
        buf.write("\u080b\7\u00c5\2\2\u080b\u080d\7\177\2\2\u080c\u0809\3")
        buf.write("\2\2\2\u080c\u080d\3\2\2\2\u080d\u080f\3\2\2\2\u080e\u0808")
        buf.write("\3\2\2\2\u080e\u080f\3\2\2\2\u080f\u083a\3\2\2\2\u0810")
        buf.write("\u0811\7\u00a3\2\2\u0811\u0813\7\u00a6\2\2\u0812\u0814")
        buf.write("\7\u010f\2\2\u0813\u0812\3\2\2\2\u0813\u0814\3\2\2\2\u0814")
        buf.write("\u0815\3\2\2\2\u0815\u0817\5\u0142\u00a2\2\u0816\u0818")
        buf.write("\5\u00ba^\2\u0817\u0816\3\2\2\2\u0817\u0818\3\2\2\2\u0818")
        buf.write("\u081c\3\2\2\2\u0819\u081a\7\u009a\2\2\u081a\u081b\7\u00c5")
        buf.write("\2\2\u081b\u081d\7\177\2\2\u081c\u0819\3\2\2\2\u081c\u081d")
        buf.write("\3\2\2\2\u081d\u083a\3\2\2\2\u081e\u081f\7\u00a3\2\2\u081f")
        buf.write("\u0821\7\u00d5\2\2\u0820\u0822\7\u00b5\2\2\u0821\u0820")
        buf.write("\3\2\2\2\u0821\u0822\3\2\2\2\u0822\u0823\3\2\2\2\u0823")
        buf.write("\u0824\7u\2\2\u0824\u0826\7\u0148\2\2\u0825\u0827\5\u013e")
        buf.write("\u00a0\2\u0826\u0825\3\2\2\2\u0826\u0827\3\2\2\2\u0827")
        buf.write("\u0829\3\2\2\2\u0828\u082a\5\u00d8m\2\u0829\u0828\3\2")
        buf.write("\2\2\u0829\u082a\3\2\2\2\u082a\u083a\3\2\2\2\u082b\u082c")
        buf.write("\7\u00a3\2\2\u082c\u082e\7\u00d5\2\2\u082d\u082f\7\u00b5")
        buf.write("\2\2\u082e\u082d\3\2\2\2\u082e\u082f\3\2\2\2\u082f\u0830")
        buf.write("\3\2\2\2\u0830\u0832\7u\2\2\u0831\u0833\7\u0148\2\2\u0832")
        buf.write("\u0831\3\2\2\2\u0832\u0833\3\2\2\2\u0833\u0834\3\2\2\2")
        buf.write("\u0834\u0837\5\u00c8e\2\u0835\u0836\7\u00cc\2\2\u0836")
        buf.write("\u0838\5\u00ccg\2\u0837\u0835\3\2\2\2\u0837\u0838\3\2")
        buf.write("\2\2\u0838\u083a\3\2\2\2\u0839\u0802\3\2\2\2\u0839\u0810")
        buf.write("\3\2\2\2\u0839\u081e\3\2\2\2\u0839\u082b\3\2\2\2\u083a")
        buf.write("\u00b7\3\2\2\2\u083b\u083d\5\u00ba^\2\u083c\u083e\5\u00b0")
        buf.write("Y\2\u083d\u083c\3\2\2\2\u083d\u083e\3\2\2\2\u083e\u00b9")
        buf.write("\3\2\2\2\u083f\u0840\7\u00d6\2\2\u0840\u0841\7\5\2\2\u0841")
        buf.write("\u0846\5\u00bc_\2\u0842\u0843\7\3\2\2\u0843\u0845\5\u00bc")
        buf.write("_\2\u0844\u0842\3\2\2\2\u0845\u0848\3\2\2\2\u0846\u0844")
        buf.write("\3\2\2\2\u0846\u0847\3\2\2\2\u0847\u0849\3\2\2\2\u0848")
        buf.write("\u0846\3\2\2\2\u0849\u084a\7\6\2\2\u084a\u00bb\3\2\2\2")
        buf.write("\u084b\u084e\5\u019c\u00cf\2\u084c\u084d\7\u0134\2\2\u084d")
        buf.write("\u084f\5\u015c\u00af\2\u084e\u084c\3\2\2\2\u084e\u084f")
        buf.write("\3\2\2\2\u084f\u00bd\3\2\2\2\u0850\u0851\t\34\2\2\u0851")
        buf.write("\u00bf\3\2\2\2\u0852\u0858\5\u0196\u00cc\2\u0853\u0858")
        buf.write("\7\u0148\2\2\u0854\u0858\5\u015e\u00b0\2\u0855\u0858\5")
        buf.write("\u0162\u00b2\2\u0856\u0858\5\u0164\u00b3\2\u0857\u0852")
        buf.write("\3\2\2\2\u0857\u0853\3\2\2\2\u0857\u0854\3\2\2\2\u0857")
        buf.write("\u0855\3\2\2\2\u0857\u0856\3\2\2\2\u0858\u00c1\3\2\2\2")
        buf.write("\u0859\u085e\5\u019c\u00cf\2\u085a\u085b\7\t\2\2\u085b")
        buf.write("\u085d\5\u019c\u00cf\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("\u00c3\3\2\2\2\u0860\u085e\3\2\2\2\u0861\u0862\7\u0132")
        buf.write("\2\2\u0862\u0867\5\u00c6d\2\u0863\u0864\7\3\2\2\u0864")
        buf.write("\u0866\5\u00c6d\2\u0865\u0863\3\2\2\2\u0866\u0869\3\2")
        buf.write("\2\2\u0867\u0865\3\2\2\2\u0867\u0868\3\2\2\2\u0868\u00c5")
        buf.write("\3\2\2\2\u0869\u0867\3\2\2\2\u086a\u086c\5\u0198\u00cd")
        buf.write("\2\u086b\u086d\5\u012a\u0096\2\u086c\u086b\3\2\2\2\u086c")
        buf.write("\u086d\3\2\2\2\u086d\u086f\3\2\2\2\u086e\u0870\7B\2\2")
        buf.write("\u086f\u086e\3\2\2\2\u086f\u0870\3\2\2\2\u0870\u0871\3")
        buf.write("\2\2\2\u0871\u0872\7\5\2\2\u0872\u0873\5\u00b4[\2\u0873")
        buf.write("\u0874\7\6\2\2\u0874\u00c7\3\2\2\2\u0875\u0876\7\u012b")
        buf.write("\2\2\u0876\u0877\5\u0142\u00a2\2\u0877\u00c9\3\2\2\2\u0878")
        buf.write("\u0879\7\u00cc\2\2\u0879\u0883\5\u00ccg\2\u087a\u087b")
        buf.write("\7\u00d7\2\2\u087b\u087c\7J\2\2\u087c\u0883\5\u014c\u00a7")
        buf.write("\2\u087d\u0883\5\u00acW\2\u087e\u0883\5\u00b0Y\2\u087f")
        buf.write("\u0883\5\u00b2Z\2\u0880\u0881\7\u0112\2\2\u0881\u0883")
        buf.write("\5\u00ccg\2\u0882\u0878\3\2\2\2\u0882\u087a\3\2\2\2\u0882")
        buf.write("\u087d\3\2\2\2\u0882\u087e\3\2\2\2\u0882\u087f\3\2\2\2")
        buf.write("\u0882\u0880\3\2\2\2\u0883\u0886\3\2\2\2\u0884\u0882\3")
        buf.write("\2\2\2\u0884\u0885\3\2\2\2\u0885\u00cb\3\2\2\2\u0886\u0884")
        buf.write("\3\2\2\2\u0887\u0888\7\5\2\2\u0888\u088d\5\u00ceh\2\u0889")
        buf.write("\u088a\7\3\2\2\u088a\u088c\5\u00ceh\2\u088b\u0889\3\2")
        buf.write("\2\2\u088c\u088f\3\2\2\2\u088d\u088b\3\2\2\2\u088d\u088e")
        buf.write("\3\2\2\2\u088e\u0890\3\2\2\2\u088f\u088d\3\2\2\2\u0890")
        buf.write("\u0891\7\6\2\2\u0891\u00cd\3\2\2\2\u0892\u0897\5\u00d0")
        buf.write("i\2\u0893\u0895\7\u0134\2\2\u0894\u0893\3\2\2\2\u0894")
        buf.write("\u0895\3\2\2\2\u0895\u0896\3\2\2\2\u0896\u0898\5\u00d2")
        buf.write("j\2\u0897\u0894\3\2\2\2\u0897\u0898\3\2\2\2\u0898\u00cf")
        buf.write("\3\2\2\2\u0899\u089e\5\u019c\u00cf\2\u089a\u089b\7\t\2")
        buf.write("\2\u089b\u089d\5\u019c\u00cf\2\u089c\u089a\3\2\2\2\u089d")
        buf.write("\u08a0\3\2\2\2\u089e\u089c\3\2\2\2\u089e\u089f\3\2\2\2")
        buf.write("\u089f\u08a3\3\2\2\2\u08a0\u089e\3\2\2\2\u08a1\u08a3\7")
        buf.write("\u0148\2\2\u08a2\u0899\3\2\2\2\u08a2\u08a1\3\2\2\2\u08a3")
        buf.write("\u00d1\3\2\2\2\u08a4\u08a9\7\u014c\2\2\u08a5\u08a9\7\u014e")
        buf.write("\2\2\u08a6\u08a9\5\u0166\u00b4\2\u08a7\u08a9\7\u0148\2")
        buf.write("\2\u08a8\u08a4\3\2\2\2\u08a8\u08a5\3\2\2\2\u08a8\u08a6")
        buf.write("\3\2\2\2\u08a8\u08a7\3\2\2\2\u08a9\u00d3\3\2\2\2\u08aa")
        buf.write("\u08ab\7\5\2\2\u08ab\u08b0\5\u015c\u00af\2\u08ac\u08ad")
        buf.write("\7\3\2\2\u08ad\u08af\5\u015c\u00af\2\u08ae\u08ac\3\2\2")
        buf.write("\2\u08af\u08b2\3\2\2\2\u08b0\u08ae\3\2\2\2\u08b0\u08b1")
        buf.write("\3\2\2\2\u08b1\u08b3\3\2\2\2\u08b2\u08b0\3\2\2\2\u08b3")
        buf.write("\u08b4\7\6\2\2\u08b4\u00d5\3\2\2\2\u08b5\u08b6\7\5\2\2")
        buf.write("\u08b6\u08bb\5\u00d4k\2\u08b7\u08b8\7\3\2\2\u08b8\u08ba")
        buf.write("\5\u00d4k\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\u08be\3\2\2\2")
        buf.write("\u08bd\u08bb\3\2\2\2\u08be\u08bf\7\6\2\2\u08bf\u00d7\3")
        buf.write("\2\2\2\u08c0\u08c1\7\u010a\2\2\u08c1\u08c2\7B\2\2\u08c2")
        buf.write("\u08c7\5\u00dan\2\u08c3\u08c4\7\u010a\2\2\u08c4\u08c5")
        buf.write("\7J\2\2\u08c5\u08c7\5\u00dco\2\u08c6\u08c0\3\2\2\2\u08c6")
        buf.write("\u08c3\3\2\2\2\u08c7\u00d9\3\2\2\2\u08c8\u08c9\7\u00a2")
        buf.write("\2\2\u08c9\u08ca\7\u0148\2\2\u08ca\u08cb\7\u00d1\2\2\u08cb")
        buf.write("\u08ce\7\u0148\2\2\u08cc\u08ce\5\u019c\u00cf\2\u08cd\u08c8")
        buf.write("\3\2\2\2\u08cd\u08cc\3\2\2\2\u08ce\u00db\3\2\2\2\u08cf")
        buf.write("\u08d3\7\u0148\2\2\u08d0\u08d1\7\u0132\2\2\u08d1\u08d2")
        buf.write("\7\u00fe\2\2\u08d2\u08d4\5\u00ccg\2\u08d3\u08d0\3\2\2")
        buf.write("\2\u08d3\u08d4\3\2\2\2\u08d4\u00dd\3\2\2\2\u08d5\u08d6")
        buf.write("\5\u019c\u00cf\2\u08d6\u08d7\7\u0148\2\2\u08d7\u00df\3")
        buf.write("\2\2\2\u08d8\u08d9\5\u00b6\\\2\u08d9\u08da\5\u00e6t\2")
        buf.write("\u08da\u08db\5\u00e2r\2\u08db\u090c\3\2\2\2\u08dc\u08de")
        buf.write("\5\u010e\u0088\2\u08dd\u08df\5\u00e4s\2\u08de\u08dd\3")
        buf.write("\2\2\2\u08df\u08e0\3\2\2\2\u08e0\u08de\3\2\2\2\u08e0\u08e1")
        buf.write("\3\2\2\2\u08e1\u090c\3\2\2\2\u08e2\u08e3\7o\2\2\u08e3")
        buf.write("\u08e4\7\u0090\2\2\u08e4\u08e5\5\u0142\u00a2\2\u08e5\u08e7")
        buf.write("\5\u013c\u009f\2\u08e6\u08e8\5\u0106\u0084\2\u08e7\u08e6")
        buf.write("\3\2\2\2\u08e7\u08e8\3\2\2\2\u08e8\u090c\3\2\2\2\u08e9")
        buf.write("\u08ea\7\u0128\2\2\u08ea\u08eb\5\u0142\u00a2\2\u08eb\u08ec")
        buf.write("\5\u013c\u009f\2\u08ec\u08ee\5\u00f8}\2\u08ed\u08ef\5")
        buf.write("\u0106\u0084\2\u08ee\u08ed\3\2\2\2\u08ee\u08ef\3\2\2\2")
        buf.write("\u08ef\u090c\3\2\2\2\u08f0\u08f1\7\u00bd\2\2\u08f1\u08f2")
        buf.write("\7\u00a6\2\2\u08f2\u08f3\5\u0142\u00a2\2\u08f3\u08f4\5")
        buf.write("\u013c\u009f\2\u08f4\u08fa\7\u012b\2\2\u08f5\u08fb\5\u0142")
        buf.write("\u00a2\2\u08f6\u08f7\7\5\2\2\u08f7\u08f8\5\u00b4[\2\u08f8")
        buf.write("\u08f9\7\6\2\2\u08f9\u08fb\3\2\2\2\u08fa\u08f5\3\2\2\2")
        buf.write("\u08fa\u08f6\3\2\2\2\u08fb\u08fc\3\2\2\2\u08fc\u08fd\5")
        buf.write("\u013c\u009f\2\u08fd\u08fe\7\u00c9\2\2\u08fe\u0902\5\u0154")
        buf.write("\u00ab\2\u08ff\u0901\5\u00fa~\2\u0900\u08ff\3\2\2\2\u0901")
        buf.write("\u0904\3\2\2\2\u0902\u0900\3\2\2\2\u0902\u0903\3\2\2\2")
        buf.write("\u0903\u0908\3\2\2\2\u0904\u0902\3\2\2\2\u0905\u0907\5")
        buf.write("\u00fc\177\2\u0906\u0905\3\2\2\2\u0907\u090a\3\2\2\2\u0908")
        buf.write("\u0906\3\2\2\2\u0908\u0909\3\2\2\2\u0909\u090c\3\2\2\2")
        buf.write("\u090a\u0908\3\2\2\2\u090b\u08d8\3\2\2\2\u090b\u08dc\3")
        buf.write("\2\2\2\u090b\u08e2\3\2\2\2\u090b\u08e9\3\2\2\2\u090b\u08f0")
        buf.write("\3\2\2\2\u090c\u00e1\3\2\2\2\u090d\u090e\7\u00ce\2\2\u090e")
        buf.write("\u090f\7J\2\2\u090f\u0914\5\u00eav\2\u0910\u0911\7\3\2")
        buf.write("\2\u0911\u0913\5\u00eav\2\u0912\u0910\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("\u0918\3\2\2\2\u0916\u0914\3\2\2\2\u0917\u090d\3\2\2\2")
        buf.write("\u0917\u0918\3\2\2\2\u0918\u0923\3\2\2\2\u0919\u091a\7")
        buf.write("R\2\2\u091a\u091b\7J\2\2\u091b\u0920\5\u0152\u00aa\2\u091c")
        buf.write("\u091d\7\3\2\2\u091d\u091f\5\u0152\u00aa\2\u091e\u091c")
        buf.write("\3\2\2\2\u091f\u0922\3\2\2\2\u0920\u091e\3\2\2\2\u0920")
        buf.write("\u0921\3\2\2\2\u0921\u0924\3\2\2\2\u0922\u0920\3\2\2\2")
        buf.write("\u0923\u0919\3\2\2\2\u0923\u0924\3\2\2\2\u0924\u092f\3")
        buf.write("\2\2\2\u0925\u0926\7w\2\2\u0926\u0927\7J\2\2\u0927\u092c")
        buf.write("\5\u0152\u00aa\2\u0928\u0929\7\3\2\2\u0929\u092b\5\u0152")
        buf.write("\u00aa\2\u092a\u0928\3\2\2\2\u092b\u092e\3\2\2\2\u092c")
        buf.write("\u092a\3\2\2\2\u092c\u092d\3\2\2\2\u092d\u0930\3\2\2\2")
        buf.write("\u092e\u092c\3\2\2\2\u092f\u0925\3\2\2\2\u092f\u0930\3")
        buf.write("\2\2\2\u0930\u093b\3\2\2\2\u0931\u0932\7\u0106\2\2\u0932")
        buf.write("\u0933\7J\2\2\u0933\u0938\5\u00eav\2\u0934\u0935\7\3\2")
        buf.write("\2\u0935\u0937\5\u00eav\2\u0936\u0934\3\2\2\2\u0937\u093a")
        buf.write("\3\2\2\2\u0938\u0936\3\2\2\2\u0938\u0939\3\2\2\2\u0939")
        buf.write("\u093c\3\2\2\2\u093a\u0938\3\2\2\2\u093b\u0931\3\2\2\2")
        buf.write("\u093b\u093c\3\2\2\2\u093c\u093e\3\2\2\2\u093d\u093f\5")
        buf.write("\u0188\u00c5\2\u093e\u093d\3\2\2\2\u093e\u093f\3\2\2\2")
        buf.write("\u093f\u0945\3\2\2\2\u0940\u0943\7\u00b1\2\2\u0941\u0944")
        buf.write("\7:\2\2\u0942\u0944\5\u0152\u00aa\2\u0943\u0941\3\2\2")
        buf.write("\2\u0943\u0942\3\2\2\2\u0944\u0946\3\2\2\2\u0945\u0940")
        buf.write("\3\2\2\2\u0945\u0946\3\2\2\2\u0946\u00e3\3\2\2\2\u0947")
        buf.write("\u0948\5\u00b6\\\2\u0948\u0949\5\u00eex\2\u0949\u00e5")
        buf.write("\3\2\2\2\u094a\u094b\bt\1\2\u094b\u094e\5\u00e8u\2\u094c")
        buf.write("\u094e\5\n\6\2\u094d\u094a\3\2\2\2\u094d\u094c\3\2\2\2")
        buf.write("\u094e\u0966\3\2\2\2\u094f\u0950\f\5\2\2\u0950\u0951\6")
        buf.write("t\5\2\u0951\u0953\t\35\2\2\u0952\u0954\5\u011c\u008f\2")
        buf.write("\u0953\u0952\3\2\2\2\u0953\u0954\3\2\2\2\u0954\u0955\3")
        buf.write("\2\2\2\u0955\u0965\5\u00e6t\6\u0956\u0957\f\4\2\2\u0957")
        buf.write("\u0958\6t\7\2\u0958\u095a\7\u00a4\2\2\u0959\u095b\5\u011c")
        buf.write("\u008f\2\u095a\u0959\3\2\2\2\u095a\u095b\3\2\2\2\u095b")
        buf.write("\u095c\3\2\2\2\u095c\u0965\5\u00e6t\5\u095d\u095e\f\3")
        buf.write("\2\2\u095e\u095f\6t\t\2\u095f\u0961\t\36\2\2\u0960\u0962")
        buf.write("\5\u011c\u008f\2\u0961\u0960\3\2\2\2\u0961\u0962\3\2\2")
        buf.write("\2\u0962\u0963\3\2\2\2\u0963\u0965\5\u00e6t\4\u0964\u094f")
        buf.write("\3\2\2\2\u0964\u0956\3\2\2\2\u0964\u095d\3\2\2\2\u0965")
        buf.write("\u0968\3\2\2\2\u0966\u0964\3\2\2\2\u0966\u0967\3\2\2\2")
        buf.write("\u0967\u00e7\3\2\2\2\u0968\u0966\3\2\2\2\u0969\u096f\5")
        buf.write("\u00f0y\2\u096a\u096f\5\u00ecw\2\u096b\u096c\7\u010f\2")
        buf.write("\2\u096c\u096f\5\u0142\u00a2\2\u096d\u096f\5\u0138\u009d")
        buf.write("\2\u096e\u0969\3\2\2\2\u096e\u096a\3\2\2\2\u096e\u096b")
        buf.write("\3\2\2\2\u096e\u096d\3\2\2\2\u096f\u00e9\3\2\2\2\u0970")
        buf.write("\u0972\5\u0152\u00aa\2\u0971\u0973\t\r\2\2\u0972\u0971")
        buf.write("\3\2\2\2\u0972\u0973\3\2\2\2\u0973\u0976\3\2\2\2\u0974")
        buf.write("\u0975\7\u00c7\2\2\u0975\u0977\t\5\2\2\u0976\u0974\3\2")
        buf.write("\2\2\u0976\u0977\3\2\2\2\u0977\u00eb\3\2\2\2\u0978\u097a")
        buf.write("\5\u010e\u0088\2\u0979\u097b\5\u00eex\2\u097a\u0979\3")
        buf.write("\2\2\2\u097b\u097c\3\2\2\2\u097c\u097a\3\2\2\2\u097c\u097d")
        buf.write("\3\2\2\2\u097d\u00ed\3\2\2\2\u097e\u0980\5\u00f4{\2\u097f")
        buf.write("\u0981\5\u0106\u0084\2\u0980\u097f\3\2\2\2\u0980\u0981")
        buf.write("\3\2\2\2\u0981\u0982\3\2\2\2\u0982\u0983\5\u00e2r\2\u0983")
        buf.write("\u099a\3\2\2\2\u0984\u0988\5\u00f6|\2\u0985\u0987\5\u011a")
        buf.write("\u008e\2\u0986\u0985\3\2\2\2\u0987\u098a\3\2\2\2\u0988")
        buf.write("\u0986\3\2\2\2\u0988\u0989\3\2\2\2\u0989\u098c\3\2\2\2")
        buf.write("\u098a\u0988\3\2\2\2\u098b\u098d\5\u0106\u0084\2\u098c")
        buf.write("\u098b\3\2\2\2\u098c\u098d\3\2\2\2\u098d\u098f\3\2\2\2")
        buf.write("\u098e\u0990\5\u0110\u0089\2\u098f\u098e\3\2\2\2\u098f")
        buf.write("\u0990\3\2\2\2\u0990\u0992\3\2\2\2\u0991\u0993\5\u0108")
        buf.write("\u0085\2\u0992\u0991\3\2\2\2\u0992\u0993\3\2\2\2\u0993")
        buf.write("\u0995\3\2\2\2\u0994\u0996\5\u0188\u00c5\2\u0995\u0994")
        buf.write("\3\2\2\2\u0995\u0996\3\2\2\2\u0996\u0997\3\2\2\2\u0997")
        buf.write("\u0998\5\u00e2r\2\u0998\u099a\3\2\2\2\u0999\u097e\3\2")
        buf.write("\2\2\u0999\u0984\3\2\2\2\u099a\u00ef\3\2\2\2\u099b\u099c")
        buf.write("\5\u00f4{\2\u099c\u099e\5\u00f2z\2\u099d\u099f\5\u0106")
        buf.write("\u0084\2\u099e\u099d\3\2\2\2\u099e\u099f\3\2\2\2\u099f")
        buf.write("\u09b5\3\2\2\2\u09a0\u09a1\5\u00f6|\2\u09a1\u09a5\5\u00f2")
        buf.write("z\2\u09a2\u09a4\5\u011a\u008e\2\u09a3\u09a2\3\2\2\2\u09a4")
        buf.write("\u09a7\3\2\2\2\u09a5\u09a3\3\2\2\2\u09a5\u09a6\3\2\2\2")
        buf.write("\u09a6\u09a9\3\2\2\2\u09a7\u09a5\3\2\2\2\u09a8\u09aa\5")
        buf.write("\u0106\u0084\2\u09a9\u09a8\3\2\2\2\u09a9\u09aa\3\2\2\2")
        buf.write("\u09aa\u09ac\3\2\2\2\u09ab\u09ad\5\u0110\u0089\2\u09ac")
        buf.write("\u09ab\3\2\2\2\u09ac\u09ad\3\2\2\2\u09ad\u09af\3\2\2\2")
        buf.write("\u09ae\u09b0\5\u0108\u0085\2\u09af\u09ae\3\2\2\2\u09af")
        buf.write("\u09b0\3\2\2\2\u09b0\u09b2\3\2\2\2\u09b1\u09b3\5\u0188")
        buf.write("\u00c5\2\u09b2\u09b1\3\2\2\2\u09b2\u09b3\3\2\2\2\u09b3")
        buf.write("\u09b5\3\2\2\2\u09b4\u099b\3\2\2\2\u09b4\u09a0\3\2\2\2")
        buf.write("\u09b5\u00f1\3\2\2\2\u09b6\u09b8\5\u010e\u0088\2\u09b7")
        buf.write("\u09b6\3\2\2\2\u09b7\u09b8\3\2\2\2\u09b8\u00f3\3\2\2\2")
        buf.write("\u09b9\u09ba\7\u00fa\2\2\u09ba\u09bb\7\u011b\2\2\u09bb")
        buf.write("\u09bc\7\5\2\2\u09bc\u09bd\5\u014a\u00a6\2\u09bd\u09be")
        buf.write("\7\6\2\2\u09be\u09c4\3\2\2\2\u09bf\u09c0\7\u00bb\2\2\u09c0")
        buf.write("\u09c4\5\u014a\u00a6\2\u09c1\u09c2\7\u00e7\2\2\u09c2\u09c4")
        buf.write("\5\u014a\u00a6\2\u09c3\u09b9\3\2\2\2\u09c3\u09bf\3\2\2")
        buf.write("\2\u09c3\u09c1\3\2\2\2\u09c4\u09c6\3\2\2\2\u09c5\u09c7")
        buf.write("\5\u013e\u00a0\2\u09c6\u09c5\3\2\2\2\u09c6\u09c7\3\2\2")
        buf.write("\2\u09c7\u09ca\3\2\2\2\u09c8\u09c9\7\u00e5\2\2\u09c9\u09cb")
        buf.write("\7\u0148\2\2\u09ca\u09c8\3\2\2\2\u09ca\u09cb\3\2\2\2\u09cb")
        buf.write("\u09cc\3\2\2\2\u09cc\u09cd\7\u012b\2\2\u09cd\u09da\7\u0148")
        buf.write("\2\2\u09ce\u09d8\7B\2\2\u09cf\u09d9\5\u012c\u0097\2\u09d0")
        buf.write("\u09d9\5\u017e\u00c0\2\u09d1\u09d4\7\5\2\2\u09d2\u09d5")
        buf.write("\5\u012c\u0097\2\u09d3\u09d5\5\u017e\u00c0\2\u09d4\u09d2")
        buf.write("\3\2\2\2\u09d4\u09d3\3\2\2\2\u09d5\u09d6\3\2\2\2\u09d6")
        buf.write("\u09d7\7\6\2\2\u09d7\u09d9\3\2\2\2\u09d8\u09cf\3\2\2\2")
        buf.write("\u09d8\u09d0\3\2\2\2\u09d8\u09d1\3\2\2\2\u09d9\u09db\3")
        buf.write("\2\2\2\u09da\u09ce\3\2\2\2\u09da\u09db\3\2\2\2\u09db\u09dd")
        buf.write("\3\2\2\2\u09dc\u09de\5\u013e\u00a0\2\u09dd\u09dc\3\2\2")
        buf.write("\2\u09dd\u09de\3\2\2\2\u09de\u09e1\3\2\2\2\u09df\u09e0")
        buf.write("\7\u00e4\2\2\u09e0\u09e2\7\u0148\2\2\u09e1\u09df\3\2\2")
        buf.write("\2\u09e1\u09e2\3\2\2\2\u09e2\u00f5\3\2\2\2\u09e3\u09e7")
        buf.write("\7\u00fa\2\2\u09e4\u09e6\5\u010a\u0086\2\u09e5\u09e4\3")
        buf.write("\2\2\2\u09e6\u09e9\3\2\2\2\u09e7\u09e5\3\2\2\2\u09e7\u09e8")
        buf.write("\3\2\2\2\u09e8\u09eb\3\2\2\2\u09e9\u09e7\3\2\2\2\u09ea")
        buf.write("\u09ec\5\u011c\u008f\2\u09eb\u09ea\3\2\2\2\u09eb\u09ec")
        buf.write("\3\2\2\2\u09ec\u09ed\3\2\2\2\u09ed\u09ee\5\u014a\u00a6")
        buf.write("\2\u09ee\u00f7\3\2\2\2\u09ef\u09f0\7\u0100\2\2\u09f0\u09f1")
        buf.write("\5\u0102\u0082\2\u09f1\u00f9\3\2\2\2\u09f2\u09f3\7\u012f")
        buf.write("\2\2\u09f3\u09f6\7\u00bc\2\2\u09f4\u09f5\7=\2\2\u09f5")
        buf.write("\u09f7\5\u0154\u00ab\2\u09f6\u09f4\3\2\2\2\u09f6\u09f7")
        buf.write("\3\2\2\2\u09f7\u09f8\3\2\2\2\u09f8\u09f9\7\u0115\2\2\u09f9")
        buf.write("\u09fa\5\u00fe\u0080\2\u09fa\u00fb\3\2\2\2\u09fb\u09fc")
        buf.write("\7\u012f\2\2\u09fc\u09fd\7\u00c5\2\2\u09fd\u0a00\7\u00bc")
        buf.write("\2\2\u09fe\u09ff\7=\2\2\u09ff\u0a01\5\u0154\u00ab\2\u0a00")
        buf.write("\u09fe\3\2\2\2\u0a00\u0a01\3\2\2\2\u0a01\u0a02\3\2\2\2")
        buf.write("\u0a02\u0a03\7\u0115\2\2\u0a03\u0a04\5\u0100\u0081\2\u0a04")
        buf.write("\u00fd\3\2\2\2\u0a05\u0a0d\7o\2\2\u0a06\u0a07\7\u0128")
        buf.write("\2\2\u0a07\u0a08\7\u0100\2\2\u0a08\u0a0d\7\u013f\2\2\u0a09")
        buf.write("\u0a0a\7\u0128\2\2\u0a0a\u0a0b\7\u0100\2\2\u0a0b\u0a0d")
        buf.write("\5\u0102\u0082\2\u0a0c\u0a05\3\2\2\2\u0a0c\u0a06\3\2\2")
        buf.write("\2\u0a0c\u0a09\3\2\2\2\u0a0d\u00ff\3\2\2\2\u0a0e\u0a0f")
        buf.write("\7\u00a3\2\2\u0a0f\u0a21\7\u013f\2\2\u0a10\u0a11\7\u00a3")
        buf.write("\2\2\u0a11\u0a12\7\5\2\2\u0a12\u0a13\5\u0140\u00a1\2\u0a13")
        buf.write("\u0a14\7\6\2\2\u0a14\u0a15\7\u012c\2\2\u0a15\u0a16\7\5")
        buf.write("\2\2\u0a16\u0a1b\5\u0152\u00aa\2\u0a17\u0a18\7\3\2\2\u0a18")
        buf.write("\u0a1a\5\u0152\u00aa\2\u0a19\u0a17\3\2\2\2\u0a1a\u0a1d")
        buf.write("\3\2\2\2\u0a1b\u0a19\3\2\2\2\u0a1b\u0a1c\3\2\2\2\u0a1c")
        buf.write("\u0a1e\3\2\2\2\u0a1d\u0a1b\3\2\2\2\u0a1e\u0a1f\7\6\2\2")
        buf.write("\u0a1f\u0a21\3\2\2\2\u0a20\u0a0e\3\2\2\2\u0a20\u0a10\3")
        buf.write("\2\2\2\u0a21\u0101\3\2\2\2\u0a22\u0a27\5\u0104\u0083\2")
        buf.write("\u0a23\u0a24\7\3\2\2\u0a24\u0a26\5\u0104\u0083\2\u0a25")
        buf.write("\u0a23\3\2\2\2\u0a26\u0a29\3\2\2\2\u0a27\u0a25\3\2\2\2")
        buf.write("\u0a27\u0a28\3\2\2\2\u0a28\u0103\3\2\2\2\u0a29\u0a27\3")
        buf.write("\2\2\2\u0a2a\u0a2b\5\u0142\u00a2\2\u0a2b\u0a2c\7\u0134")
        buf.write("\2\2\u0a2c\u0a2d\5\u0152\u00aa\2\u0a2d\u0105\3\2\2\2\u0a2e")
        buf.write("\u0a2f\7\u0130\2\2\u0a2f\u0a30\5\u0154\u00ab\2\u0a30\u0107")
        buf.write("\3\2\2\2\u0a31\u0a32\7\u0098\2\2\u0a32\u0a33\5\u0154\u00ab")
        buf.write("\2\u0a33\u0109\3\2\2\2\u0a34\u0a35\7\20\2\2\u0a35\u0a3c")
        buf.write("\5\u010c\u0087\2\u0a36\u0a38\7\3\2\2\u0a37\u0a36\3\2\2")
        buf.write("\2\u0a37\u0a38\3\2\2\2\u0a38\u0a39\3\2\2\2\u0a39\u0a3b")
        buf.write("\5\u010c\u0087\2\u0a3a\u0a37\3\2\2\2\u0a3b\u0a3e\3\2\2")
        buf.write("\2\u0a3c\u0a3a\3\2\2\2\u0a3c\u0a3d\3\2\2\2\u0a3d\u0a3f")
        buf.write("\3\2\2\2\u0a3e\u0a3c\3\2\2\2\u0a3f\u0a40\7\21\2\2\u0a40")
        buf.write("\u010b\3\2\2\2\u0a41\u0a4f\5\u019c\u00cf\2\u0a42\u0a43")
        buf.write("\5\u019c\u00cf\2\u0a43\u0a44\7\5\2\2\u0a44\u0a49\5\u015a")
        buf.write("\u00ae\2\u0a45\u0a46\7\3\2\2\u0a46\u0a48\5\u015a\u00ae")
        buf.write("\2\u0a47\u0a45\3\2\2\2\u0a48\u0a4b\3\2\2\2\u0a49\u0a47")
        buf.write("\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a4c\3\2\2\2\u0a4b")
        buf.write("\u0a49\3\2\2\2\u0a4c\u0a4d\7\6\2\2\u0a4d\u0a4f\3\2\2\2")
        buf.write("\u0a4e\u0a41\3\2\2\2\u0a4e\u0a42\3\2\2\2\u0a4f\u010d\3")
        buf.write("\2\2\2\u0a50\u0a51\7\u0090\2\2\u0a51\u0a56\5\u011e\u0090")
        buf.write("\2\u0a52\u0a53\7\3\2\2\u0a53\u0a55\5\u011e\u0090\2\u0a54")
        buf.write("\u0a52\3\2\2\2\u0a55\u0a58\3\2\2\2\u0a56\u0a54\3\2\2\2")
        buf.write("\u0a56\u0a57\3\2\2\2\u0a57\u0a5c\3\2\2\2\u0a58\u0a56\3")
        buf.write("\2\2\2\u0a59\u0a5b\5\u011a\u008e\2\u0a5a\u0a59\3\2\2\2")
        buf.write("\u0a5b\u0a5e\3\2\2\2\u0a5c\u0a5a\3\2\2\2\u0a5c\u0a5d\3")
        buf.write("\2\2\2\u0a5d\u0a60\3\2\2\2\u0a5e\u0a5c\3\2\2\2\u0a5f\u0a61")
        buf.write("\5\u0114\u008b\2\u0a60\u0a5f\3\2\2\2\u0a60\u0a61\3\2\2")
        buf.write("\2\u0a61\u010f\3\2\2\2\u0a62\u0a63\7\u0096\2\2\u0a63\u0a64")
        buf.write("\7J\2\2\u0a64\u0a69\5\u0152\u00aa\2\u0a65\u0a66\7\3\2")
        buf.write("\2\u0a66\u0a68\5\u0152\u00aa\2\u0a67\u0a65\3\2\2\2\u0a68")
        buf.write("\u0a6b\3\2\2\2\u0a69\u0a67\3\2\2\2\u0a69\u0a6a\3\2\2\2")
        buf.write("\u0a6a\u0a7d\3\2\2\2\u0a6b\u0a69\3\2\2\2\u0a6c\u0a6d\7")
        buf.write("\u0132\2\2\u0a6d\u0a7e\7\u00f5\2\2\u0a6e\u0a6f\7\u0132")
        buf.write("\2\2\u0a6f\u0a7e\7c\2\2\u0a70\u0a71\7\u0097\2\2\u0a71")
        buf.write("\u0a72\7\u0102\2\2\u0a72\u0a73\7\5\2\2\u0a73\u0a78\5\u0112")
        buf.write("\u008a\2\u0a74\u0a75\7\3\2\2\u0a75\u0a77\5\u0112\u008a")
        buf.write("\2\u0a76\u0a74\3\2\2\2\u0a77\u0a7a\3\2\2\2\u0a78\u0a76")
        buf.write("\3\2\2\2\u0a78\u0a79\3\2\2\2\u0a79\u0a7b\3\2\2\2\u0a7a")
        buf.write("\u0a78\3\2\2\2\u0a7b\u0a7c\7\6\2\2\u0a7c\u0a7e\3\2\2\2")
        buf.write("\u0a7d\u0a6c\3\2\2\2\u0a7d\u0a6e\3\2\2\2\u0a7d\u0a70\3")
        buf.write("\2\2\2\u0a7d\u0a7e\3\2\2\2\u0a7e\u0a8f\3\2\2\2\u0a7f\u0a80")
        buf.write("\7\u0096\2\2\u0a80\u0a81\7J\2\2\u0a81\u0a82\7\u0097\2")
        buf.write("\2\u0a82\u0a83\7\u0102\2\2\u0a83\u0a84\7\5\2\2\u0a84\u0a89")
        buf.write("\5\u0112\u008a\2\u0a85\u0a86\7\3\2\2\u0a86\u0a88\5\u0112")
        buf.write("\u008a\2\u0a87\u0a85\3\2\2\2\u0a88\u0a8b\3\2\2\2\u0a89")
        buf.write("\u0a87\3\2\2\2\u0a89\u0a8a\3\2\2\2\u0a8a\u0a8c\3\2\2\2")
        buf.write("\u0a8b\u0a89\3\2\2\2\u0a8c\u0a8d\7\6\2\2\u0a8d\u0a8f\3")
        buf.write("\2\2\2\u0a8e\u0a62\3\2\2\2\u0a8e\u0a7f\3\2\2\2\u0a8f\u0111")
        buf.write("\3\2\2\2\u0a90\u0a99\7\5\2\2\u0a91\u0a96\5\u0152\u00aa")
        buf.write("\2\u0a92\u0a93\7\3\2\2\u0a93\u0a95\5\u0152\u00aa\2\u0a94")
        buf.write("\u0a92\3\2\2\2\u0a95\u0a98\3\2\2\2\u0a96\u0a94\3\2\2\2")
        buf.write("\u0a96\u0a97\3\2\2\2\u0a97\u0a9a\3\2\2\2\u0a98\u0a96\3")
        buf.write("\2\2\2\u0a99\u0a91\3\2\2\2\u0a99\u0a9a\3\2\2\2\u0a9a\u0a9b")
        buf.write("\3\2\2\2\u0a9b\u0a9e\7\6\2\2\u0a9c\u0a9e\5\u0152\u00aa")
        buf.write("\2\u0a9d\u0a90\3\2\2\2\u0a9d\u0a9c\3\2\2\2\u0a9e\u0113")
        buf.write("\3\2\2\2\u0a9f\u0aa0\7\u00da\2\2\u0aa0\u0aa1\7\5\2\2\u0aa1")
        buf.write("\u0aa2\5\u014a\u00a6\2\u0aa2\u0aa3\7\u008c\2\2\u0aa3\u0aa4")
        buf.write("\5\u0116\u008c\2\u0aa4\u0aa5\7\u009d\2\2\u0aa5\u0aa6\7")
        buf.write("\5\2\2\u0aa6\u0aab\5\u0118\u008d\2\u0aa7\u0aa8\7\3\2\2")
        buf.write("\u0aa8\u0aaa\5\u0118\u008d\2\u0aa9\u0aa7\3\2\2\2\u0aaa")
        buf.write("\u0aad\3\2\2\2\u0aab\u0aa9\3\2\2\2\u0aab\u0aac\3\2\2\2")
        buf.write("\u0aac\u0aae\3\2\2\2\u0aad\u0aab\3\2\2\2\u0aae\u0aaf\7")
        buf.write("\6\2\2\u0aaf\u0ab0\7\6\2\2\u0ab0\u0115\3\2\2\2\u0ab1\u0abe")
        buf.write("\5\u019c\u00cf\2\u0ab2\u0ab3\7\5\2\2\u0ab3\u0ab8\5\u019c")
        buf.write("\u00cf\2\u0ab4\u0ab5\7\3\2\2\u0ab5\u0ab7\5\u019c\u00cf")
        buf.write("\2\u0ab6\u0ab4\3\2\2\2\u0ab7\u0aba\3\2\2\2\u0ab8\u0ab6")
        buf.write("\3\2\2\2\u0ab8\u0ab9\3\2\2\2\u0ab9\u0abb\3\2\2\2\u0aba")
        buf.write("\u0ab8\3\2\2\2\u0abb\u0abc\7\6\2\2\u0abc\u0abe\3\2\2\2")
        buf.write("\u0abd\u0ab1\3\2\2\2\u0abd\u0ab2\3\2\2\2\u0abe\u0117\3")
        buf.write("\2\2\2\u0abf\u0ac4\5\u0152\u00aa\2\u0ac0\u0ac2\7B\2\2")
        buf.write("\u0ac1\u0ac0\3\2\2\2\u0ac1\u0ac2\3\2\2\2\u0ac2\u0ac3\3")
        buf.write("\2\2\2\u0ac3\u0ac5\5\u019c\u00cf\2\u0ac4\u0ac1\3\2\2\2")
        buf.write("\u0ac4\u0ac5\3\2\2\2\u0ac5\u0119\3\2\2\2\u0ac6\u0ac7\7")
        buf.write("\u00ac\2\2\u0ac7\u0ac9\7\u012d\2\2\u0ac8\u0aca\7\u00d0")
        buf.write("\2\2\u0ac9\u0ac8\3\2\2\2\u0ac9\u0aca\3\2\2\2\u0aca\u0acb")
        buf.write("\3\2\2\2\u0acb\u0acc\5\u0196\u00cc\2\u0acc\u0ad5\7\5\2")
        buf.write("\2\u0acd\u0ad2\5\u0152\u00aa\2\u0ace\u0acf\7\3\2\2\u0acf")
        buf.write("\u0ad1\5\u0152\u00aa\2\u0ad0\u0ace\3\2\2\2\u0ad1\u0ad4")
        buf.write("\3\2\2\2\u0ad2\u0ad0\3\2\2\2\u0ad2\u0ad3\3\2\2\2\u0ad3")
        buf.write("\u0ad6\3\2\2\2\u0ad4\u0ad2\3\2\2\2\u0ad5\u0acd\3\2\2\2")
        buf.write("\u0ad5\u0ad6\3\2\2\2\u0ad6\u0ad7\3\2\2\2\u0ad7\u0ad8\7")
        buf.write("\6\2\2\u0ad8\u0ae4\5\u019c\u00cf\2\u0ad9\u0adb\7B\2\2")
        buf.write("\u0ada\u0ad9\3\2\2\2\u0ada\u0adb\3\2\2\2\u0adb\u0adc\3")
        buf.write("\2\2\2\u0adc\u0ae1\5\u019c\u00cf\2\u0add\u0ade\7\3\2\2")
        buf.write("\u0ade\u0ae0\5\u019c\u00cf\2\u0adf\u0add\3\2\2\2\u0ae0")
        buf.write("\u0ae3\3\2\2\2\u0ae1\u0adf\3\2\2\2\u0ae1\u0ae2\3\2\2\2")
        buf.write("\u0ae2\u0ae5\3\2\2\2\u0ae3\u0ae1\3\2\2\2\u0ae4\u0ada\3")
        buf.write("\2\2\2\u0ae4\u0ae5\3\2\2\2\u0ae5\u011b\3\2\2\2\u0ae6\u0ae7")
        buf.write("\t\37\2\2\u0ae7\u011d\3\2\2\2\u0ae8\u0aec\5\u0136\u009c")
        buf.write("\2\u0ae9\u0aeb\5\u0120\u0091\2\u0aea\u0ae9\3\2\2\2\u0aeb")
        buf.write("\u0aee\3\2\2\2\u0aec\u0aea\3\2\2\2\u0aec\u0aed\3\2\2\2")
        buf.write("\u0aed\u011f\3\2\2\2\u0aee\u0aec\3\2\2\2\u0aef\u0af0\5")
        buf.write("\u0122\u0092\2\u0af0\u0af1\7\u00a9\2\2\u0af1\u0af3\5\u0136")
        buf.write("\u009c\2\u0af2\u0af4\5\u0124\u0093\2\u0af3\u0af2\3\2\2")
        buf.write("\2\u0af3\u0af4\3\2\2\2\u0af4\u0afb\3\2\2\2\u0af5\u0af6")
        buf.write("\7\u00c3\2\2\u0af6\u0af7\5\u0122\u0092\2\u0af7\u0af8\7")
        buf.write("\u00a9\2\2\u0af8\u0af9\5\u0136\u009c\2\u0af9\u0afb\3\2")
        buf.write("\2\2\u0afa\u0aef\3\2\2\2\u0afa\u0af5\3\2\2\2\u0afb\u0121")
        buf.write("\3\2\2\2\u0afc\u0afe\7\u00a0\2\2\u0afd\u0afc\3\2\2\2\u0afd")
        buf.write("\u0afe\3\2\2\2\u0afe\u0b15\3\2\2\2\u0aff\u0b15\7b\2\2")
        buf.write("\u0b00\u0b02\7\u00af\2\2\u0b01\u0b03\7\u00d0\2\2\u0b02")
        buf.write("\u0b01\3\2\2\2\u0b02\u0b03\3\2\2\2\u0b03\u0b15\3\2\2\2")
        buf.write("\u0b04\u0b06\7\u00af\2\2\u0b05\u0b04\3\2\2\2\u0b05\u0b06")
        buf.write("\3\2\2\2\u0b06\u0b07\3\2\2\2\u0b07\u0b15\7\u00fb\2\2\u0b08")
        buf.write("\u0b0a\7\u00f0\2\2\u0b09\u0b0b\7\u00d0\2\2\u0b0a\u0b09")
        buf.write("\3\2\2\2\u0b0a\u0b0b\3\2\2\2\u0b0b\u0b15\3\2\2\2\u0b0c")
        buf.write("\u0b0e\7\u0091\2\2\u0b0d\u0b0f\7\u00d0\2\2\u0b0e\u0b0d")
        buf.write("\3\2\2\2\u0b0e\u0b0f\3\2\2\2\u0b0f\u0b15\3\2\2\2\u0b10")
        buf.write("\u0b12\7\u00af\2\2\u0b11\u0b10\3\2\2\2\u0b11\u0b12\3\2")
        buf.write("\2\2\u0b12\u0b13\3\2\2\2\u0b13\u0b15\7>\2\2\u0b14\u0afd")
        buf.write("\3\2\2\2\u0b14\u0aff\3\2\2\2\u0b14\u0b00\3\2\2\2\u0b14")
        buf.write("\u0b05\3\2\2\2\u0b14\u0b08\3\2\2\2\u0b14\u0b0c\3\2\2\2")
        buf.write("\u0b14\u0b11\3\2\2\2\u0b15\u0123\3\2\2\2\u0b16\u0b17\7")
        buf.write("\u00c9\2\2\u0b17\u0b1b\5\u0154\u00ab\2\u0b18\u0b19\7\u012b")
        buf.write("\2\2\u0b19\u0b1b\5\u012a\u0096\2\u0b1a\u0b16\3\2\2\2\u0b1a")
        buf.write("\u0b18\3\2\2\2\u0b1b\u0125\3\2\2\2\u0b1c\u0b1d\7\u0111")
        buf.write("\2\2\u0b1d\u0b1f\7\5\2\2\u0b1e\u0b20\5\u0128\u0095\2\u0b1f")
        buf.write("\u0b1e\3\2\2\2\u0b1f\u0b20\3\2\2\2\u0b20\u0b21\3\2\2\2")
        buf.write("\u0b21\u0b22\7\6\2\2\u0b22\u0127\3\2\2\2\u0b23\u0b25\7")
        buf.write("\u013e\2\2\u0b24\u0b23\3\2\2\2\u0b24\u0b25\3\2\2\2\u0b25")
        buf.write("\u0b26\3\2\2\2\u0b26\u0b27\t\n\2\2\u0b27\u0b3c\7\u00d9")
        buf.write("\2\2\u0b28\u0b29\5\u0152\u00aa\2\u0b29\u0b2a\7\u00f7\2")
        buf.write("\2\u0b2a\u0b3c\3\2\2\2\u0b2b\u0b2c\7H\2\2\u0b2c\u0b2d")
        buf.write("\7\u014c\2\2\u0b2d\u0b2e\7\u00cf\2\2\u0b2e\u0b2f\7\u00c8")
        buf.write("\2\2\u0b2f\u0b38\7\u014c\2\2\u0b30\u0b36\7\u00c9\2\2\u0b31")
        buf.write("\u0b37\5\u019c\u00cf\2\u0b32\u0b33\5\u0196\u00cc\2\u0b33")
        buf.write("\u0b34\7\5\2\2\u0b34\u0b35\7\6\2\2\u0b35\u0b37\3\2\2\2")
        buf.write("\u0b36\u0b31\3\2\2\2\u0b36\u0b32\3\2\2\2\u0b37\u0b39\3")
        buf.write("\2\2\2\u0b38\u0b30\3\2\2\2\u0b38\u0b39\3\2\2\2\u0b39\u0b3c")
        buf.write("\3\2\2\2\u0b3a\u0b3c\5\u0152\u00aa\2\u0b3b\u0b24\3\2\2")
        buf.write("\2\u0b3b\u0b28\3\2\2\2\u0b3b\u0b2b\3\2\2\2\u0b3b\u0b3a")
        buf.write("\3\2\2\2\u0b3c\u0129\3\2\2\2\u0b3d\u0b3e\7\5\2\2\u0b3e")
        buf.write("\u0b3f\5\u012c\u0097\2\u0b3f\u0b40\7\6\2\2\u0b40\u012b")
        buf.write("\3\2\2\2\u0b41\u0b46\5\u0198\u00cd\2\u0b42\u0b43\7\3\2")
        buf.write("\2\u0b43\u0b45\5\u0198\u00cd\2\u0b44\u0b42\3\2\2\2\u0b45")
        buf.write("\u0b48\3\2\2\2\u0b46\u0b44\3\2\2\2\u0b46\u0b47\3\2\2\2")
        buf.write("\u0b47\u012d\3\2\2\2\u0b48\u0b46\3\2\2\2\u0b49\u0b4a\7")
        buf.write("\5\2\2\u0b4a\u0b4f\5\u0130\u0099\2\u0b4b\u0b4c\7\3\2\2")
        buf.write("\u0b4c\u0b4e\5\u0130\u0099\2\u0b4d\u0b4b\3\2\2\2\u0b4e")
        buf.write("\u0b51\3\2\2\2\u0b4f\u0b4d\3\2\2\2\u0b4f\u0b50\3\2\2\2")
        buf.write("\u0b50\u0b52\3\2\2\2\u0b51\u0b4f\3\2\2\2\u0b52\u0b53\7")
        buf.write("\6\2\2\u0b53\u012f\3\2\2\2\u0b54\u0b56\5\u0198\u00cd\2")
        buf.write("\u0b55\u0b57\t\r\2\2\u0b56\u0b55\3\2\2\2\u0b56\u0b57\3")
        buf.write("\2\2\2\u0b57\u0131\3\2\2\2\u0b58\u0b59\7\5\2\2\u0b59\u0b5e")
        buf.write("\5\u0134\u009b\2\u0b5a\u0b5b\7\3\2\2\u0b5b\u0b5d\5\u0134")
        buf.write("\u009b\2\u0b5c\u0b5a\3\2\2\2\u0b5d\u0b60\3\2\2\2\u0b5e")
        buf.write("\u0b5c\3\2\2\2\u0b5e\u0b5f\3\2\2\2\u0b5f\u0b61\3\2\2\2")
        buf.write("\u0b60\u0b5e\3\2\2\2\u0b61\u0b62\7\6\2\2\u0b62\u0133\3")
        buf.write("\2\2\2\u0b63\u0b65\5\u019c\u00cf\2\u0b64\u0b66\5\u00b2")
        buf.write("Z\2\u0b65\u0b64\3\2\2\2\u0b65\u0b66\3\2\2\2\u0b66\u0135")
        buf.write("\3\2\2\2\u0b67\u0b69\5\u0142\u00a2\2\u0b68\u0b6a\5L\'")
        buf.write("\2\u0b69\u0b68\3\2\2\2\u0b69\u0b6a\3\2\2\2\u0b6a\u0b6c")
        buf.write("\3\2\2\2\u0b6b\u0b6d\5\u0126\u0094\2\u0b6c\u0b6b\3\2\2")
        buf.write("\2\u0b6c\u0b6d\3\2\2\2\u0b6d\u0b6e\3\2\2\2\u0b6e\u0b6f")
        buf.write("\5\u013c\u009f\2\u0b6f\u0b83\3\2\2\2\u0b70\u0b71\7\5\2")
        buf.write("\2\u0b71\u0b72\5\u00b4[\2\u0b72\u0b74\7\6\2\2\u0b73\u0b75")
        buf.write("\5\u0126\u0094\2\u0b74\u0b73\3\2\2\2\u0b74\u0b75\3\2\2")
        buf.write("\2\u0b75\u0b76\3\2\2\2\u0b76\u0b77\5\u013c\u009f\2\u0b77")
        buf.write("\u0b83\3\2\2\2\u0b78\u0b79\7\5\2\2\u0b79\u0b7a\5\u011e")
        buf.write("\u0090\2\u0b7a\u0b7c\7\6\2\2\u0b7b\u0b7d\5\u0126\u0094")
        buf.write("\2\u0b7c\u0b7b\3\2\2\2\u0b7c\u0b7d\3\2\2\2\u0b7d\u0b7e")
        buf.write("\3\2\2\2\u0b7e\u0b7f\5\u013c\u009f\2\u0b7f\u0b83\3\2\2")
        buf.write("\2\u0b80\u0b83\5\u0138\u009d\2\u0b81\u0b83\5\u013a\u009e")
        buf.write("\2\u0b82\u0b67\3\2\2\2\u0b82\u0b70\3\2\2\2\u0b82\u0b78")
        buf.write("\3\2\2\2\u0b82\u0b80\3\2\2\2\u0b82\u0b81\3\2\2\2\u0b83")
        buf.write("\u0137\3\2\2\2\u0b84\u0b85\7\u012c\2\2\u0b85\u0b8a\5\u0152")
        buf.write("\u00aa\2\u0b86\u0b87\7\3\2\2\u0b87\u0b89\5\u0152\u00aa")
        buf.write("\2\u0b88\u0b86\3\2\2\2\u0b89\u0b8c\3\2\2\2\u0b8a\u0b88")
        buf.write("\3\2\2\2\u0b8a\u0b8b\3\2\2\2\u0b8b\u0b8d\3\2\2\2\u0b8c")
        buf.write("\u0b8a\3\2\2\2\u0b8d\u0b8e\5\u013c\u009f\2\u0b8e\u0139")
        buf.write("\3\2\2\2\u0b8f\u0b90\5\u0198\u00cd\2\u0b90\u0b99\7\5\2")
        buf.write("\2\u0b91\u0b96\5\u0152\u00aa\2\u0b92\u0b93\7\3\2\2\u0b93")
        buf.write("\u0b95\5\u0152\u00aa\2\u0b94\u0b92\3\2\2\2\u0b95\u0b98")
        buf.write("\3\2\2\2\u0b96\u0b94\3\2\2\2\u0b96\u0b97\3\2\2\2\u0b97")
        buf.write("\u0b9a\3\2\2\2\u0b98\u0b96\3\2\2\2\u0b99\u0b91\3\2\2\2")
        buf.write("\u0b99\u0b9a\3\2\2\2\u0b9a\u0b9b\3\2\2\2\u0b9b\u0b9c\7")
        buf.write("\6\2\2\u0b9c\u0b9d\5\u013c\u009f\2\u0b9d\u013b\3\2\2\2")
        buf.write("\u0b9e\u0ba0\7B\2\2\u0b9f\u0b9e\3\2\2\2\u0b9f\u0ba0\3")
        buf.write("\2\2\2\u0ba0\u0ba1\3\2\2\2\u0ba1\u0ba3\5\u019e\u00d0\2")
        buf.write("\u0ba2\u0ba4\5\u012a\u0096\2\u0ba3\u0ba2\3\2\2\2\u0ba3")
        buf.write("\u0ba4\3\2\2\2\u0ba4\u0ba6\3\2\2\2\u0ba5\u0b9f\3\2\2\2")
        buf.write("\u0ba5\u0ba6\3\2\2\2\u0ba6\u013d\3\2\2\2\u0ba7\u0ba8\7")
        buf.write("\u00f6\2\2\u0ba8\u0ba9\7\u008e\2\2\u0ba9\u0baa\7\u00fd")
        buf.write("\2\2\u0baa\u0bae\7\u0148\2\2\u0bab\u0bac\7\u0132\2\2\u0bac")
        buf.write("\u0bad\7\u00fe\2\2\u0bad\u0baf\5\u00ccg\2\u0bae\u0bab")
        buf.write("\3\2\2\2\u0bae\u0baf\3\2\2\2\u0baf\u0bd9\3\2\2\2\u0bb0")
        buf.write("\u0bb1\7\u00f6\2\2\u0bb1\u0bb2\7\u008e\2\2\u0bb2\u0bbc")
        buf.write("\7p\2\2\u0bb3\u0bb4\7\u0087\2\2\u0bb4\u0bb5\7\u0114\2")
        buf.write("\2\u0bb5\u0bb6\7J\2\2\u0bb6\u0bba\7\u0148\2\2\u0bb7\u0bb8")
        buf.write("\7|\2\2\u0bb8\u0bb9\7J\2\2\u0bb9\u0bbb\7\u0148\2\2\u0bba")
        buf.write("\u0bb7\3\2\2\2\u0bba\u0bbb\3\2\2\2\u0bbb\u0bbd\3\2\2\2")
        buf.write("\u0bbc\u0bb3\3\2\2\2\u0bbc\u0bbd\3\2\2\2\u0bbd\u0bc3\3")
        buf.write("\2\2\2\u0bbe\u0bbf\7V\2\2\u0bbf\u0bc0\7\u00a8\2\2\u0bc0")
        buf.write("\u0bc1\7\u0114\2\2\u0bc1\u0bc2\7J\2\2\u0bc2\u0bc4\7\u0148")
        buf.write("\2\2\u0bc3\u0bbe\3\2\2\2\u0bc3\u0bc4\3\2\2\2\u0bc4\u0bca")
        buf.write("\3\2\2\2\u0bc5\u0bc6\7\u00bb\2\2\u0bc6\u0bc7\7\u00aa\2")
        buf.write("\2\u0bc7\u0bc8\7\u0114\2\2\u0bc8\u0bc9\7J\2\2\u0bc9\u0bcb")
        buf.write("\7\u0148\2\2\u0bca\u0bc5\3\2\2\2\u0bca\u0bcb\3\2\2\2\u0bcb")
        buf.write("\u0bd0\3\2\2\2\u0bcc\u0bcd\7\u00b2\2\2\u0bcd\u0bce\7\u0114")
        buf.write("\2\2\u0bce\u0bcf\7J\2\2\u0bcf\u0bd1\7\u0148\2\2\u0bd0")
        buf.write("\u0bcc\3\2\2\2\u0bd0\u0bd1\3\2\2\2\u0bd1\u0bd6\3\2\2\2")
        buf.write("\u0bd2\u0bd3\7\u00c6\2\2\u0bd3\u0bd4\7n\2\2\u0bd4\u0bd5")
        buf.write("\7B\2\2\u0bd5\u0bd7\7\u0148\2\2\u0bd6\u0bd2\3\2\2\2\u0bd6")
        buf.write("\u0bd7\3\2\2\2\u0bd7\u0bd9\3\2\2\2\u0bd8\u0ba7\3\2\2\2")
        buf.write("\u0bd8\u0bb0\3\2\2\2\u0bd9\u013f\3\2\2\2\u0bda\u0bdf\5")
        buf.write("\u0142\u00a2\2\u0bdb\u0bdc\7\3\2\2\u0bdc\u0bde\5\u0142")
        buf.write("\u00a2\2\u0bdd\u0bdb\3\2\2\2\u0bde\u0be1\3\2\2\2\u0bdf")
        buf.write("\u0bdd\3\2\2\2\u0bdf\u0be0\3\2\2\2\u0be0\u0141\3\2\2\2")
        buf.write("\u0be1\u0bdf\3\2\2\2\u0be2\u0be7\5\u0198\u00cd\2\u0be3")
        buf.write("\u0be4\7\t\2\2\u0be4\u0be6\5\u0198\u00cd\2\u0be5\u0be3")
        buf.write("\3\2\2\2\u0be6\u0be9\3\2\2\2\u0be7\u0be5\3\2\2\2\u0be7")
        buf.write("\u0be8\3\2\2\2\u0be8\u0143\3\2\2\2\u0be9\u0be7\3\2\2\2")
        buf.write("\u0bea\u0beb\5\u0198\u00cd\2\u0beb\u0bec\7\t\2\2\u0bec")
        buf.write("\u0bee\3\2\2\2\u0bed\u0bea\3\2\2\2\u0bed\u0bee\3\2\2\2")
        buf.write("\u0bee\u0bef\3\2\2\2\u0bef\u0bf0\5\u0198\u00cd\2\u0bf0")
        buf.write("\u0145\3\2\2\2\u0bf1\u0bf2\5\u0198\u00cd\2\u0bf2\u0bf3")
        buf.write("\7\t\2\2\u0bf3\u0bf5\3\2\2\2\u0bf4\u0bf1\3\2\2\2\u0bf4")
        buf.write("\u0bf5\3\2\2\2\u0bf5\u0bf6\3\2\2\2\u0bf6\u0bf7\5\u0198")
        buf.write("\u00cd\2\u0bf7\u0147\3\2\2\2\u0bf8\u0c00\5\u0152\u00aa")
        buf.write("\2\u0bf9\u0bfb\7B\2\2\u0bfa\u0bf9\3\2\2\2\u0bfa\u0bfb")
        buf.write("\3\2\2\2\u0bfb\u0bfe\3\2\2\2\u0bfc\u0bff\5\u0198\u00cd")
        buf.write("\2\u0bfd\u0bff\5\u012a\u0096\2\u0bfe\u0bfc\3\2\2\2\u0bfe")
        buf.write("\u0bfd\3\2\2\2\u0bff\u0c01\3\2\2\2\u0c00\u0bfa\3\2\2\2")
        buf.write("\u0c00\u0c01\3\2\2\2\u0c01\u0149\3\2\2\2\u0c02\u0c07\5")
        buf.write("\u0148\u00a5\2\u0c03\u0c04\7\3\2\2\u0c04\u0c06\5\u0148")
        buf.write("\u00a5\2\u0c05\u0c03\3\2\2\2\u0c06\u0c09\3\2\2\2\u0c07")
        buf.write("\u0c05\3\2\2\2\u0c07\u0c08\3\2\2\2\u0c08\u014b\3\2\2\2")
        buf.write("\u0c09\u0c07\3\2\2\2\u0c0a\u0c0b\7\5\2\2\u0c0b\u0c10\5")
        buf.write("\u014e\u00a8\2\u0c0c\u0c0d\7\3\2\2\u0c0d\u0c0f\5\u014e")
        buf.write("\u00a8\2\u0c0e\u0c0c\3\2\2\2\u0c0f\u0c12\3\2\2\2\u0c10")
        buf.write("\u0c0e\3\2\2\2\u0c10\u0c11\3\2\2\2\u0c11\u0c13\3\2\2\2")
        buf.write("\u0c12\u0c10\3\2\2\2\u0c13\u0c14\7\6\2\2\u0c14\u014d\3")
        buf.write("\2\2\2\u0c15\u0c23\5\u0196\u00cc\2\u0c16\u0c17\5\u019c")
        buf.write("\u00cf\2\u0c17\u0c18\7\5\2\2\u0c18\u0c1d\5\u0150\u00a9")
        buf.write("\2\u0c19\u0c1a\7\3\2\2\u0c1a\u0c1c\5\u0150\u00a9\2\u0c1b")
        buf.write("\u0c19\3\2\2\2\u0c1c\u0c1f\3\2\2\2\u0c1d\u0c1b\3\2\2\2")
        buf.write("\u0c1d\u0c1e\3\2\2\2\u0c1e\u0c20\3\2\2\2\u0c1f\u0c1d\3")
        buf.write("\2\2\2\u0c20\u0c21\7\6\2\2\u0c21\u0c23\3\2\2\2\u0c22\u0c15")
        buf.write("\3\2\2\2\u0c22\u0c16\3\2\2\2\u0c23\u014f\3\2\2\2\u0c24")
        buf.write("\u0c27\5\u0196\u00cc\2\u0c25\u0c27\5\u015c\u00af\2\u0c26")
        buf.write("\u0c24\3\2\2\2\u0c26\u0c25\3\2\2\2\u0c27\u0151\3\2\2\2")
        buf.write("\u0c28\u0c29\5\u0154\u00ab\2\u0c29\u0153\3\2\2\2\u0c2a")
        buf.write("\u0c2b\b\u00ab\1\2\u0c2b\u0c2c\7\u00c5\2\2\u0c2c\u0c37")
        buf.write("\5\u0154\u00ab\7\u0c2d\u0c2e\7\177\2\2\u0c2e\u0c2f\7\5")
        buf.write("\2\2\u0c2f\u0c30\5\u00b4[\2\u0c30\u0c31\7\6\2\2\u0c31")
        buf.write("\u0c37\3\2\2\2\u0c32\u0c34\5\u0158\u00ad\2\u0c33\u0c35")
        buf.write("\5\u0156\u00ac\2\u0c34\u0c33\3\2\2\2\u0c34\u0c35\3\2\2")
        buf.write("\2\u0c35\u0c37\3\2\2\2\u0c36\u0c2a\3\2\2\2\u0c36\u0c2d")
        buf.write("\3\2\2\2\u0c36\u0c32\3\2\2\2\u0c37\u0c40\3\2\2\2\u0c38")
        buf.write("\u0c39\f\4\2\2\u0c39\u0c3a\7=\2\2\u0c3a\u0c3f\5\u0154")
        buf.write("\u00ab\5\u0c3b\u0c3c\f\3\2\2\u0c3c\u0c3d\7\u00cd\2\2\u0c3d")
        buf.write("\u0c3f\5\u0154\u00ab\4\u0c3e\u0c38\3\2\2\2\u0c3e\u0c3b")
        buf.write("\3\2\2\2\u0c3f\u0c42\3\2\2\2\u0c40\u0c3e\3\2\2\2\u0c40")
        buf.write("\u0c41\3\2\2\2\u0c41\u0155\3\2\2\2\u0c42\u0c40\3\2\2\2")
        buf.write("\u0c43\u0c45\7\u00c5\2\2\u0c44\u0c43\3\2\2\2\u0c44\u0c45")
        buf.write("\3\2\2\2\u0c45\u0c46\3\2\2\2\u0c46\u0c47\7F\2\2\u0c47")
        buf.write("\u0c48\5\u0158\u00ad\2\u0c48\u0c49\7=\2\2\u0c49\u0c4a")
        buf.write("\5\u0158\u00ad\2\u0c4a\u0c96\3\2\2\2\u0c4b\u0c4d\7\u00c5")
        buf.write("\2\2\u0c4c\u0c4b\3\2\2\2\u0c4c\u0c4d\3\2\2\2\u0c4d\u0c4e")
        buf.write("\3\2\2\2\u0c4e\u0c4f\7\u009d\2\2\u0c4f\u0c50\7\5\2\2\u0c50")
        buf.write("\u0c55\5\u0152\u00aa\2\u0c51\u0c52\7\3\2\2\u0c52\u0c54")
        buf.write("\5\u0152\u00aa\2\u0c53\u0c51\3\2\2\2\u0c54\u0c57\3\2\2")
        buf.write("\2\u0c55\u0c53\3\2\2\2\u0c55\u0c56\3\2\2\2\u0c56\u0c58")
        buf.write("\3\2\2\2\u0c57\u0c55\3\2\2\2\u0c58\u0c59\7\6\2\2\u0c59")
        buf.write("\u0c96\3\2\2\2\u0c5a\u0c5c\7\u00c5\2\2\u0c5b\u0c5a\3\2")
        buf.write("\2\2\u0c5b\u0c5c\3\2\2\2\u0c5c\u0c5d\3\2\2\2\u0c5d\u0c5e")
        buf.write("\7\u009d\2\2\u0c5e\u0c5f\7\5\2\2\u0c5f\u0c60\5\u00b4[")
        buf.write("\2\u0c60\u0c61\7\6\2\2\u0c61\u0c96\3\2\2\2\u0c62\u0c64")
        buf.write("\7\u00c5\2\2\u0c63\u0c62\3\2\2\2\u0c63\u0c64\3\2\2\2\u0c64")
        buf.write("\u0c65\3\2\2\2\u0c65\u0c66\7\u00f1\2\2\u0c66\u0c96\5\u0158")
        buf.write("\u00ad\2\u0c67\u0c69\7\u00c5\2\2\u0c68\u0c67\3\2\2\2\u0c68")
        buf.write("\u0c69\3\2\2\2\u0c69\u0c6a\3\2\2\2\u0c6a\u0c6b\7\u00b0")
        buf.write("\2\2\u0c6b\u0c79\t \2\2\u0c6c\u0c6d\7\5\2\2\u0c6d\u0c7a")
        buf.write("\7\6\2\2\u0c6e\u0c6f\7\5\2\2\u0c6f\u0c74\5\u0152\u00aa")
        buf.write("\2\u0c70\u0c71\7\3\2\2\u0c71\u0c73\5\u0152\u00aa\2\u0c72")
        buf.write("\u0c70\3\2\2\2\u0c73\u0c76\3\2\2\2\u0c74\u0c72\3\2\2\2")
        buf.write("\u0c74\u0c75\3\2\2\2\u0c75\u0c77\3\2\2\2\u0c76\u0c74\3")
        buf.write("\2\2\2\u0c77\u0c78\7\6\2\2\u0c78\u0c7a\3\2\2\2\u0c79\u0c6c")
        buf.write("\3\2\2\2\u0c79\u0c6e\3\2\2\2\u0c7a\u0c96\3\2\2\2\u0c7b")
        buf.write("\u0c7d\7\u00c5\2\2\u0c7c\u0c7b\3\2\2\2\u0c7c\u0c7d\3\2")
        buf.write("\2\2\u0c7d\u0c7e\3\2\2\2\u0c7e\u0c7f\7\u00b0\2\2\u0c7f")
        buf.write("\u0c82\5\u0158\u00ad\2\u0c80\u0c81\7{\2\2\u0c81\u0c83")
        buf.write("\7\u0148\2\2\u0c82\u0c80\3\2\2\2\u0c82\u0c83\3\2\2\2\u0c83")
        buf.write("\u0c96\3\2\2\2\u0c84\u0c86\7\u00a7\2\2\u0c85\u0c87\7\u00c5")
        buf.write("\2\2\u0c86\u0c85\3\2\2\2\u0c86\u0c87\3\2\2\2\u0c87\u0c88")
        buf.write("\3\2\2\2\u0c88\u0c96\7\u00c6\2\2\u0c89\u0c8b\7\u00a7\2")
        buf.write("\2\u0c8a\u0c8c\7\u00c5\2\2\u0c8b\u0c8a\3\2\2\2\u0c8b\u0c8c")
        buf.write("\3\2\2\2\u0c8c\u0c8d\3\2\2\2\u0c8d\u0c96\t!\2\2\u0c8e")
        buf.write("\u0c90\7\u00a7\2\2\u0c8f\u0c91\7\u00c5\2\2\u0c90\u0c8f")
        buf.write("\3\2\2\2\u0c90\u0c91\3\2\2\2\u0c91\u0c92\3\2\2\2\u0c92")
        buf.write("\u0c93\7v\2\2\u0c93\u0c94\7\u0090\2\2\u0c94\u0c96\5\u0158")
        buf.write("\u00ad\2\u0c95\u0c44\3\2\2\2\u0c95\u0c4c\3\2\2\2\u0c95")
        buf.write("\u0c5b\3\2\2\2\u0c95\u0c63\3\2\2\2\u0c95\u0c68\3\2\2\2")
        buf.write("\u0c95\u0c7c\3\2\2\2\u0c95\u0c84\3\2\2\2\u0c95\u0c89\3")
        buf.write("\2\2\2\u0c95\u0c8e\3\2\2\2\u0c96\u0157\3\2\2\2\u0c97\u0c98")
        buf.write("\b\u00ad\1\2\u0c98\u0c9c\5\u015a\u00ae\2\u0c99\u0c9a\t")
        buf.write("\"\2\2\u0c9a\u0c9c\5\u0158\u00ad\t\u0c9b\u0c97\3\2\2\2")
        buf.write("\u0c9b\u0c99\3\2\2\2\u0c9c\u0cb2\3\2\2\2\u0c9d\u0c9e\f")
        buf.write("\b\2\2\u0c9e\u0c9f\t#\2\2\u0c9f\u0cb1\5\u0158\u00ad\t")
        buf.write("\u0ca0\u0ca1\f\7\2\2\u0ca1\u0ca2\t$\2\2\u0ca2\u0cb1\5")
        buf.write("\u0158\u00ad\b\u0ca3\u0ca4\f\6\2\2\u0ca4\u0ca5\7\u0144")
        buf.write("\2\2\u0ca5\u0cb1\5\u0158\u00ad\7\u0ca6\u0ca7\f\5\2\2\u0ca7")
        buf.write("\u0ca8\7\u0147\2\2\u0ca8\u0cb1\5\u0158\u00ad\6\u0ca9\u0caa")
        buf.write("\f\4\2\2\u0caa\u0cab\7\u0145\2\2\u0cab\u0cb1\5\u0158\u00ad")
        buf.write("\5\u0cac\u0cad\f\3\2\2\u0cad\u0cae\5\u015e\u00b0\2\u0cae")
        buf.write("\u0caf\5\u0158\u00ad\4\u0caf\u0cb1\3\2\2\2\u0cb0\u0c9d")
        buf.write("\3\2\2\2\u0cb0\u0ca0\3\2\2\2\u0cb0\u0ca3\3\2\2\2\u0cb0")
        buf.write("\u0ca6\3\2\2\2\u0cb0\u0ca9\3\2\2\2\u0cb0\u0cac\3\2\2\2")
        buf.write("\u0cb1\u0cb4\3\2\2\2\u0cb2\u0cb0\3\2\2\2\u0cb2\u0cb3\3")
        buf.write("\2\2\2\u0cb3\u0159\3\2\2\2\u0cb4\u0cb2\3\2\2\2\u0cb5\u0cb6")
        buf.write("\b\u00ae\1\2\u0cb6\u0d6e\t%\2\2\u0cb7\u0cb9\7M\2\2\u0cb8")
        buf.write("\u0cba\5\u0186\u00c4\2\u0cb9\u0cb8\3\2\2\2\u0cba\u0cbb")
        buf.write("\3\2\2\2\u0cbb\u0cb9\3\2\2\2\u0cbb\u0cbc\3\2\2\2\u0cbc")
        buf.write("\u0cbf\3\2\2\2\u0cbd\u0cbe\7y\2\2\u0cbe\u0cc0\5\u0152")
        buf.write("\u00aa\2\u0cbf\u0cbd\3\2\2\2\u0cbf\u0cc0\3\2\2\2\u0cc0")
        buf.write("\u0cc1\3\2\2\2\u0cc1\u0cc2\7z\2\2\u0cc2\u0d6e\3\2\2\2")
        buf.write("\u0cc3\u0cc4\7M\2\2\u0cc4\u0cc6\5\u0152\u00aa\2\u0cc5")
        buf.write("\u0cc7\5\u0186\u00c4\2\u0cc6\u0cc5\3\2\2\2\u0cc7\u0cc8")
        buf.write("\3\2\2\2\u0cc8\u0cc6\3\2\2\2\u0cc8\u0cc9\3\2\2\2\u0cc9")
        buf.write("\u0ccc\3\2\2\2\u0cca\u0ccb\7y\2\2\u0ccb\u0ccd\5\u0152")
        buf.write("\u00aa\2\u0ccc\u0cca\3\2\2\2\u0ccc\u0ccd\3\2\2\2\u0ccd")
        buf.write("\u0cce\3\2\2\2\u0cce\u0ccf\7z\2\2\u0ccf\u0d6e\3\2\2\2")
        buf.write("\u0cd0\u0cd1\7N\2\2\u0cd1\u0cd2\7\5\2\2\u0cd2\u0cd3\5")
        buf.write("\u0152\u00aa\2\u0cd3\u0cd4\7B\2\2\u0cd4\u0cd5\5\u0178")
        buf.write("\u00bd\2\u0cd5\u0cd6\7\6\2\2\u0cd6\u0d6e\3\2\2\2\u0cd7")
        buf.write("\u0cd8\7\u010c\2\2\u0cd8\u0ce1\7\5\2\2\u0cd9\u0cde\5\u0148")
        buf.write("\u00a5\2\u0cda\u0cdb\7\3\2\2\u0cdb\u0cdd\5\u0148\u00a5")
        buf.write("\2\u0cdc\u0cda\3\2\2\2\u0cdd\u0ce0\3\2\2\2\u0cde\u0cdc")
        buf.write("\3\2\2\2\u0cde\u0cdf\3\2\2\2\u0cdf\u0ce2\3\2\2\2\u0ce0")
        buf.write("\u0cde\3\2\2\2\u0ce1\u0cd9\3\2\2\2\u0ce1\u0ce2\3\2\2\2")
        buf.write("\u0ce2\u0ce3\3\2\2\2\u0ce3\u0d6e\7\6\2\2\u0ce4\u0ce5\7")
        buf.write("\u008a\2\2\u0ce5\u0ce6\7\5\2\2\u0ce6\u0ce9\5\u0152\u00aa")
        buf.write("\2\u0ce7\u0ce8\7\u009b\2\2\u0ce8\u0cea\7\u00c7\2\2\u0ce9")
        buf.write("\u0ce7\3\2\2\2\u0ce9\u0cea\3\2\2\2\u0cea\u0ceb\3\2\2\2")
        buf.write("\u0ceb\u0cec\7\6\2\2\u0cec\u0d6e\3\2\2\2\u0ced\u0cee\7")
        buf.write("\u00ab\2\2\u0cee\u0cef\7\5\2\2\u0cef\u0cf2\5\u0152\u00aa")
        buf.write("\2\u0cf0\u0cf1\7\u009b\2\2\u0cf1\u0cf3\7\u00c7\2\2\u0cf2")
        buf.write("\u0cf0\3\2\2\2\u0cf2\u0cf3\3\2\2\2\u0cf3\u0cf4\3\2\2\2")
        buf.write("\u0cf4\u0cf5\7\6\2\2\u0cf5\u0d6e\3\2\2\2\u0cf6\u0cf7\7")
        buf.write("\u00dc\2\2\u0cf7\u0cf8\7\5\2\2\u0cf8\u0cf9\5\u0158\u00ad")
        buf.write("\2\u0cf9\u0cfa\7\u009d\2\2\u0cfa\u0cfb\5\u0158\u00ad\2")
        buf.write("\u0cfb\u0cfc\7\6\2\2\u0cfc\u0d6e\3\2\2\2\u0cfd\u0d6e\5")
        buf.write("\u015c\u00af\2\u0cfe\u0d6e\7\u013f\2\2\u0cff\u0d00\5\u0196")
        buf.write("\u00cc\2\u0d00\u0d01\7\t\2\2\u0d01\u0d02\7\u013f\2\2\u0d02")
        buf.write("\u0d6e\3\2\2\2\u0d03\u0d04\7\5\2\2\u0d04\u0d07\5\u0148")
        buf.write("\u00a5\2\u0d05\u0d06\7\3\2\2\u0d06\u0d08\5\u0148\u00a5")
        buf.write("\2\u0d07\u0d05\3\2\2\2\u0d08\u0d09\3\2\2\2\u0d09\u0d07")
        buf.write("\3\2\2\2\u0d09\u0d0a\3\2\2\2\u0d0a\u0d0b\3\2\2\2\u0d0b")
        buf.write("\u0d0c\7\6\2\2\u0d0c\u0d6e\3\2\2\2\u0d0d\u0d0e\7\5\2\2")
        buf.write("\u0d0e\u0d0f\5\u00b4[\2\u0d0f\u0d10\7\6\2\2\u0d10\u0d6e")
        buf.write("\3\2\2\2\u0d11\u0d12\5\u0194\u00cb\2\u0d12\u0d1e\7\5\2")
        buf.write("\2\u0d13\u0d15\5\u011c\u008f\2\u0d14\u0d13\3\2\2\2\u0d14")
        buf.write("\u0d15\3\2\2\2\u0d15\u0d16\3\2\2\2\u0d16\u0d1b\5\u0152")
        buf.write("\u00aa\2\u0d17\u0d18\7\3\2\2\u0d18\u0d1a\5\u0152\u00aa")
        buf.write("\2\u0d19\u0d17\3\2\2\2\u0d1a\u0d1d\3\2\2\2\u0d1b\u0d19")
        buf.write("\3\2\2\2\u0d1b\u0d1c\3\2\2\2\u0d1c\u0d1f\3\2\2\2\u0d1d")
        buf.write("\u0d1b\3\2\2\2\u0d1e\u0d14\3\2\2\2\u0d1e\u0d1f\3\2\2\2")
        buf.write("\u0d1f\u0d20\3\2\2\2\u0d20\u0d27\7\6\2\2\u0d21\u0d22\7")
        buf.write("\u0088\2\2\u0d22\u0d23\7\5\2\2\u0d23\u0d24\7\u0130\2\2")
        buf.write("\u0d24\u0d25\5\u0154\u00ab\2\u0d25\u0d26\7\6\2\2\u0d26")
        buf.write("\u0d28\3\2\2\2\u0d27\u0d21\3\2\2\2\u0d27\u0d28\3\2\2\2")
        buf.write("\u0d28\u0d2b\3\2\2\2\u0d29\u0d2a\7\u00d2\2\2\u0d2a\u0d2c")
        buf.write("\5\u018c\u00c7\2\u0d2b\u0d29\3\2\2\2\u0d2b\u0d2c\3\2\2")
        buf.write("\2\u0d2c\u0d6e\3\2\2\2\u0d2d\u0d2e\5\u019c\u00cf\2\u0d2e")
        buf.write("\u0d2f\7\22\2\2\u0d2f\u0d30\5\u0152\u00aa\2\u0d30\u0d6e")
        buf.write("\3\2\2\2\u0d31\u0d32\7\5\2\2\u0d32\u0d35\5\u019c\u00cf")
        buf.write("\2\u0d33\u0d34\7\3\2\2\u0d34\u0d36\5\u019c\u00cf\2\u0d35")
        buf.write("\u0d33\3\2\2\2\u0d36\u0d37\3\2\2\2\u0d37\u0d35\3\2\2\2")
        buf.write("\u0d37\u0d38\3\2\2\2\u0d38\u0d39\3\2\2\2\u0d39\u0d3a\7")
        buf.write("\6\2\2\u0d3a\u0d3b\7\22\2\2\u0d3b\u0d3c\5\u0152\u00aa")
        buf.write("\2\u0d3c\u0d6e\3\2\2\2\u0d3d\u0d6e\5\u019c\u00cf\2\u0d3e")
        buf.write("\u0d3f\7\5\2\2\u0d3f\u0d40\5\u0152\u00aa\2\u0d40\u0d41")
        buf.write("\7\6\2\2\u0d41\u0d6e\3\2\2\2\u0d42\u0d43\7\u0084\2\2\u0d43")
        buf.write("\u0d44\7\5\2\2\u0d44\u0d45\5\u019c\u00cf\2\u0d45\u0d46")
        buf.write("\7\u0090\2\2\u0d46\u0d47\5\u0158\u00ad\2\u0d47\u0d48\7")
        buf.write("\6\2\2\u0d48\u0d6e\3\2\2\2\u0d49\u0d4a\t&\2\2\u0d4a\u0d4b")
        buf.write("\7\5\2\2\u0d4b\u0d4c\5\u0158\u00ad\2\u0d4c\u0d4d\t\'\2")
        buf.write("\2\u0d4d\u0d50\5\u0158\u00ad\2\u0d4e\u0d4f\t(\2\2\u0d4f")
        buf.write("\u0d51\5\u0158\u00ad\2\u0d50\u0d4e\3\2\2\2\u0d50\u0d51")
        buf.write("\3\2\2\2\u0d51\u0d52\3\2\2\2\u0d52\u0d53\7\6\2\2\u0d53")
        buf.write("\u0d6e\3\2\2\2\u0d54\u0d55\7\u011c\2\2\u0d55\u0d57\7\5")
        buf.write("\2\2\u0d56\u0d58\t)\2\2\u0d57\u0d56\3\2\2\2\u0d57\u0d58")
        buf.write("\3\2\2\2\u0d58\u0d5a\3\2\2\2\u0d59\u0d5b\5\u0158\u00ad")
        buf.write("\2\u0d5a\u0d59\3\2\2\2\u0d5a\u0d5b\3\2\2\2\u0d5b\u0d5c")
        buf.write("\3\2\2\2\u0d5c\u0d5d\7\u0090\2\2\u0d5d\u0d5e\5\u0158\u00ad")
        buf.write("\2\u0d5e\u0d5f\7\6\2\2\u0d5f\u0d6e\3\2\2\2\u0d60\u0d61")
        buf.write("\7\u00d4\2\2\u0d61\u0d62\7\5\2\2\u0d62\u0d63\5\u0158\u00ad")
        buf.write("\2\u0d63\u0d64\7\u00db\2\2\u0d64\u0d65\5\u0158\u00ad\2")
        buf.write("\u0d65\u0d66\7\u0090\2\2\u0d66\u0d69\5\u0158\u00ad\2\u0d67")
        buf.write("\u0d68\7\u008c\2\2\u0d68\u0d6a\5\u0158\u00ad\2\u0d69\u0d67")
        buf.write("\3\2\2\2\u0d69\u0d6a\3\2\2\2\u0d6a\u0d6b\3\2\2\2\u0d6b")
        buf.write("\u0d6c\7\6\2\2\u0d6c\u0d6e\3\2\2\2\u0d6d\u0cb5\3\2\2\2")
        buf.write("\u0d6d\u0cb7\3\2\2\2\u0d6d\u0cc3\3\2\2\2\u0d6d\u0cd0\3")
        buf.write("\2\2\2\u0d6d\u0cd7\3\2\2\2\u0d6d\u0ce4\3\2\2\2\u0d6d\u0ced")
        buf.write("\3\2\2\2\u0d6d\u0cf6\3\2\2\2\u0d6d\u0cfd\3\2\2\2\u0d6d")
        buf.write("\u0cfe\3\2\2\2\u0d6d\u0cff\3\2\2\2\u0d6d\u0d03\3\2\2\2")
        buf.write("\u0d6d\u0d0d\3\2\2\2\u0d6d\u0d11\3\2\2\2\u0d6d\u0d2d\3")
        buf.write("\2\2\2\u0d6d\u0d31\3\2\2\2\u0d6d\u0d3d\3\2\2\2\u0d6d\u0d3e")
        buf.write("\3\2\2\2\u0d6d\u0d42\3\2\2\2\u0d6d\u0d49\3\2\2\2\u0d6d")
        buf.write("\u0d54\3\2\2\2\u0d6d\u0d60\3\2\2\2\u0d6e\u0d79\3\2\2\2")
        buf.write("\u0d6f\u0d70\f\n\2\2\u0d70\u0d71\7\7\2\2\u0d71\u0d72\5")
        buf.write("\u0158\u00ad\2\u0d72\u0d73\7\b\2\2\u0d73\u0d78\3\2\2\2")
        buf.write("\u0d74\u0d75\f\b\2\2\u0d75\u0d76\7\t\2\2\u0d76\u0d78\5")
        buf.write("\u019c\u00cf\2\u0d77\u0d6f\3\2\2\2\u0d77\u0d74\3\2\2\2")
        buf.write("\u0d78\u0d7b\3\2\2\2\u0d79\u0d77\3\2\2\2\u0d79\u0d7a\3")
        buf.write("\2\2\2\u0d7a\u015b\3\2\2\2\u0d7b\u0d79\3\2\2\2\u0d7c\u0d89")
        buf.write("\7\u00c6\2\2\u0d7d\u0d89\5\u0168\u00b5\2\u0d7e\u0d7f\5")
        buf.write("\u019c\u00cf\2\u0d7f\u0d80\7\u0148\2\2\u0d80\u0d89\3\2")
        buf.write("\2\2\u0d81\u0d89\5\u01a2\u00d2\2\u0d82\u0d89\5\u0166\u00b4")
        buf.write("\2\u0d83\u0d85\7\u0148\2\2\u0d84\u0d83\3\2\2\2\u0d85\u0d86")
        buf.write("\3\2\2\2\u0d86\u0d84\3\2\2\2\u0d86\u0d87\3\2\2\2\u0d87")
        buf.write("\u0d89\3\2\2\2\u0d88\u0d7c\3\2\2\2\u0d88\u0d7d\3\2\2\2")
        buf.write("\u0d88\u0d7e\3\2\2\2\u0d88\u0d81\3\2\2\2\u0d88\u0d82\3")
        buf.write("\2\2\2\u0d88\u0d84\3\2\2\2\u0d89\u015d\3\2\2\2\u0d8a\u0d93")
        buf.write("\5\u0160\u00b1\2\u0d8b\u0d93\7\u0137\2\2\u0d8c\u0d93\7")
        buf.write("\u0138\2\2\u0d8d\u0d93\7\u0139\2\2\u0d8e\u0d93\7\u013a")
        buf.write("\2\2\u0d8f\u0d93\7\u013b\2\2\u0d90\u0d93\7\u013c\2\2\u0d91")
        buf.write("\u0d93\7\u0136\2\2\u0d92\u0d8a\3\2\2\2\u0d92\u0d8b\3\2")
        buf.write("\2\2\u0d92\u0d8c\3\2\2\2\u0d92\u0d8d\3\2\2\2\u0d92\u0d8e")
        buf.write("\3\2\2\2\u0d92\u0d8f\3\2\2\2\u0d92\u0d90\3\2\2\2\u0d92")
        buf.write("\u0d91\3\2\2\2\u0d93\u015f\3\2\2\2\u0d94\u0d95\t*\2\2")
        buf.write("\u0d95\u0161\3\2\2\2\u0d96\u0d97\t+\2\2\u0d97\u0163\3")
        buf.write("\2\2\2\u0d98\u0d99\t,\2\2\u0d99\u0165\3\2\2\2\u0d9a\u0d9b")
        buf.write("\t-\2\2\u0d9b\u0167\3\2\2\2\u0d9c\u0d9f\7\u00a5\2\2\u0d9d")
        buf.write("\u0da0\5\u016a\u00b6\2\u0d9e\u0da0\5\u016e\u00b8\2\u0d9f")
        buf.write("\u0d9d\3\2\2\2\u0d9f\u0d9e\3\2\2\2\u0d9f\u0da0\3\2\2\2")
        buf.write("\u0da0\u0169\3\2\2\2\u0da1\u0da3\5\u016c\u00b7\2\u0da2")
        buf.write("\u0da4\5\u0170\u00b9\2\u0da3\u0da2\3\2\2\2\u0da3\u0da4")
        buf.write("\3\2\2\2\u0da4\u016b\3\2\2\2\u0da5\u0da6\5\u0172\u00ba")
        buf.write("\2\u0da6\u0da7\5\u0174\u00bb\2\u0da7\u0da9\3\2\2\2\u0da8")
        buf.write("\u0da5\3\2\2\2\u0da9\u0daa\3\2\2\2\u0daa\u0da8\3\2\2\2")
        buf.write("\u0daa\u0dab\3\2\2\2\u0dab\u016d\3\2\2\2\u0dac\u0daf\5")
        buf.write("\u0170\u00b9\2\u0dad\u0db0\5\u016c\u00b7\2\u0dae\u0db0")
        buf.write("\5\u0170\u00b9\2\u0daf\u0dad\3\2\2\2\u0daf\u0dae\3\2\2")
        buf.write("\2\u0daf\u0db0\3\2\2\2\u0db0\u016f\3\2\2\2\u0db1\u0db2")
        buf.write("\5\u0172\u00ba\2\u0db2\u0db3\5\u0174\u00bb\2\u0db3\u0db4")
        buf.write("\7\u0116\2\2\u0db4\u0db5\5\u0174\u00bb\2\u0db5\u0171\3")
        buf.write("\2\2\2\u0db6\u0db8\t.\2\2\u0db7\u0db6\3\2\2\2\u0db7\u0db8")
        buf.write("\3\2\2\2\u0db8\u0db9\3\2\2\2\u0db9\u0dbc\t\n\2\2\u0dba")
        buf.write("\u0dbc\7\u0148\2\2\u0dbb\u0db7\3\2\2\2\u0dbb\u0dba\3\2")
        buf.write("\2\2\u0dbc\u0173\3\2\2\2\u0dbd\u0dc5\7l\2\2\u0dbe\u0dc5")
        buf.write("\7\u0099\2\2\u0dbf\u0dc5\7\u00be\2\2\u0dc0\u0dc5\7\u00bf")
        buf.write("\2\2\u0dc1\u0dc5\7\u00f9\2\2\u0dc2\u0dc5\7\u0133\2\2\u0dc3")
        buf.write("\u0dc5\5\u019c\u00cf\2\u0dc4\u0dbd\3\2\2\2\u0dc4\u0dbe")
        buf.write("\3\2\2\2\u0dc4\u0dbf\3\2\2\2\u0dc4\u0dc0\3\2\2\2\u0dc4")
        buf.write("\u0dc1\3\2\2\2\u0dc4\u0dc2\3\2\2\2\u0dc4\u0dc3\3\2\2\2")
        buf.write("\u0dc5\u0175\3\2\2\2\u0dc6\u0dca\7\u008a\2\2\u0dc7\u0dc8")
        buf.write("\79\2\2\u0dc8\u0dca\5\u0198\u00cd\2\u0dc9\u0dc6\3\2\2")
        buf.write("\2\u0dc9\u0dc7\3\2\2\2\u0dca\u0177\3\2\2\2\u0dcb\u0dcc")
        buf.write("\7A\2\2\u0dcc\u0dcd\7\u0139\2\2\u0dcd\u0dce\5\u0178\u00bd")
        buf.write("\2\u0dce\u0dcf\7\u013b\2\2\u0dcf\u0dee\3\2\2\2\u0dd0\u0dd1")
        buf.write("\7\u00bb\2\2\u0dd1\u0dd2\7\u0139\2\2\u0dd2\u0dd3\5\u0178")
        buf.write("\u00bd\2\u0dd3\u0dd4\7\3\2\2\u0dd4\u0dd5\5\u0178\u00bd")
        buf.write("\2\u0dd5\u0dd6\7\u013b\2\2\u0dd6\u0dee\3\2\2\2\u0dd7\u0dde")
        buf.write("\7\u010c\2\2\u0dd8\u0dda\7\u0139\2\2\u0dd9\u0ddb\5\u0182")
        buf.write("\u00c2\2\u0dda\u0dd9\3\2\2\2\u0dda\u0ddb\3\2\2\2\u0ddb")
        buf.write("\u0ddc\3\2\2\2\u0ddc\u0ddf\7\u013b\2\2\u0ddd\u0ddf\7\u0137")
        buf.write("\2\2\u0dde\u0dd8\3\2\2\2\u0dde\u0ddd\3\2\2\2\u0ddf\u0dee")
        buf.write("\3\2\2\2\u0de0\u0deb\5\u019c\u00cf\2\u0de1\u0de2\7\5\2")
        buf.write("\2\u0de2\u0de7\7\u014c\2\2\u0de3\u0de4\7\3\2\2\u0de4\u0de6")
        buf.write("\7\u014c\2\2\u0de5\u0de3\3\2\2\2\u0de6\u0de9\3\2\2\2\u0de7")
        buf.write("\u0de5\3\2\2\2\u0de7\u0de8\3\2\2\2\u0de8\u0dea\3\2\2\2")
        buf.write("\u0de9\u0de7\3\2\2\2\u0dea\u0dec\7\6\2\2\u0deb\u0de1\3")
        buf.write("\2\2\2\u0deb\u0dec\3\2\2\2\u0dec\u0dee\3\2\2\2\u0ded\u0dcb")
        buf.write("\3\2\2\2\u0ded\u0dd0\3\2\2\2\u0ded\u0dd7\3\2\2\2\u0ded")
        buf.write("\u0de0\3\2\2\2\u0dee\u0179\3\2\2\2\u0def\u0df4\5\u017c")
        buf.write("\u00bf\2\u0df0\u0df1\7\3\2\2\u0df1\u0df3\5\u017c\u00bf")
        buf.write("\2\u0df2\u0df0\3\2\2\2\u0df3\u0df6\3\2\2\2\u0df4\u0df2")
        buf.write("\3\2\2\2\u0df4\u0df5\3\2\2\2\u0df5\u017b\3\2\2\2\u0df6")
        buf.write("\u0df4\3\2\2\2\u0df7\u0df8\5\u0142\u00a2\2\u0df8\u0dfb")
        buf.write("\5\u0178\u00bd\2\u0df9\u0dfa\7\u00c5\2\2\u0dfa\u0dfc\7")
        buf.write("\u00c6\2\2\u0dfb\u0df9\3\2\2\2\u0dfb\u0dfc\3\2\2\2\u0dfc")
        buf.write("\u0dfe\3\2\2\2\u0dfd\u0dff\5\u00b2Z\2\u0dfe\u0dfd\3\2")
        buf.write("\2\2\u0dfe\u0dff\3\2\2\2\u0dff\u0e01\3\2\2\2\u0e00\u0e02")
        buf.write("\5\u0176\u00bc\2\u0e01\u0e00\3\2\2\2\u0e01\u0e02\3\2\2")
        buf.write("\2\u0e02\u017d\3\2\2\2\u0e03\u0e08\5\u0180\u00c1\2\u0e04")
        buf.write("\u0e05\7\3\2\2\u0e05\u0e07\5\u0180\u00c1\2\u0e06\u0e04")
        buf.write("\3\2\2\2\u0e07\u0e0a\3\2\2\2\u0e08\u0e06\3\2\2\2\u0e08")
        buf.write("\u0e09\3\2\2\2\u0e09\u017f\3\2\2\2\u0e0a\u0e08\3\2\2\2")
        buf.write("\u0e0b\u0e0c\5\u0198\u00cd\2\u0e0c\u0e0f\5\u0178\u00bd")
        buf.write("\2\u0e0d\u0e0e\7\u00c5\2\2\u0e0e\u0e10\7\u00c6\2\2\u0e0f")
        buf.write("\u0e0d\3\2\2\2\u0e0f\u0e10\3\2\2\2\u0e10\u0e12\3\2\2\2")
        buf.write("\u0e11\u0e13\5\u00b2Z\2\u0e12\u0e11\3\2\2\2\u0e12\u0e13")
        buf.write("\3\2\2\2\u0e13\u0181\3\2\2\2\u0e14\u0e19\5\u0184\u00c3")
        buf.write("\2\u0e15\u0e16\7\3\2\2\u0e16\u0e18\5\u0184\u00c3\2\u0e17")
        buf.write("\u0e15\3\2\2\2\u0e18\u0e1b\3\2\2\2\u0e19\u0e17\3\2\2\2")
        buf.write("\u0e19\u0e1a\3\2\2\2\u0e1a\u0183\3\2\2\2\u0e1b\u0e19\3")
        buf.write("\2\2\2\u0e1c\u0e1d\5\u019c\u00cf\2\u0e1d\u0e1e\7\4\2\2")
        buf.write("\u0e1e\u0e21\5\u0178\u00bd\2\u0e1f\u0e20\7\u00c5\2\2\u0e20")
        buf.write("\u0e22\7\u00c6\2\2\u0e21\u0e1f\3\2\2\2\u0e21\u0e22\3\2")
        buf.write("\2\2\u0e22\u0e24\3\2\2\2\u0e23\u0e25\5\u00b2Z\2\u0e24")
        buf.write("\u0e23\3\2\2\2\u0e24\u0e25\3\2\2\2\u0e25\u0185\3\2\2\2")
        buf.write("\u0e26\u0e27\7\u012f\2\2\u0e27\u0e28\5\u0152\u00aa\2\u0e28")
        buf.write("\u0e29\7\u0115\2\2\u0e29\u0e2a\5\u0152\u00aa\2\u0e2a\u0187")
        buf.write("\3\2\2\2\u0e2b\u0e2c\7\u0131\2\2\u0e2c\u0e31\5\u018a\u00c6")
        buf.write("\2\u0e2d\u0e2e\7\3\2\2\u0e2e\u0e30\5\u018a\u00c6\2\u0e2f")
        buf.write("\u0e2d\3\2\2\2\u0e30\u0e33\3\2\2\2\u0e31\u0e2f\3\2\2\2")
        buf.write("\u0e31\u0e32\3\2\2\2\u0e32\u0189\3\2\2\2\u0e33\u0e31\3")
        buf.write("\2\2\2\u0e34\u0e35\5\u0198\u00cd\2\u0e35\u0e36\7B\2\2")
        buf.write("\u0e36\u0e37\5\u018c\u00c7\2\u0e37\u018b\3\2\2\2\u0e38")
        buf.write("\u0e67\5\u0198\u00cd\2\u0e39\u0e3a\7\5\2\2\u0e3a\u0e3b")
        buf.write("\5\u0198\u00cd\2\u0e3b\u0e3c\7\6\2\2\u0e3c\u0e67\3\2\2")
        buf.write("\2\u0e3d\u0e60\7\5\2\2\u0e3e\u0e3f\7R\2\2\u0e3f\u0e40")
        buf.write("\7J\2\2\u0e40\u0e45\5\u0152\u00aa\2\u0e41\u0e42\7\3\2")
        buf.write("\2\u0e42\u0e44\5\u0152\u00aa\2\u0e43\u0e41\3\2\2\2\u0e44")
        buf.write("\u0e47\3\2\2\2\u0e45\u0e43\3\2\2\2\u0e45\u0e46\3\2\2\2")
        buf.write("\u0e46\u0e61\3\2\2\2\u0e47\u0e45\3\2\2\2\u0e48\u0e49\t")
        buf.write("/\2\2\u0e49\u0e4a\7J\2\2\u0e4a\u0e4f\5\u0152\u00aa\2\u0e4b")
        buf.write("\u0e4c\7\3\2\2\u0e4c\u0e4e\5\u0152\u00aa\2\u0e4d\u0e4b")
        buf.write("\3\2\2\2\u0e4e\u0e51\3\2\2\2\u0e4f\u0e4d\3\2\2\2\u0e4f")
        buf.write("\u0e50\3\2\2\2\u0e50\u0e53\3\2\2\2\u0e51\u0e4f\3\2\2\2")
        buf.write("\u0e52\u0e48\3\2\2\2\u0e52\u0e53\3\2\2\2\u0e53\u0e5e\3")
        buf.write("\2\2\2\u0e54\u0e55\t\60\2\2\u0e55\u0e56\7J\2\2\u0e56\u0e5b")
        buf.write("\5\u00eav\2\u0e57\u0e58\7\3\2\2\u0e58\u0e5a\5\u00eav\2")
        buf.write("\u0e59\u0e57\3\2\2\2\u0e5a\u0e5d\3\2\2\2\u0e5b\u0e59\3")
        buf.write("\2\2\2\u0e5b\u0e5c\3\2\2\2\u0e5c\u0e5f\3\2\2\2\u0e5d\u0e5b")
        buf.write("\3\2\2\2\u0e5e\u0e54\3\2\2\2\u0e5e\u0e5f\3\2\2\2\u0e5f")
        buf.write("\u0e61\3\2\2\2\u0e60\u0e3e\3\2\2\2\u0e60\u0e52\3\2\2\2")
        buf.write("\u0e61\u0e63\3\2\2\2\u0e62\u0e64\5\u018e\u00c8\2\u0e63")
        buf.write("\u0e62\3\2\2\2\u0e63\u0e64\3\2\2\2\u0e64\u0e65\3\2\2\2")
        buf.write("\u0e65\u0e67\7\6\2\2\u0e66\u0e38\3\2\2\2\u0e66\u0e39\3")
        buf.write("\2\2\2\u0e66\u0e3d\3\2\2\2\u0e67\u018d\3\2\2\2\u0e68\u0e69")
        buf.write("\7\u00e3\2\2\u0e69\u0e79\5\u0190\u00c9\2\u0e6a\u0e6b\7")
        buf.write("\u00f7\2\2\u0e6b\u0e79\5\u0190\u00c9\2\u0e6c\u0e6d\7\u00e3")
        buf.write("\2\2\u0e6d\u0e6e\7F\2\2\u0e6e\u0e6f\5\u0190\u00c9\2\u0e6f")
        buf.write("\u0e70\7=\2\2\u0e70\u0e71\5\u0190\u00c9\2\u0e71\u0e79")
        buf.write("\3\2\2\2\u0e72\u0e73\7\u00f7\2\2\u0e73\u0e74\7F\2\2\u0e74")
        buf.write("\u0e75\5\u0190\u00c9\2\u0e75\u0e76\7=\2\2\u0e76\u0e77")
        buf.write("\5\u0190\u00c9\2\u0e77\u0e79\3\2\2\2\u0e78\u0e68\3\2\2")
        buf.write("\2\u0e78\u0e6a\3\2\2\2\u0e78\u0e6c\3\2\2\2\u0e78\u0e72")
        buf.write("\3\2\2\2\u0e79\u018f\3\2\2\2\u0e7a\u0e7b\7\u0121\2\2\u0e7b")
        buf.write("\u0e82\t\61\2\2\u0e7c\u0e7d\7d\2\2\u0e7d\u0e82\7\u00f6")
        buf.write("\2\2\u0e7e\u0e7f\5\u0152\u00aa\2\u0e7f\u0e80\t\61\2\2")
        buf.write("\u0e80\u0e82\3\2\2\2\u0e81\u0e7a\3\2\2\2\u0e81\u0e7c\3")
        buf.write("\2\2\2\u0e81\u0e7e\3\2\2\2\u0e82\u0191\3\2\2\2\u0e83\u0e88")
        buf.write("\5\u0196\u00cc\2\u0e84\u0e85\7\3\2\2\u0e85\u0e87\5\u0196")
        buf.write("\u00cc\2\u0e86\u0e84\3\2\2\2\u0e87\u0e8a\3\2\2\2\u0e88")
        buf.write("\u0e86\3\2\2\2\u0e88\u0e89\3\2\2\2\u0e89\u0193\3\2\2\2")
        buf.write("\u0e8a\u0e88\3\2\2\2\u0e8b\u0e90\5\u0196\u00cc\2\u0e8c")
        buf.write("\u0e90\7\u0088\2\2\u0e8d\u0e90\7\u00af\2\2\u0e8e\u0e90")
        buf.write("\7\u00f0\2\2\u0e8f\u0e8b\3\2\2\2\u0e8f\u0e8c\3\2\2\2\u0e8f")
        buf.write("\u0e8d\3\2\2\2\u0e8f\u0e8e\3\2\2\2\u0e90\u0195\3\2\2\2")
        buf.write("\u0e91\u0e96\5\u019c\u00cf\2\u0e92\u0e93\7\t\2\2\u0e93")
        buf.write("\u0e95\5\u019c\u00cf\2\u0e94\u0e92\3\2\2\2\u0e95\u0e98")
        buf.write("\3\2\2\2\u0e96\u0e94\3\2\2\2\u0e96\u0e97\3\2\2\2\u0e97")
        buf.write("\u0197\3\2\2\2\u0e98\u0e96\3\2\2\2\u0e99\u0e9a\5\u019c")
        buf.write("\u00cf\2\u0e9a\u0e9b\5\u019a\u00ce\2\u0e9b\u0199\3\2\2")
        buf.write("\2\u0e9c\u0e9d\7\u013e\2\2\u0e9d\u0e9f\5\u019c\u00cf\2")
        buf.write("\u0e9e\u0e9c\3\2\2\2\u0e9f\u0ea0\3\2\2\2\u0ea0\u0e9e\3")
        buf.write("\2\2\2\u0ea0\u0ea1\3\2\2\2\u0ea1\u0ea4\3\2\2\2\u0ea2\u0ea4")
        buf.write("\3\2\2\2\u0ea3\u0e9e\3\2\2\2\u0ea3\u0ea2\3\2\2\2\u0ea4")
        buf.write("\u019b\3\2\2\2\u0ea5\u0ea9\5\u019e\u00d0\2\u0ea6\u0ea7")
        buf.write("\6\u00cf\24\2\u0ea7\u0ea9\5\u01a8\u00d5\2\u0ea8\u0ea5")
        buf.write("\3\2\2\2\u0ea8\u0ea6\3\2\2\2\u0ea9\u019d\3\2\2\2\u0eaa")
        buf.write("\u0eb1\7\u0151\2\2\u0eab\u0eb1\5\u01a0\u00d1\2\u0eac\u0ead")
        buf.write("\6\u00d0\25\2\u0ead\u0eb1\5\u01a6\u00d4\2\u0eae\u0eaf")
        buf.write("\6\u00d0\26\2\u0eaf\u0eb1\5\u01aa\u00d6\2\u0eb0\u0eaa")
        buf.write("\3\2\2\2\u0eb0\u0eab\3\2\2\2\u0eb0\u0eac\3\2\2\2\u0eb0")
        buf.write("\u0eae\3\2\2\2\u0eb1\u019f\3\2\2\2\u0eb2\u0eb3\7\u0152")
        buf.write("\2\2\u0eb3\u01a1\3\2\2\2\u0eb4\u0eb6\6\u00d2\27\2\u0eb5")
        buf.write("\u0eb7\7\u013e\2\2\u0eb6\u0eb5\3\2\2\2\u0eb6\u0eb7\3\2")
        buf.write("\2\2\u0eb7\u0eb8\3\2\2\2\u0eb8\u0edc\7\u014d\2\2\u0eb9")
        buf.write("\u0ebb\6\u00d2\30\2\u0eba\u0ebc\7\u013e\2\2\u0ebb\u0eba")
        buf.write("\3\2\2\2\u0ebb\u0ebc\3\2\2\2\u0ebc\u0ebd\3\2\2\2\u0ebd")
        buf.write("\u0edc\7\u014e\2\2\u0ebe\u0ec0\6\u00d2\31\2\u0ebf\u0ec1")
        buf.write("\7\u013e\2\2\u0ec0\u0ebf\3\2\2\2\u0ec0\u0ec1\3\2\2\2\u0ec1")
        buf.write("\u0ec2\3\2\2\2\u0ec2\u0edc\t\62\2\2\u0ec3\u0ec5\7\u013e")
        buf.write("\2\2\u0ec4\u0ec3\3\2\2\2\u0ec4\u0ec5\3\2\2\2\u0ec5\u0ec6")
        buf.write("\3\2\2\2\u0ec6\u0edc\7\u014c\2\2\u0ec7\u0ec9\7\u013e\2")
        buf.write("\2\u0ec8\u0ec7\3\2\2\2\u0ec8\u0ec9\3\2\2\2\u0ec9\u0eca")
        buf.write("\3\2\2\2\u0eca\u0edc\7\u0149\2\2\u0ecb\u0ecd\7\u013e\2")
        buf.write("\2\u0ecc\u0ecb\3\2\2\2\u0ecc\u0ecd\3\2\2\2\u0ecd\u0ece")
        buf.write("\3\2\2\2\u0ece\u0edc\7\u014a\2\2\u0ecf\u0ed1\7\u013e\2")
        buf.write("\2\u0ed0\u0ecf\3\2\2\2\u0ed0\u0ed1\3\2\2\2\u0ed1\u0ed2")
        buf.write("\3\2\2\2\u0ed2\u0edc\7\u014b\2\2\u0ed3\u0ed5\7\u013e\2")
        buf.write("\2\u0ed4\u0ed3\3\2\2\2\u0ed4\u0ed5\3\2\2\2\u0ed5\u0ed6")
        buf.write("\3\2\2\2\u0ed6\u0edc\7\u014f\2\2\u0ed7\u0ed9\7\u013e\2")
        buf.write("\2\u0ed8\u0ed7\3\2\2\2\u0ed8\u0ed9\3\2\2\2\u0ed9\u0eda")
        buf.write("\3\2\2\2\u0eda\u0edc\7\u0150\2\2\u0edb\u0eb4\3\2\2\2\u0edb")
        buf.write("\u0eb9\3\2\2\2\u0edb\u0ebe\3\2\2\2\u0edb\u0ec4\3\2\2\2")
        buf.write("\u0edb\u0ec8\3\2\2\2\u0edb\u0ecc\3\2\2\2\u0edb\u0ed0\3")
        buf.write("\2\2\2\u0edb\u0ed4\3\2\2\2\u0edb\u0ed8\3\2\2\2\u0edc\u01a3")
        buf.write("\3\2\2\2\u0edd\u0ede\7\u011f\2\2\u0ede\u0ee5\5\u0178\u00bd")
        buf.write("\2\u0edf\u0ee5\5\u00b2Z\2\u0ee0\u0ee5\5\u0176\u00bc\2")
        buf.write("\u0ee1\u0ee2\t\63\2\2\u0ee2\u0ee3\7\u00c5\2\2\u0ee3\u0ee5")
        buf.write("\7\u00c6\2\2\u0ee4\u0edd\3\2\2\2\u0ee4\u0edf\3\2\2\2\u0ee4")
        buf.write("\u0ee0\3\2\2\2\u0ee4\u0ee1\3\2\2\2\u0ee5\u01a5\3\2\2\2")
        buf.write("\u0ee6\u0ee7\t\64\2\2\u0ee7\u01a7\3\2\2\2\u0ee8\u0ee9")
        buf.write("\t\65\2\2\u0ee9\u01a9\3\2\2\2\u0eea\u0eeb\t\66\2\2\u0eeb")
        buf.write("\u01ab\3\2\2\2\u0204\u01af\u01bc\u01bf\u01c3\u01c6\u01c9")
        buf.write("\u01d9\u01dd\u01e0\u01e5\u01e9\u01ec\u01f4\u01f7\u01fb")
        buf.write("\u01fe\u0202\u0209\u0210\u0217\u021b\u0224\u0228\u022f")
        buf.write("\u0233\u0238\u023c\u0241\u0245\u024a\u024e\u0253\u0257")
        buf.write("\u025b\u0262\u026a\u026e\u0272\u0276\u0279\u027e\u0285")
        buf.write("\u0288\u028c\u0290\u0293\u0297\u0299\u029d\u02a0\u02a4")
        buf.write("\u02a7\u02ab\u02af\u02b2\u02b7\u02bb\u02be\u02c2\u02c7")
        buf.write("\u02cc\u02d2\u02db\u02e0\u02e3\u02e6\u02e9\u02ed\u02f0")
        buf.write("\u02f3\u02f6\u02fb\u02fe\u0301\u0304\u0306\u030e\u0317")
        buf.write("\u031f\u0322\u032a\u0330\u0335\u033f\u0344\u0348\u034d")
        buf.write("\u0351\u0358\u035f\u0369\u036c\u0372\u0376\u0379\u0380")
        buf.write("\u0382\u038c\u0393\u0397\u039b\u03a0\u03a5\u03a8\u03af")
        buf.write("\u03b7\u03bc\u03c5\u03cd\u03d2\u03d9\u03eb\u03f6\u03ff")
        buf.write("\u0405\u040c\u0415\u041d\u0421\u0427\u042f\u043f\u0458")
        buf.write("\u045d\u0465\u046d\u046f\u0483\u0487\u048d\u0490\u0493")
        buf.write("\u049a\u049f\u04a2\u04a9\u04b5\u04be\u04c0\u04c4\u04c7")
        buf.write("\u04ce\u04d9\u04db\u04e3\u04e8\u04eb\u04f1\u04fc\u053c")
        buf.write("\u0545\u0549\u054f\u0553\u0558\u055e\u056a\u0572\u0578")
        buf.write("\u0585\u058a\u059a\u05a1\u05a5\u05ab\u05ba\u05be\u05c4")
        buf.write("\u05ca\u05cd\u05d0\u05d6\u05da\u05e2\u05e4\u05ed\u05f0")
        buf.write("\u05f9\u05fe\u0604\u060b\u060e\u0614\u061f\u0622\u0626")
        buf.write("\u062b\u0630\u0637\u063a\u063d\u0644\u0649\u0652\u065a")
        buf.write("\u0660\u0663\u0666\u066c\u0670\u0674\u0678\u067a\u0682")
        buf.write("\u068a\u0690\u0696\u0699\u069d\u06a0\u06a4\u06bd\u06c0")
        buf.write("\u06c4\u06ca\u06cd\u06d0\u06d6\u06de\u06e3\u06e9\u06ef")
        buf.write("\u06fb\u06fe\u0705\u070c\u0714\u0717\u071f\u0723\u072a")
        buf.write("\u079e\u07a6\u07ae\u07b7\u07c1\u07c5\u07c8\u07ce\u07d4")
        buf.write("\u07e0\u07ec\u07f1\u07fa\u07fd\u0805\u080c\u080e\u0813")
        buf.write("\u0817\u081c\u0821\u0826\u0829\u082e\u0832\u0837\u0839")
        buf.write("\u083d\u0846\u084e\u0857\u085e\u0867\u086c\u086f\u0882")
        buf.write("\u0884\u088d\u0894\u0897\u089e\u08a2\u08a8\u08b0\u08bb")
        buf.write("\u08c6\u08cd\u08d3\u08e0\u08e7\u08ee\u08fa\u0902\u0908")
        buf.write("\u090b\u0914\u0917\u0920\u0923\u092c\u092f\u0938\u093b")
        buf.write("\u093e\u0943\u0945\u094d\u0953\u095a\u0961\u0964\u0966")
        buf.write("\u096e\u0972\u0976\u097c\u0980\u0988\u098c\u098f\u0992")
        buf.write("\u0995\u0999\u099e\u09a5\u09a9\u09ac\u09af\u09b2\u09b4")
        buf.write("\u09b7\u09c3\u09c6\u09ca\u09d4\u09d8\u09da\u09dd\u09e1")
        buf.write("\u09e7\u09eb\u09f6\u0a00\u0a0c\u0a1b\u0a20\u0a27\u0a37")
        buf.write("\u0a3c\u0a49\u0a4e\u0a56\u0a5c\u0a60\u0a69\u0a78\u0a7d")
        buf.write("\u0a89\u0a8e\u0a96\u0a99\u0a9d\u0aab\u0ab8\u0abd\u0ac1")
        buf.write("\u0ac4\u0ac9\u0ad2\u0ad5\u0ada\u0ae1\u0ae4\u0aec\u0af3")
        buf.write("\u0afa\u0afd\u0b02\u0b05\u0b0a\u0b0e\u0b11\u0b14\u0b1a")
        buf.write("\u0b1f\u0b24\u0b36\u0b38\u0b3b\u0b46\u0b4f\u0b56\u0b5e")
        buf.write("\u0b65\u0b69\u0b6c\u0b74\u0b7c\u0b82\u0b8a\u0b96\u0b99")
        buf.write("\u0b9f\u0ba3\u0ba5\u0bae\u0bba\u0bbc\u0bc3\u0bca\u0bd0")
        buf.write("\u0bd6\u0bd8\u0bdf\u0be7\u0bed\u0bf4\u0bfa\u0bfe\u0c00")
        buf.write("\u0c07\u0c10\u0c1d\u0c22\u0c26\u0c34\u0c36\u0c3e\u0c40")
        buf.write("\u0c44\u0c4c\u0c55\u0c5b\u0c63\u0c68\u0c74\u0c79\u0c7c")
        buf.write("\u0c82\u0c86\u0c8b\u0c90\u0c95\u0c9b\u0cb0\u0cb2\u0cbb")
        buf.write("\u0cbf\u0cc8\u0ccc\u0cde\u0ce1\u0ce9\u0cf2\u0d09\u0d14")
        buf.write("\u0d1b\u0d1e\u0d27\u0d2b\u0d37\u0d50\u0d57\u0d5a\u0d69")
        buf.write("\u0d6d\u0d77\u0d79\u0d86\u0d88\u0d92\u0d9f\u0da3\u0daa")
        buf.write("\u0daf\u0db7\u0dbb\u0dc4\u0dc9\u0dda\u0dde\u0de7\u0deb")
        buf.write("\u0ded\u0df4\u0dfb\u0dfe\u0e01\u0e08\u0e0f\u0e12\u0e19")
        buf.write("\u0e21\u0e24\u0e31\u0e45\u0e4f\u0e52\u0e5b\u0e5e\u0e60")
        buf.write("\u0e63\u0e66\u0e78\u0e81\u0e88\u0e8f\u0e96\u0ea0\u0ea3")
        buf.write("\u0ea8\u0eb0\u0eb6\u0ebb\u0ec0\u0ec4\u0ec8\u0ecc\u0ed0")
        buf.write("\u0ed4\u0ed8\u0edb\u0ee4")
        return buf.getvalue()


class fugue_sqlParser ( Parser ):

    grammarFileName = "fugue_sql.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "','", "':'", "'('", "')'", "'['", "']'", 
                     "'.'", "'{'", "'}'", "'true'", "'false'", "'null'", 
                     "';'", "'/*+'", "'*/'", "'->'", "'FILL'", "'TAKE'", 
                     "'HASH'", "'RAND'", "'EVEN'", "'PRESORT'", "'PERSIST'", 
                     "'BROADCAST'", "'PARAMS'", "'PROCESS'", "'OUTPUT'", 
                     "'OUTTRANSFORM'", "'ROWCOUNT'", "'CONCURRENCY'", "'PREPARTITION'", 
                     "'ZIP'", "'PRINT'", "'TITLE'", "'SAVE'", "'APPEND'", 
                     "'PARQUET'", "'CSV'", "'JSON'", "'SINGLE'", "':='", 
                     "'CHECKPOINT'", "'WEAK'", "'STRONG'", "'DETERMINISTIC'", 
                     "'YIELD'", "'CONNECT'", "'SAMPLE'", "'SEED'", "'SUB'", 
                     "'CALLBACK'", "'DATAFRAME'", "'FILE'", "'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>", "'+'", "'-'", "'*'", "'/'", "'%'", 
                     "'DIV'", "'~'", "'&'", "'|'", "'||'", "'^'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "FILL", "TAKE", "HASH", "RAND", "EVEN", 
                      "PRESORT", "PERSIST", "BROADCAST", "PARAMS", "PROCESS", 
                      "OUTPUT", "OUTTRANSFORM", "ROWCOUNT", "CONCURRENCY", 
                      "PREPARTITION", "ZIP", "PRINT", "TITLE", "SAVE", "APPEND", 
                      "PARQUET", "CSV", "JSON", "SINGLE", "COLONEQUAL", 
                      "CHECKPOINT", "WEAK", "STRONG", "DETERMINISTIC", "YIELD", 
                      "CONNECT", "SAMPLE", "SEED", "SUB", "CALLBACK", "DATAFRAME", 
                      "FILE", "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", "EQUAL", 
                      "DOUBLEEQUAL", "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_fugueLanguage = 0
    RULE_fugueSingleStatement = 1
    RULE_fugueSingleTask = 2
    RULE_fugueNestableTask = 3
    RULE_fugueNestableTaskCollectionNoSelect = 4
    RULE_fugueTransformTask = 5
    RULE_fugueProcessTask = 6
    RULE_fugueSaveAndUseTask = 7
    RULE_fugueRenameColumnsTask = 8
    RULE_fugueAlterColumnsTask = 9
    RULE_fugueDropColumnsTask = 10
    RULE_fugueDropnaTask = 11
    RULE_fugueFillnaTask = 12
    RULE_fugueSampleTask = 13
    RULE_fugueTakeTask = 14
    RULE_fugueZipTask = 15
    RULE_fugueCreateTask = 16
    RULE_fugueCreateDataTask = 17
    RULE_fugueLoadTask = 18
    RULE_fugueOutputTask = 19
    RULE_fuguePrintTask = 20
    RULE_fugueSaveTask = 21
    RULE_fugueOutputTransformTask = 22
    RULE_fugueModuleTask = 23
    RULE_fugueSqlEngine = 24
    RULE_fugueSingleFile = 25
    RULE_fugueLoadColumns = 26
    RULE_fugueSaveMode = 27
    RULE_fugueFileFormat = 28
    RULE_fuguePath = 29
    RULE_fugueCheckpoint = 30
    RULE_fugueCheckpointNamespace = 31
    RULE_fugueYield = 32
    RULE_fugueBroadcast = 33
    RULE_fugueDataFrames = 34
    RULE_fugueDataFramePair = 35
    RULE_fugueDataFrame = 36
    RULE_fugueDataFrameMember = 37
    RULE_fugueAssignment = 38
    RULE_fugueAssignmentSign = 39
    RULE_fugueSingleOutputExtensionCommonWild = 40
    RULE_fugueSingleOutputExtensionCommon = 41
    RULE_fugueExtension = 42
    RULE_fugueSampleMethod = 43
    RULE_fugueZipType = 44
    RULE_fuguePrepartition = 45
    RULE_fuguePartitionAlgo = 46
    RULE_fuguePartitionNum = 47
    RULE_fuguePartitionNumber = 48
    RULE_fugueParams = 49
    RULE_fugueCols = 50
    RULE_fugueColsSort = 51
    RULE_fugueColSort = 52
    RULE_fugueColumnIdentifier = 53
    RULE_fugueRenameExpression = 54
    RULE_fugueWildSchema = 55
    RULE_fugueWildSchemaPair = 56
    RULE_fugueSchema = 57
    RULE_fugueSchemaPair = 58
    RULE_fugueSchemaKey = 59
    RULE_fugueSchemaType = 60
    RULE_fugueRenamePair = 61
    RULE_fugueJson = 62
    RULE_fugueJsonObj = 63
    RULE_fugueJsonPairs = 64
    RULE_fugueJsonPair = 65
    RULE_fugueJsonKey = 66
    RULE_fugueJsonArray = 67
    RULE_fugueJsonValue = 68
    RULE_fugueJsonNumber = 69
    RULE_fugueJsonString = 70
    RULE_fugueJsonBool = 71
    RULE_fugueJsonNull = 72
    RULE_fugueIdentifier = 73
    RULE_singleStatement = 74
    RULE_singleExpression = 75
    RULE_singleTableIdentifier = 76
    RULE_singleMultipartIdentifier = 77
    RULE_singleFunctionIdentifier = 78
    RULE_singleDataType = 79
    RULE_singleTableSchema = 80
    RULE_statement = 81
    RULE_unsupportedHiveNativeCommands = 82
    RULE_createTableHeader = 83
    RULE_replaceTableHeader = 84
    RULE_bucketSpec = 85
    RULE_skewSpec = 86
    RULE_locationSpec = 87
    RULE_commentSpec = 88
    RULE_query = 89
    RULE_insertInto = 90
    RULE_partitionSpecLocation = 91
    RULE_partitionSpec = 92
    RULE_partitionVal = 93
    RULE_namespace = 94
    RULE_describeFuncName = 95
    RULE_describeColName = 96
    RULE_ctes = 97
    RULE_namedQuery = 98
    RULE_tableProvider = 99
    RULE_createTableClauses = 100
    RULE_tablePropertyList = 101
    RULE_tableProperty = 102
    RULE_tablePropertyKey = 103
    RULE_tablePropertyValue = 104
    RULE_constantList = 105
    RULE_nestedConstantList = 106
    RULE_createFileFormat = 107
    RULE_fileFormat = 108
    RULE_storageHandler = 109
    RULE_resource = 110
    RULE_dmlStatementNoWith = 111
    RULE_queryOrganization = 112
    RULE_multiInsertQueryBody = 113
    RULE_queryTerm = 114
    RULE_queryPrimary = 115
    RULE_sortItem = 116
    RULE_fromStatement = 117
    RULE_fromStatementBody = 118
    RULE_querySpecification = 119
    RULE_optionalFromClause = 120
    RULE_transformClause = 121
    RULE_selectClause = 122
    RULE_setClause = 123
    RULE_matchedClause = 124
    RULE_notMatchedClause = 125
    RULE_matchedAction = 126
    RULE_notMatchedAction = 127
    RULE_assignmentList = 128
    RULE_assignment = 129
    RULE_whereClause = 130
    RULE_havingClause = 131
    RULE_hint = 132
    RULE_hintStatement = 133
    RULE_fromClause = 134
    RULE_aggregationClause = 135
    RULE_groupingSet = 136
    RULE_pivotClause = 137
    RULE_pivotColumn = 138
    RULE_pivotValue = 139
    RULE_lateralView = 140
    RULE_setQuantifier = 141
    RULE_relation = 142
    RULE_joinRelation = 143
    RULE_joinType = 144
    RULE_joinCriteria = 145
    RULE_sample = 146
    RULE_sampleMethod = 147
    RULE_identifierList = 148
    RULE_identifierSeq = 149
    RULE_orderedIdentifierList = 150
    RULE_orderedIdentifier = 151
    RULE_identifierCommentList = 152
    RULE_identifierComment = 153
    RULE_relationPrimary = 154
    RULE_inlineTable = 155
    RULE_functionTable = 156
    RULE_tableAlias = 157
    RULE_rowFormat = 158
    RULE_multipartIdentifierList = 159
    RULE_multipartIdentifier = 160
    RULE_tableIdentifier = 161
    RULE_functionIdentifier = 162
    RULE_namedExpression = 163
    RULE_namedExpressionSeq = 164
    RULE_transformList = 165
    RULE_transform = 166
    RULE_transformArgument = 167
    RULE_expression = 168
    RULE_booleanExpression = 169
    RULE_predicate = 170
    RULE_valueExpression = 171
    RULE_primaryExpression = 172
    RULE_constant = 173
    RULE_comparisonOperator = 174
    RULE_comparisonEqualOperator = 175
    RULE_arithmeticOperator = 176
    RULE_predicateOperator = 177
    RULE_booleanValue = 178
    RULE_interval = 179
    RULE_errorCapturingMultiUnitsInterval = 180
    RULE_multiUnitsInterval = 181
    RULE_errorCapturingUnitToUnitInterval = 182
    RULE_unitToUnitInterval = 183
    RULE_intervalValue = 184
    RULE_intervalUnit = 185
    RULE_colPosition = 186
    RULE_dataType = 187
    RULE_qualifiedColTypeWithPositionList = 188
    RULE_qualifiedColTypeWithPosition = 189
    RULE_colTypeList = 190
    RULE_colType = 191
    RULE_complexColTypeList = 192
    RULE_complexColType = 193
    RULE_whenClause = 194
    RULE_windowClause = 195
    RULE_namedWindow = 196
    RULE_windowSpec = 197
    RULE_windowFrame = 198
    RULE_frameBound = 199
    RULE_qualifiedNameList = 200
    RULE_functionName = 201
    RULE_qualifiedName = 202
    RULE_errorCapturingIdentifier = 203
    RULE_errorCapturingIdentifierExtra = 204
    RULE_identifier = 205
    RULE_strictIdentifier = 206
    RULE_quotedIdentifier = 207
    RULE_number = 208
    RULE_alterColumnAction = 209
    RULE_ansiNonReserved = 210
    RULE_strictNonReserved = 211
    RULE_nonReserved = 212

    ruleNames =  [ "fugueLanguage", "fugueSingleStatement", "fugueSingleTask", 
                   "fugueNestableTask", "fugueNestableTaskCollectionNoSelect", 
                   "fugueTransformTask", "fugueProcessTask", "fugueSaveAndUseTask", 
                   "fugueRenameColumnsTask", "fugueAlterColumnsTask", "fugueDropColumnsTask", 
                   "fugueDropnaTask", "fugueFillnaTask", "fugueSampleTask", 
                   "fugueTakeTask", "fugueZipTask", "fugueCreateTask", "fugueCreateDataTask", 
                   "fugueLoadTask", "fugueOutputTask", "fuguePrintTask", 
                   "fugueSaveTask", "fugueOutputTransformTask", "fugueModuleTask", 
                   "fugueSqlEngine", "fugueSingleFile", "fugueLoadColumns", 
                   "fugueSaveMode", "fugueFileFormat", "fuguePath", "fugueCheckpoint", 
                   "fugueCheckpointNamespace", "fugueYield", "fugueBroadcast", 
                   "fugueDataFrames", "fugueDataFramePair", "fugueDataFrame", 
                   "fugueDataFrameMember", "fugueAssignment", "fugueAssignmentSign", 
                   "fugueSingleOutputExtensionCommonWild", "fugueSingleOutputExtensionCommon", 
                   "fugueExtension", "fugueSampleMethod", "fugueZipType", 
                   "fuguePrepartition", "fuguePartitionAlgo", "fuguePartitionNum", 
                   "fuguePartitionNumber", "fugueParams", "fugueCols", "fugueColsSort", 
                   "fugueColSort", "fugueColumnIdentifier", "fugueRenameExpression", 
                   "fugueWildSchema", "fugueWildSchemaPair", "fugueSchema", 
                   "fugueSchemaPair", "fugueSchemaKey", "fugueSchemaType", 
                   "fugueRenamePair", "fugueJson", "fugueJsonObj", "fugueJsonPairs", 
                   "fugueJsonPair", "fugueJsonKey", "fugueJsonArray", "fugueJsonValue", 
                   "fugueJsonNumber", "fugueJsonString", "fugueJsonBool", 
                   "fugueJsonNull", "fugueIdentifier", "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", 
                   "optionalFromClause", "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", 
                   "comparisonEqualOperator", "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
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    FILL=17
    TAKE=18
    HASH=19
    RAND=20
    EVEN=21
    PRESORT=22
    PERSIST=23
    BROADCAST=24
    PARAMS=25
    PROCESS=26
    OUTPUT=27
    OUTTRANSFORM=28
    ROWCOUNT=29
    CONCURRENCY=30
    PREPARTITION=31
    ZIP=32
    PRINT=33
    TITLE=34
    SAVE=35
    APPEND=36
    PARQUET=37
    CSV=38
    JSON=39
    SINGLE=40
    COLONEQUAL=41
    CHECKPOINT=42
    WEAK=43
    STRONG=44
    DETERMINISTIC=45
    YIELD=46
    CONNECT=47
    SAMPLE=48
    SEED=49
    SUB=50
    CALLBACK=51
    DATAFRAME=52
    FILE=53
    ADD=54
    AFTER=55
    ALL=56
    ALTER=57
    ANALYZE=58
    AND=59
    ANTI=60
    ANY=61
    ARCHIVE=62
    ARRAY=63
    AS=64
    ASC=65
    AT=66
    AUTHORIZATION=67
    BETWEEN=68
    BOTH=69
    BUCKET=70
    BUCKETS=71
    BY=72
    CACHE=73
    CASCADE=74
    CASE=75
    CAST=76
    CHANGE=77
    CHECK=78
    CLEAR=79
    CLUSTER=80
    CLUSTERED=81
    CODEGEN=82
    COLLATE=83
    COLLECTION=84
    COLUMN=85
    COLUMNS=86
    COMMENT=87
    COMMIT=88
    COMPACT=89
    COMPACTIONS=90
    COMPUTE=91
    CONCATENATE=92
    CONSTRAINT=93
    COST=94
    CREATE=95
    CROSS=96
    CUBE=97
    CURRENT=98
    CURRENT_DATE=99
    CURRENT_TIME=100
    CURRENT_TIMESTAMP=101
    CURRENT_USER=102
    DATA=103
    DATABASE=104
    DATABASES=105
    DAY=106
    DBPROPERTIES=107
    DEFINED=108
    DELETE=109
    DELIMITED=110
    DESC=111
    DESCRIBE=112
    DFS=113
    DIRECTORIES=114
    DIRECTORY=115
    DISTINCT=116
    DISTRIBUTE=117
    DROP=118
    ELSE=119
    END=120
    ESCAPE=121
    ESCAPED=122
    EXCEPT=123
    EXCHANGE=124
    EXISTS=125
    EXPLAIN=126
    EXPORT=127
    EXTENDED=128
    EXTERNAL=129
    EXTRACT=130
    FALSE=131
    FETCH=132
    FIELDS=133
    FILTER=134
    FILEFORMAT=135
    FIRST=136
    FOLLOWING=137
    FOR=138
    FOREIGN=139
    FORMAT=140
    FORMATTED=141
    FROM=142
    FULL=143
    FUNCTION=144
    FUNCTIONS=145
    GLOBAL=146
    GRANT=147
    GROUP=148
    GROUPING=149
    HAVING=150
    HOUR=151
    IF=152
    IGNORE=153
    IMPORT=154
    IN=155
    INDEX=156
    INDEXES=157
    INNER=158
    INPATH=159
    INPUTFORMAT=160
    INSERT=161
    INTERSECT=162
    INTERVAL=163
    INTO=164
    IS=165
    ITEMS=166
    JOIN=167
    KEYS=168
    LAST=169
    LATERAL=170
    LAZY=171
    LEADING=172
    LEFT=173
    LIKE=174
    LIMIT=175
    LINES=176
    LIST=177
    LOAD=178
    LOCAL=179
    LOCATION=180
    LOCK=181
    LOCKS=182
    LOGICAL=183
    MACRO=184
    MAP=185
    MATCHED=186
    MERGE=187
    MINUTE=188
    MONTH=189
    MSCK=190
    NAMESPACE=191
    NAMESPACES=192
    NATURAL=193
    NO=194
    NOT=195
    NULL=196
    NULLS=197
    OF=198
    ON=199
    ONLY=200
    OPTION=201
    OPTIONS=202
    OR=203
    ORDER=204
    OUT=205
    OUTER=206
    OUTPUTFORMAT=207
    OVER=208
    OVERLAPS=209
    OVERLAY=210
    OVERWRITE=211
    PARTITION=212
    PARTITIONED=213
    PARTITIONS=214
    PERCENTLIT=215
    PIVOT=216
    PLACING=217
    POSITION=218
    PRECEDING=219
    PRIMARY=220
    PRINCIPALS=221
    PROPERTIES=222
    PURGE=223
    QUERY=224
    RANGE=225
    RECORDREADER=226
    RECORDWRITER=227
    RECOVER=228
    REDUCE=229
    REFERENCES=230
    REFRESH=231
    RENAME=232
    REPAIR=233
    REPLACE=234
    RESET=235
    RESTRICT=236
    REVOKE=237
    RIGHT=238
    RLIKE=239
    ROLE=240
    ROLES=241
    ROLLBACK=242
    ROLLUP=243
    ROW=244
    ROWS=245
    SCHEMA=246
    SECOND=247
    SELECT=248
    SEMI=249
    SEPARATED=250
    SERDE=251
    SERDEPROPERTIES=252
    SESSION_USER=253
    SET=254
    SETMINUS=255
    SETS=256
    SHOW=257
    SKEWED=258
    SOME=259
    SORT=260
    SORTED=261
    START=262
    STATISTICS=263
    STORED=264
    STRATIFY=265
    STRUCT=266
    SUBSTR=267
    SUBSTRING=268
    TABLE=269
    TABLES=270
    TABLESAMPLE=271
    TBLPROPERTIES=272
    TEMPORARY=273
    TERMINATED=274
    THEN=275
    TO=276
    TOUCH=277
    TRAILING=278
    TRANSACTION=279
    TRANSACTIONS=280
    TRANSFORM=281
    TRIM=282
    TRUE=283
    TRUNCATE=284
    TYPE=285
    UNARCHIVE=286
    UNBOUNDED=287
    UNCACHE=288
    UNION=289
    UNIQUE=290
    UNKNOWN=291
    UNLOCK=292
    UNSET=293
    UPDATE=294
    USE=295
    USER=296
    USING=297
    VALUES=298
    VIEW=299
    VIEWS=300
    WHEN=301
    WHERE=302
    WINDOW=303
    WITH=304
    YEAR=305
    EQUAL=306
    DOUBLEEQUAL=307
    NSEQ=308
    NEQ=309
    NEQJ=310
    LT=311
    LTE=312
    GT=313
    GTE=314
    PLUS=315
    MINUS=316
    ASTERISK=317
    SLASH=318
    PERCENT=319
    DIV=320
    TILDE=321
    AMPERSAND=322
    PIPE=323
    CONCAT_PIPE=324
    HAT=325
    STRING=326
    BIGINT_LITERAL=327
    SMALLINT_LITERAL=328
    TINYINT_LITERAL=329
    INTEGER_VALUE=330
    EXPONENT_VALUE=331
    DECIMAL_VALUE=332
    DOUBLE_LITERAL=333
    BIGDECIMAL_LITERAL=334
    IDENTIFIER=335
    BACKQUOTED_IDENTIFIER=336
    SIMPLE_COMMENT=337
    BRACKETED_COMMENT=338
    WS=339
    UNRECOGNIZED=340

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.9")
        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.
    legacy_setops_precedence_enbled = False

    # When false, a literal with an exponent would be converted into
    # double type rather than decimal type.
    legacy_exponent_literal_as_decimal_enabled = 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.
    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

    @property
    def simpleAssign(self):
        if "_simple_assign" in self.__dict__:
            return self._simple_assign
        return False




    class FugueLanguageContext(ParserRuleContext):

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

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

        def fugueSingleTask(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueSingleTaskContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueSingleTaskContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueLanguage

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




    def fugueLanguage(self):

        localctx = fugue_sqlParser.FugueLanguageContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_fugueLanguage)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 427 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 426
                    self.fugueSingleTask()

                else:
                    raise NoViableAltException(self)
                self.state = 429 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,0,self._ctx)

            self.state = 431
            self.match(fugue_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 FugueSingleStatementContext(ParserRuleContext):

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

        def fugueSingleTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSingleTaskContext,0)


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleStatement

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




    def fugueSingleStatement(self):

        localctx = fugue_sqlParser.FugueSingleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_fugueSingleStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 433
            self.fugueSingleTask()
            self.state = 434
            self.match(fugue_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 FugueSingleTaskContext(ParserRuleContext):

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

        def fugueNestableTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueNestableTaskContext,0)


        def fugueOutputTransformTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueOutputTransformTaskContext,0)


        def fugueOutputTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueOutputTaskContext,0)


        def fuguePrintTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrintTaskContext,0)


        def fugueSaveTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSaveTaskContext,0)


        def fugueModuleTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueModuleTaskContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleTask

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




    def fugueSingleTask(self):

        localctx = fugue_sqlParser.FugueSingleTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_fugueSingleTask)
        try:
            self.state = 442
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 436
                self.fugueNestableTask()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 437
                self.fugueOutputTransformTask()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 438
                self.fugueOutputTask()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 439
                self.fuguePrintTask()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 440
                self.fugueSaveTask()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 441
                self.fugueModuleTask()
                pass


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


    class FugueNestableTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.assign = None # FugueAssignmentContext
            self.q = None # QueryContext
            self.checkpoint = None # FugueCheckpointContext
            self.broadcast = None # FugueBroadcastContext
            self.y = None # FugueYieldContext

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


        def fugueAssignment(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueAssignmentContext,0)


        def fugueCheckpoint(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueCheckpointContext,0)


        def fugueBroadcast(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueBroadcastContext,0)


        def fugueYield(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueYieldContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueNestableTask

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




    def fugueNestableTask(self):

        localctx = fugue_sqlParser.FugueNestableTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_fugueNestableTask)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 445
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 444
                localctx.assign = self.fugueAssignment()


            self.state = 447
            localctx.q = self.query()
            self.state = 449
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.state = 448
                localctx.checkpoint = self.fugueCheckpoint()


            self.state = 452
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.state = 451
                localctx.broadcast = self.fugueBroadcast()


            self.state = 455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.state = 454
                localctx.y = self.fugueYield()


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


    class FugueNestableTaskCollectionNoSelectContext(ParserRuleContext):

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

        def fugueTransformTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueTransformTaskContext,0)


        def fugueProcessTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueProcessTaskContext,0)


        def fugueZipTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueZipTaskContext,0)


        def fugueCreateTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueCreateTaskContext,0)


        def fugueCreateDataTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueCreateDataTaskContext,0)


        def fugueLoadTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueLoadTaskContext,0)


        def fugueSaveAndUseTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSaveAndUseTaskContext,0)


        def fugueRenameColumnsTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueRenameColumnsTaskContext,0)


        def fugueAlterColumnsTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueAlterColumnsTaskContext,0)


        def fugueDropColumnsTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDropColumnsTaskContext,0)


        def fugueDropnaTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDropnaTaskContext,0)


        def fugueFillnaTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueFillnaTaskContext,0)


        def fugueSampleTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSampleTaskContext,0)


        def fugueTakeTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueTakeTaskContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueNestableTaskCollectionNoSelect

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




    def fugueNestableTaskCollectionNoSelect(self):

        localctx = fugue_sqlParser.FugueNestableTaskCollectionNoSelectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_fugueNestableTaskCollectionNoSelect)
        try:
            self.state = 471
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 457
                self.fugueTransformTask()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 458
                self.fugueProcessTask()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 459
                self.fugueZipTask()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 460
                self.fugueCreateTask()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 461
                self.fugueCreateDataTask()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 462
                self.fugueLoadTask()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 463
                self.fugueSaveAndUseTask()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 464
                self.fugueRenameColumnsTask()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 465
                self.fugueAlterColumnsTask()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 466
                self.fugueDropColumnsTask()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 467
                self.fugueDropnaTask()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 468
                self.fugueFillnaTask()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 469
                self.fugueSampleTask()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 470
                self.fugueTakeTask()
                pass


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


    class FugueTransformTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.dfs = None # FugueDataFramesContext
            self.partition = None # FuguePrepartitionContext
            self.params = None # FugueSingleOutputExtensionCommonWildContext
            self.callback = None # FugueExtensionContext

        def TRANSFORM(self):
            return self.getToken(fugue_sqlParser.TRANSFORM, 0)

        def fugueSingleOutputExtensionCommonWild(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSingleOutputExtensionCommonWildContext,0)


        def CALLBACK(self):
            return self.getToken(fugue_sqlParser.CALLBACK, 0)

        def fugueDataFrames(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFramesContext,0)


        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)


        def fugueExtension(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueExtensionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueTransformTask

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




    def fugueTransformTask(self):

        localctx = fugue_sqlParser.FugueTransformTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_fugueTransformTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 473
            self.match(fugue_sqlParser.TRANSFORM)
            self.state = 475
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 474
                localctx.dfs = self.fugueDataFrames()


            self.state = 478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN) | (1 << fugue_sqlParser.PREPARTITION))) != 0):
                self.state = 477
                localctx.partition = self.fuguePrepartition()


            self.state = 480
            localctx.params = self.fugueSingleOutputExtensionCommonWild()
            self.state = 483
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 481
                self.match(fugue_sqlParser.CALLBACK)
                self.state = 482
                localctx.callback = self.fugueExtension()


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


    class FugueProcessTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.dfs = None # FugueDataFramesContext
            self.partition = None # FuguePrepartitionContext
            self.params = None # FugueSingleOutputExtensionCommonContext

        def PROCESS(self):
            return self.getToken(fugue_sqlParser.PROCESS, 0)

        def fugueSingleOutputExtensionCommon(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSingleOutputExtensionCommonContext,0)


        def fugueDataFrames(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFramesContext,0)


        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueProcessTask

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




    def fugueProcessTask(self):

        localctx = fugue_sqlParser.FugueProcessTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_fugueProcessTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 485
            self.match(fugue_sqlParser.PROCESS)
            self.state = 487
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.state = 486
                localctx.dfs = self.fugueDataFrames()


            self.state = 490
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN) | (1 << fugue_sqlParser.PREPARTITION))) != 0):
                self.state = 489
                localctx.partition = self.fuguePrepartition()


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


    class FugueSaveAndUseTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.df = None # FugueDataFrameContext
            self.partition = None # FuguePrepartitionContext
            self.m = None # FugueSaveModeContext
            self.single = None # FugueSingleFileContext
            self.fmt = None # FugueFileFormatContext
            self.path = None # FuguePathContext
            self.params = None # FugueParamsContext

        def SAVE(self):
            return self.getToken(fugue_sqlParser.SAVE, 0)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def USE(self):
            return self.getToken(fugue_sqlParser.USE, 0)

        def fugueSaveMode(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSaveModeContext,0)


        def fuguePath(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePathContext,0)


        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)


        def fugueSingleFile(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSingleFileContext,0)


        def fugueFileFormat(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueFileFormatContext,0)


        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSaveAndUseTask

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




    def fugueSaveAndUseTask(self):

        localctx = fugue_sqlParser.FugueSaveAndUseTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_fugueSaveAndUseTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 494
            self.match(fugue_sqlParser.SAVE)
            self.state = 495
            self.match(fugue_sqlParser.AND)
            self.state = 496
            self.match(fugue_sqlParser.USE)
            self.state = 498
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.state = 497
                localctx.df = self.fugueDataFrame()


            self.state = 501
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN) | (1 << fugue_sqlParser.PREPARTITION))) != 0):
                self.state = 500
                localctx.partition = self.fuguePrepartition()


            self.state = 503
            localctx.m = self.fugueSaveMode()
            self.state = 505
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.SINGLE:
                self.state = 504
                localctx.single = self.fugueSingleFile()


            self.state = 508
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.PARQUET) | (1 << fugue_sqlParser.CSV) | (1 << fugue_sqlParser.JSON))) != 0):
                self.state = 507
                localctx.fmt = self.fugueFileFormat()


            self.state = 510
            localctx.path = self.fuguePath()
            self.state = 512
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.state = 511
                localctx.params = self.fugueParams()


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


    class FugueRenameColumnsTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.cols = None # FugueRenameExpressionContext
            self.df = None # FugueDataFrameContext

        def RENAME(self):
            return self.getToken(fugue_sqlParser.RENAME, 0)

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

        def fugueRenameExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueRenameExpressionContext,0)


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

        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueRenameColumnsTask

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




    def fugueRenameColumnsTask(self):

        localctx = fugue_sqlParser.FugueRenameColumnsTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_fugueRenameColumnsTask)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 514
            self.match(fugue_sqlParser.RENAME)
            self.state = 515
            self.match(fugue_sqlParser.COLUMNS)
            self.state = 516
            localctx.cols = self.fugueRenameExpression()
            self.state = 519
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.state = 517
                self.match(fugue_sqlParser.FROM)
                self.state = 518
                localctx.df = self.fugueDataFrame()


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


    class FugueAlterColumnsTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.cols = None # FugueSchemaContext
            self.df = None # FugueDataFrameContext

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

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

        def fugueSchema(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaContext,0)


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

        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueAlterColumnsTask

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




    def fugueAlterColumnsTask(self):

        localctx = fugue_sqlParser.FugueAlterColumnsTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_fugueAlterColumnsTask)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 521
            self.match(fugue_sqlParser.ALTER)
            self.state = 522
            self.match(fugue_sqlParser.COLUMNS)
            self.state = 523
            localctx.cols = self.fugueSchema()
            self.state = 526
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
            if la_ == 1:
                self.state = 524
                self.match(fugue_sqlParser.FROM)
                self.state = 525
                localctx.df = self.fugueDataFrame()


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


    class FugueDropColumnsTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.cols = None # FugueColsContext
            self.df = None # FugueDataFrameContext

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

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

        def fugueCols(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColsContext,0)


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

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

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

        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDropColumnsTask

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




    def fugueDropColumnsTask(self):

        localctx = fugue_sqlParser.FugueDropColumnsTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_fugueDropColumnsTask)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 528
            self.match(fugue_sqlParser.DROP)
            self.state = 529
            self.match(fugue_sqlParser.COLUMNS)
            self.state = 530
            localctx.cols = self.fugueCols()
            self.state = 533
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.state = 531
                self.match(fugue_sqlParser.IF)
                self.state = 532
                self.match(fugue_sqlParser.EXISTS)


            self.state = 537
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.state = 535
                self.match(fugue_sqlParser.FROM)
                self.state = 536
                localctx.df = self.fugueDataFrame()


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


    class FugueDropnaTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.how = None # Token
            self.cols = None # FugueColsContext
            self.df = None # FugueDataFrameContext

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

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

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

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

        def NULLS(self):
            return self.getToken(fugue_sqlParser.NULLS, 0)

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

        def ANY(self):
            return self.getToken(fugue_sqlParser.ANY, 0)

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

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

        def fugueCols(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColsContext,0)


        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDropnaTask

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




    def fugueDropnaTask(self):

        localctx = fugue_sqlParser.FugueDropnaTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_fugueDropnaTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539
            self.match(fugue_sqlParser.DROP)
            self.state = 540
            self.match(fugue_sqlParser.ROWS)
            self.state = 541
            self.match(fugue_sqlParser.IF)
            self.state = 542
            localctx.how = self._input.LT(1)
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.ALL or _la==fugue_sqlParser.ANY):
                localctx.how = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 543
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.NULL or _la==fugue_sqlParser.NULLS):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 546
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.state = 544
                self.match(fugue_sqlParser.ON)
                self.state = 545
                localctx.cols = self.fugueCols()


            self.state = 550
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.state = 548
                self.match(fugue_sqlParser.FROM)
                self.state = 549
                localctx.df = self.fugueDataFrame()


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


    class FugueFillnaTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.params = None # FugueParamsContext
            self.df = None # FugueDataFrameContext

        def FILL(self):
            return self.getToken(fugue_sqlParser.FILL, 0)

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

        def NULLS(self):
            return self.getToken(fugue_sqlParser.NULLS, 0)

        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


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

        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueFillnaTask

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




    def fugueFillnaTask(self):

        localctx = fugue_sqlParser.FugueFillnaTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_fugueFillnaTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 552
            self.match(fugue_sqlParser.FILL)
            self.state = 553
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.NULL or _la==fugue_sqlParser.NULLS):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 554
            localctx.params = self.fugueParams()
            self.state = 557
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.state = 555
                self.match(fugue_sqlParser.FROM)
                self.state = 556
                localctx.df = self.fugueDataFrame()


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


    class FugueSampleTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.method = None # FugueSampleMethodContext
            self.seed = None # Token
            self.df = None # FugueDataFrameContext

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

        def fugueSampleMethod(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSampleMethodContext,0)


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

        def SEED(self):
            return self.getToken(fugue_sqlParser.SEED, 0)

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

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

        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSampleTask

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




    def fugueSampleTask(self):

        localctx = fugue_sqlParser.FugueSampleTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_fugueSampleTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 559
            self.match(fugue_sqlParser.SAMPLE)
            self.state = 561
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.REPLACE:
                self.state = 560
                self.match(fugue_sqlParser.REPLACE)


            self.state = 563
            localctx.method = self.fugueSampleMethod()
            self.state = 566
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
            if la_ == 1:
                self.state = 564
                self.match(fugue_sqlParser.SEED)
                self.state = 565
                localctx.seed = self.match(fugue_sqlParser.INTEGER_VALUE)


            self.state = 570
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.state = 568
                self.match(fugue_sqlParser.FROM)
                self.state = 569
                localctx.df = self.fugueDataFrame()


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


    class FugueTakeTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.rows = None # Token
            self.df = None # FugueDataFrameContext
            self.partition = None # FuguePrepartitionContext
            self.presort = None # FugueColsSortContext
            self.na_position = None # Token

        def TAKE(self):
            return self.getToken(fugue_sqlParser.TAKE, 0)

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

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

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

        def NULLS(self):
            return self.getToken(fugue_sqlParser.NULLS, 0)

        def PRESORT(self):
            return self.getToken(fugue_sqlParser.PRESORT, 0)

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)

        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)


        def fugueColsSort(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColsSortContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueTakeTask

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




    def fugueTakeTask(self):

        localctx = fugue_sqlParser.FugueTakeTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_fugueTakeTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 572
            self.match(fugue_sqlParser.TAKE)
            self.state = 575
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.state = 573
                localctx.rows = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 574
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.ROW or _la==fugue_sqlParser.ROWS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 579
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                self.state = 577
                self.match(fugue_sqlParser.FROM)
                self.state = 578
                localctx.df = self.fugueDataFrame()


            self.state = 584
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.state = 581
                localctx.partition = self.fuguePrepartition()

            elif la_ == 2:
                self.state = 582
                self.match(fugue_sqlParser.PRESORT)
                self.state = 583
                localctx.presort = self.fugueColsSort()


            self.state = 588
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.state = 586
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.NULL or _la==fugue_sqlParser.NULLS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 587
                localctx.na_position = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.FIRST or _la==fugue_sqlParser.LAST):
                    localctx.na_position = 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 FugueZipTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.dfs = None # FugueDataFramesContext
            self.how = None # FugueZipTypeContext
            self.by = None # FugueColsContext
            self.presort = None # FugueColsSortContext

        def ZIP(self):
            return self.getToken(fugue_sqlParser.ZIP, 0)

        def fugueDataFrames(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFramesContext,0)


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

        def PRESORT(self):
            return self.getToken(fugue_sqlParser.PRESORT, 0)

        def fugueZipType(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueZipTypeContext,0)


        def fugueCols(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColsContext,0)


        def fugueColsSort(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColsSortContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueZipTask

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




    def fugueZipTask(self):

        localctx = fugue_sqlParser.FugueZipTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_fugueZipTask)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 590
            self.match(fugue_sqlParser.ZIP)
            self.state = 591
            localctx.dfs = self.fugueDataFrames()
            self.state = 593
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.state = 592
                localctx.how = self.fugueZipType()


            self.state = 597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
            if la_ == 1:
                self.state = 595
                self.match(fugue_sqlParser.BY)
                self.state = 596
                localctx.by = self.fugueCols()


            self.state = 601
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.state = 599
                self.match(fugue_sqlParser.PRESORT)
                self.state = 600
                localctx.presort = self.fugueColsSort()


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


    class FugueCreateTaskContext(ParserRuleContext):

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

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

        def fugueSingleOutputExtensionCommon(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSingleOutputExtensionCommonContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCreateTask

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




    def fugueCreateTask(self):

        localctx = fugue_sqlParser.FugueCreateTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_fugueCreateTask)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 603
            self.match(fugue_sqlParser.CREATE)
            self.state = 604
            localctx.params = self.fugueSingleOutputExtensionCommon()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueCreateDataTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.data = None # FugueJsonArrayContext
            self.schema = None # FugueSchemaContext

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

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

        def fugueJsonArray(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonArrayContext,0)


        def fugueSchema(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaContext,0)


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCreateDataTask

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




    def fugueCreateDataTask(self):

        localctx = fugue_sqlParser.FugueCreateDataTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_fugueCreateDataTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 606
            self.match(fugue_sqlParser.CREATE)
            self.state = 608
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.DATA:
                self.state = 607
                self.match(fugue_sqlParser.DATA)


            self.state = 610
            localctx.data = self.fugueJsonArray()
            self.state = 611
            self.match(fugue_sqlParser.SCHEMA)
            self.state = 612
            localctx.schema = self.fugueSchema()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueLoadTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.fmt = None # FugueFileFormatContext
            self.path = None # FuguePathContext
            self.params = None # FugueParamsContext
            self.columns = None # FugueLoadColumnsContext

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

        def fuguePath(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePathContext,0)


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

        def fugueFileFormat(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueFileFormatContext,0)


        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def fugueLoadColumns(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueLoadColumnsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueLoadTask

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




    def fugueLoadTask(self):

        localctx = fugue_sqlParser.FugueLoadTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_fugueLoadTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 614
            self.match(fugue_sqlParser.LOAD)
            self.state = 616
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.PARQUET) | (1 << fugue_sqlParser.CSV) | (1 << fugue_sqlParser.JSON))) != 0):
                self.state = 615
                localctx.fmt = self.fugueFileFormat()


            self.state = 618
            localctx.path = self.fuguePath()
            self.state = 620
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.state = 619
                localctx.params = self.fugueParams()


            self.state = 624
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
            if la_ == 1:
                self.state = 622
                self.match(fugue_sqlParser.COLUMNS)
                self.state = 623
                localctx.columns = self.fugueLoadColumns()


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


    class FugueOutputTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.dfs = None # FugueDataFramesContext
            self.partition = None # FuguePrepartitionContext
            self.using = None # FugueExtensionContext
            self.params = None # FugueParamsContext

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

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

        def fugueExtension(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueExtensionContext,0)


        def fugueDataFrames(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFramesContext,0)


        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)


        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueOutputTask

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




    def fugueOutputTask(self):

        localctx = fugue_sqlParser.FugueOutputTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_fugueOutputTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 626
            self.match(fugue_sqlParser.OUTPUT)
            self.state = 628
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.state = 627
                localctx.dfs = self.fugueDataFrames()


            self.state = 631
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN) | (1 << fugue_sqlParser.PREPARTITION))) != 0):
                self.state = 630
                localctx.partition = self.fuguePrepartition()


            self.state = 633
            self.match(fugue_sqlParser.USING)
            self.state = 634
            localctx.using = self.fugueExtension()
            self.state = 636
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
            if la_ == 1:
                self.state = 635
                localctx.params = self.fugueParams()


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


    class FuguePrintTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.rows = None # Token
            self.dfs = None # FugueDataFramesContext
            self.count = None # Token
            self.title = None # Token

        def PRINT(self):
            return self.getToken(fugue_sqlParser.PRINT, 0)

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

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

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

        def TITLE(self):
            return self.getToken(fugue_sqlParser.TITLE, 0)

        def fugueDataFrames(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFramesContext,0)


        def ROWCOUNT(self):
            return self.getToken(fugue_sqlParser.ROWCOUNT, 0)

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePrintTask

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




    def fuguePrintTask(self):

        localctx = fugue_sqlParser.FuguePrintTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_fuguePrintTask)
        self._la = 0 # Token type
        try:
            self.state = 663
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 638
                self.match(fugue_sqlParser.PRINT)
                self.state = 639
                localctx.rows = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 640
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.ROW or _la==fugue_sqlParser.ROWS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 643
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
                if la_ == 1:
                    self.state = 641
                    self.match(fugue_sqlParser.FROM)
                    self.state = 642
                    localctx.dfs = self.fugueDataFrames()


                self.state = 646
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
                if la_ == 1:
                    self.state = 645
                    localctx.count = self.match(fugue_sqlParser.ROWCOUNT)


                self.state = 650
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
                if la_ == 1:
                    self.state = 648
                    self.match(fugue_sqlParser.TITLE)
                    self.state = 649
                    localctx.title = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 652
                self.match(fugue_sqlParser.PRINT)
                self.state = 654
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
                if la_ == 1:
                    self.state = 653
                    localctx.dfs = self.fugueDataFrames()


                self.state = 657
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
                if la_ == 1:
                    self.state = 656
                    localctx.count = self.match(fugue_sqlParser.ROWCOUNT)


                self.state = 661
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
                if la_ == 1:
                    self.state = 659
                    self.match(fugue_sqlParser.TITLE)
                    self.state = 660
                    localctx.title = self.match(fugue_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 FugueSaveTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.df = None # FugueDataFrameContext
            self.partition = None # FuguePrepartitionContext
            self.m = None # FugueSaveModeContext
            self.single = None # FugueSingleFileContext
            self.fmt = None # FugueFileFormatContext
            self.path = None # FuguePathContext
            self.params = None # FugueParamsContext

        def SAVE(self):
            return self.getToken(fugue_sqlParser.SAVE, 0)

        def fugueSaveMode(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSaveModeContext,0)


        def fuguePath(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePathContext,0)


        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)


        def fugueSingleFile(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSingleFileContext,0)


        def fugueFileFormat(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueFileFormatContext,0)


        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSaveTask

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




    def fugueSaveTask(self):

        localctx = fugue_sqlParser.FugueSaveTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_fugueSaveTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.match(fugue_sqlParser.SAVE)
            self.state = 667
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.state = 666
                localctx.df = self.fugueDataFrame()


            self.state = 670
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN) | (1 << fugue_sqlParser.PREPARTITION))) != 0):
                self.state = 669
                localctx.partition = self.fuguePrepartition()


            self.state = 672
            localctx.m = self.fugueSaveMode()
            self.state = 674
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.SINGLE:
                self.state = 673
                localctx.single = self.fugueSingleFile()


            self.state = 677
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.PARQUET) | (1 << fugue_sqlParser.CSV) | (1 << fugue_sqlParser.JSON))) != 0):
                self.state = 676
                localctx.fmt = self.fugueFileFormat()


            self.state = 679
            localctx.path = self.fuguePath()
            self.state = 681
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.state = 680
                localctx.params = self.fugueParams()


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


    class FugueOutputTransformTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.dfs = None # FugueDataFramesContext
            self.partition = None # FuguePrepartitionContext
            self.using = None # FugueExtensionContext
            self.params = None # FugueParamsContext
            self.callback = None # FugueExtensionContext

        def OUTTRANSFORM(self):
            return self.getToken(fugue_sqlParser.OUTTRANSFORM, 0)

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

        def fugueExtension(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueExtensionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueExtensionContext,i)


        def CALLBACK(self):
            return self.getToken(fugue_sqlParser.CALLBACK, 0)

        def fugueDataFrames(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFramesContext,0)


        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)


        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueOutputTransformTask

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




    def fugueOutputTransformTask(self):

        localctx = fugue_sqlParser.FugueOutputTransformTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_fugueOutputTransformTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 683
            self.match(fugue_sqlParser.OUTTRANSFORM)
            self.state = 685
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
            if la_ == 1:
                self.state = 684
                localctx.dfs = self.fugueDataFrames()


            self.state = 688
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN) | (1 << fugue_sqlParser.PREPARTITION))) != 0):
                self.state = 687
                localctx.partition = self.fuguePrepartition()


            self.state = 690
            self.match(fugue_sqlParser.USING)
            self.state = 691
            localctx.using = self.fugueExtension()
            self.state = 693
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.state = 692
                localctx.params = self.fugueParams()


            self.state = 697
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
            if la_ == 1:
                self.state = 695
                self.match(fugue_sqlParser.CALLBACK)
                self.state = 696
                localctx.callback = self.fugueExtension()


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


    class FugueModuleTaskContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.assign = None # FugueAssignmentContext
            self.dfs = None # FugueDataFramesContext
            self.using = None # FugueExtensionContext
            self.params = None # FugueParamsContext

        def SUB(self):
            return self.getToken(fugue_sqlParser.SUB, 0)

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

        def fugueExtension(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueExtensionContext,0)


        def fugueAssignment(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueAssignmentContext,0)


        def fugueDataFrames(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFramesContext,0)


        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueModuleTask

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




    def fugueModuleTask(self):

        localctx = fugue_sqlParser.FugueModuleTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_fugueModuleTask)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 700
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.state = 699
                localctx.assign = self.fugueAssignment()


            self.state = 702
            self.match(fugue_sqlParser.SUB)
            self.state = 704
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
            if la_ == 1:
                self.state = 703
                localctx.dfs = self.fugueDataFrames()


            self.state = 706
            self.match(fugue_sqlParser.USING)
            self.state = 707
            localctx.using = self.fugueExtension()
            self.state = 709
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                self.state = 708
                localctx.params = self.fugueParams()


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


    class FugueSqlEngineContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.using = None # FugueExtensionContext
            self.params = None # FugueParamsContext

        def CONNECT(self):
            return self.getToken(fugue_sqlParser.CONNECT, 0)

        def fugueExtension(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueExtensionContext,0)


        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSqlEngine

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




    def fugueSqlEngine(self):

        localctx = fugue_sqlParser.FugueSqlEngineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_fugueSqlEngine)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 711
            self.match(fugue_sqlParser.CONNECT)
            self.state = 712
            localctx.using = self.fugueExtension()
            self.state = 714
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.T__2) | (1 << fugue_sqlParser.T__7) | (1 << fugue_sqlParser.PARAMS))) != 0):
                self.state = 713
                localctx.params = self.fugueParams()


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


    class FugueSingleFileContext(ParserRuleContext):

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

        def SINGLE(self):
            return self.getToken(fugue_sqlParser.SINGLE, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleFile

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




    def fugueSingleFile(self):

        localctx = fugue_sqlParser.FugueSingleFileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_fugueSingleFile)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 716
            localctx.single = self.match(fugue_sqlParser.SINGLE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueLoadColumnsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.schema = None # FugueSchemaContext
            self.cols = None # FugueColsContext

        def fugueSchema(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaContext,0)


        def fugueCols(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueLoadColumns

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




    def fugueLoadColumns(self):

        localctx = fugue_sqlParser.FugueLoadColumnsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_fugueLoadColumns)
        try:
            self.state = 720
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 718
                localctx.schema = self.fugueSchema()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 719
                localctx.cols = self.fugueCols()
                pass


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


    class FugueSaveModeContext(ParserRuleContext):

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

        def TO(self):
            return self.getToken(fugue_sqlParser.TO, 0)

        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)

        def APPEND(self):
            return self.getToken(fugue_sqlParser.APPEND, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSaveMode

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




    def fugueSaveMode(self):

        localctx = fugue_sqlParser.FugueSaveModeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_fugueSaveMode)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 722
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.APPEND or _la==fugue_sqlParser.OVERWRITE or _la==fugue_sqlParser.TO):
                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 FugueFileFormatContext(ParserRuleContext):

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

        def PARQUET(self):
            return self.getToken(fugue_sqlParser.PARQUET, 0)

        def CSV(self):
            return self.getToken(fugue_sqlParser.CSV, 0)

        def JSON(self):
            return self.getToken(fugue_sqlParser.JSON, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueFileFormat

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




    def fugueFileFormat(self):

        localctx = fugue_sqlParser.FugueFileFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_fugueFileFormat)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 724
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.PARQUET) | (1 << fugue_sqlParser.CSV) | (1 << fugue_sqlParser.JSON))) != 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 FuguePathContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePath

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




    def fuguePath(self):

        localctx = fugue_sqlParser.FuguePathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_fuguePath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 726
            self.match(fugue_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 FugueCheckpointContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCheckpoint

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



    class FugueCheckpointDeterministicContext(FugueCheckpointContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.FugueCheckpointContext
            super().__init__(parser)
            self.ns = None # FugueCheckpointNamespaceContext
            self.partition = None # FuguePrepartitionContext
            self.single = None # FugueSingleFileContext
            self.params = None # FugueParamsContext
            self.copyFrom(ctx)

        def DETERMINISTIC(self):
            return self.getToken(fugue_sqlParser.DETERMINISTIC, 0)
        def CHECKPOINT(self):
            return self.getToken(fugue_sqlParser.CHECKPOINT, 0)
        def LAZY(self):
            return self.getToken(fugue_sqlParser.LAZY, 0)
        def fugueCheckpointNamespace(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueCheckpointNamespaceContext,0)

        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)

        def fugueSingleFile(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSingleFileContext,0)

        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


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


    class FugueCheckpointWeakContext(FugueCheckpointContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.FugueCheckpointContext
            super().__init__(parser)
            self.params = None # FugueParamsContext
            self.copyFrom(ctx)

        def PERSIST(self):
            return self.getToken(fugue_sqlParser.PERSIST, 0)
        def WEAK(self):
            return self.getToken(fugue_sqlParser.WEAK, 0)
        def CHECKPOINT(self):
            return self.getToken(fugue_sqlParser.CHECKPOINT, 0)
        def LAZY(self):
            return self.getToken(fugue_sqlParser.LAZY, 0)
        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


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


    class FugueCheckpointStrongContext(FugueCheckpointContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.FugueCheckpointContext
            super().__init__(parser)
            self.partition = None # FuguePrepartitionContext
            self.single = None # FugueSingleFileContext
            self.params = None # FugueParamsContext
            self.copyFrom(ctx)

        def CHECKPOINT(self):
            return self.getToken(fugue_sqlParser.CHECKPOINT, 0)
        def LAZY(self):
            return self.getToken(fugue_sqlParser.LAZY, 0)
        def STRONG(self):
            return self.getToken(fugue_sqlParser.STRONG, 0)
        def fuguePrepartition(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePrepartitionContext,0)

        def fugueSingleFile(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSingleFileContext,0)

        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


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



    def fugueCheckpoint(self):

        localctx = fugue_sqlParser.FugueCheckpointContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_fugueCheckpoint)
        self._la = 0 # Token type
        try:
            self.state = 772
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.FugueCheckpointWeakContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 729
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LAZY:
                    self.state = 728
                    self.match(fugue_sqlParser.LAZY)


                self.state = 734
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [fugue_sqlParser.PERSIST]:
                    self.state = 731
                    self.match(fugue_sqlParser.PERSIST)
                    pass
                elif token in [fugue_sqlParser.WEAK]:
                    self.state = 732
                    self.match(fugue_sqlParser.WEAK)
                    self.state = 733
                    self.match(fugue_sqlParser.CHECKPOINT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 737
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
                if la_ == 1:
                    self.state = 736
                    localctx.params = self.fugueParams()


                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.FugueCheckpointStrongContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 740
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LAZY:
                    self.state = 739
                    self.match(fugue_sqlParser.LAZY)


                self.state = 743
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.STRONG:
                    self.state = 742
                    self.match(fugue_sqlParser.STRONG)


                self.state = 745
                self.match(fugue_sqlParser.CHECKPOINT)
                self.state = 747
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
                if la_ == 1:
                    self.state = 746
                    localctx.partition = self.fuguePrepartition()


                self.state = 750
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                if la_ == 1:
                    self.state = 749
                    localctx.single = self.fugueSingleFile()


                self.state = 753
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
                if la_ == 1:
                    self.state = 752
                    localctx.params = self.fugueParams()


                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.FugueCheckpointDeterministicContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 756
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LAZY:
                    self.state = 755
                    self.match(fugue_sqlParser.LAZY)


                self.state = 758
                self.match(fugue_sqlParser.DETERMINISTIC)
                self.state = 759
                self.match(fugue_sqlParser.CHECKPOINT)
                self.state = 761
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
                if la_ == 1:
                    self.state = 760
                    localctx.ns = self.fugueCheckpointNamespace()


                self.state = 764
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
                if la_ == 1:
                    self.state = 763
                    localctx.partition = self.fuguePrepartition()


                self.state = 767
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
                if la_ == 1:
                    self.state = 766
                    localctx.single = self.fugueSingleFile()


                self.state = 770
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
                if la_ == 1:
                    self.state = 769
                    localctx.params = self.fugueParams()


                pass


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


    class FugueCheckpointNamespaceContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCheckpointNamespace

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




    def fugueCheckpointNamespace(self):

        localctx = fugue_sqlParser.FugueCheckpointNamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_fugueCheckpointNamespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 774
            self.match(fugue_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 FugueYieldContext(ParserRuleContext):

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

        def YIELD(self):
            return self.getToken(fugue_sqlParser.YIELD, 0)

        def DATAFRAME(self):
            return self.getToken(fugue_sqlParser.DATAFRAME, 0)

        def FILE(self):
            return self.getToken(fugue_sqlParser.FILE, 0)

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

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueYield

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




    def fugueYield(self):

        localctx = fugue_sqlParser.FugueYieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_fugueYield)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 776
            self.match(fugue_sqlParser.YIELD)
            self.state = 777
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.DATAFRAME or _la==fugue_sqlParser.FILE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 780
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 778
                self.match(fugue_sqlParser.AS)
                self.state = 779
                localctx.name = self.fugueIdentifier()


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


    class FugueBroadcastContext(ParserRuleContext):

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

        def BROADCAST(self):
            return self.getToken(fugue_sqlParser.BROADCAST, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueBroadcast

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




    def fugueBroadcast(self):

        localctx = fugue_sqlParser.FugueBroadcastContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_fugueBroadcast)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 782
            self.match(fugue_sqlParser.BROADCAST)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueDataFramesContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDataFrames

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



    class FugueDataFramesDictContext(FugueDataFramesContext):

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

        def fugueDataFramePair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueDataFramePairContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueDataFramePairContext,i)


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


    class FugueDataFramesListContext(FugueDataFramesContext):

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

        def fugueDataFrame(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueDataFrameContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,i)


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



    def fugueDataFrames(self):

        localctx = fugue_sqlParser.FugueDataFramesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_fugueDataFrames)
        try:
            self.state = 800
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.FugueDataFramesListContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 784
                self.fugueDataFrame()
                self.state = 789
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,77,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 785
                        self.match(fugue_sqlParser.T__0)
                        self.state = 786
                        self.fugueDataFrame() 
                    self.state = 791
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,77,self._ctx)

                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.FugueDataFramesDictContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 792
                self.fugueDataFramePair()
                self.state = 797
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 793
                        self.match(fugue_sqlParser.T__0)
                        self.state = 794
                        self.fugueDataFramePair() 
                    self.state = 799
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,78,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 FugueDataFramePairContext(ParserRuleContext):

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

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)


        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def fugueDataFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDataFramePair

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




    def fugueDataFramePair(self):

        localctx = fugue_sqlParser.FugueDataFramePairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_fugueDataFramePair)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 802
            localctx.key = self.fugueIdentifier()
            self.state = 803
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.T__1 or _la==fugue_sqlParser.EQUAL):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 804
            localctx.value = self.fugueDataFrame()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueDataFrameContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDataFrame

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



    class FugueDataFrameSourceContext(FugueDataFrameContext):

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

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)

        def fugueDataFrameMember(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameMemberContext,0)


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


    class FugueDataFrameNestedContext(FugueDataFrameContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.FugueDataFrameContext
            super().__init__(parser)
            self.task = None # FugueNestableTaskContext
            self.copyFrom(ctx)

        def fugueNestableTask(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueNestableTaskContext,0)


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



    def fugueDataFrame(self):

        localctx = fugue_sqlParser.FugueDataFrameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_fugueDataFrame)
        try:
            self.state = 814
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.FugueDataFrameSourceContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 806
                self.fugueIdentifier()
                self.state = 808
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
                if la_ == 1:
                    self.state = 807
                    self.fugueDataFrameMember()


                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.FugueDataFrameNestedContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 810
                self.match(fugue_sqlParser.T__2)
                self.state = 811
                localctx.task = self.fugueNestableTask()
                self.state = 812
                self.match(fugue_sqlParser.T__3)
                pass


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


    class FugueDataFrameMemberContext(ParserRuleContext):

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

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

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDataFrameMember

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




    def fugueDataFrameMember(self):

        localctx = fugue_sqlParser.FugueDataFrameMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_fugueDataFrameMember)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 816
            self.match(fugue_sqlParser.T__4)
            self.state = 819
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.state = 817
                localctx.index = self.match(fugue_sqlParser.INTEGER_VALUE)
                pass

            elif la_ == 2:
                self.state = 818
                localctx.key = self.fugueIdentifier()
                pass


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


    class FugueAssignmentContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.varname = None # FugueIdentifierContext
            self.sign = None # FugueAssignmentSignContext

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)


        def fugueAssignmentSign(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueAssignmentSignContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueAssignment

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




    def fugueAssignment(self):

        localctx = fugue_sqlParser.FugueAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_fugueAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 823
            localctx.varname = self.fugueIdentifier()
            self.state = 824
            localctx.sign = self.fugueAssignmentSign()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueAssignmentSignContext(ParserRuleContext):

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

        def COLONEQUAL(self):
            return self.getToken(fugue_sqlParser.COLONEQUAL, 0)

        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueAssignmentSign

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




    def fugueAssignmentSign(self):

        localctx = fugue_sqlParser.FugueAssignmentSignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_fugueAssignmentSign)
        try:
            self.state = 829
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 826
                self.match(fugue_sqlParser.COLONEQUAL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 827
                if not self.simpleAssign:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.simpleAssign")
                self.state = 828
                self.match(fugue_sqlParser.EQUAL)
                pass


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


    class FugueSingleOutputExtensionCommonWildContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.using = None # FugueExtensionContext
            self.params = None # FugueParamsContext
            self.schema = None # FugueWildSchemaContext

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

        def fugueExtension(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueExtensionContext,0)


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

        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def fugueWildSchema(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueWildSchemaContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleOutputExtensionCommonWild

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




    def fugueSingleOutputExtensionCommonWild(self):

        localctx = fugue_sqlParser.FugueSingleOutputExtensionCommonWildContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_fugueSingleOutputExtensionCommonWild)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 831
            self.match(fugue_sqlParser.USING)
            self.state = 832
            localctx.using = self.fugueExtension()
            self.state = 834
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.state = 833
                localctx.params = self.fugueParams()


            self.state = 838
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.state = 836
                self.match(fugue_sqlParser.SCHEMA)
                self.state = 837
                localctx.schema = self.fugueWildSchema()


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


    class FugueSingleOutputExtensionCommonContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.using = None # FugueExtensionContext
            self.params = None # FugueParamsContext
            self.schema = None # FugueSchemaContext

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

        def fugueExtension(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueExtensionContext,0)


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

        def fugueParams(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueParamsContext,0)


        def fugueSchema(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleOutputExtensionCommon

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




    def fugueSingleOutputExtensionCommon(self):

        localctx = fugue_sqlParser.FugueSingleOutputExtensionCommonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_fugueSingleOutputExtensionCommon)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 840
            self.match(fugue_sqlParser.USING)
            self.state = 841
            localctx.using = self.fugueExtension()
            self.state = 843
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
            if la_ == 1:
                self.state = 842
                localctx.params = self.fugueParams()


            self.state = 847
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 845
                self.match(fugue_sqlParser.SCHEMA)
                self.state = 846
                localctx.schema = self.fugueSchema()


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


    class FugueExtensionContext(ParserRuleContext):

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

        def fugueIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueExtension

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




    def fugueExtension(self):

        localctx = fugue_sqlParser.FugueExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_fugueExtension)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 849
            self.fugueIdentifier()
            self.state = 854
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,88,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 850
                    self.match(fugue_sqlParser.T__6)
                    self.state = 851
                    self.fugueIdentifier() 
                self.state = 856
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,88,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 FugueSampleMethodContext(ParserRuleContext):

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

        def PERCENTLIT(self):
            return self.getToken(fugue_sqlParser.PERCENTLIT, 0)

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

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

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSampleMethod

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




    def fugueSampleMethod(self):

        localctx = fugue_sqlParser.FugueSampleMethodContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_fugueSampleMethod)
        self._la = 0 # Token type
        try:
            self.state = 861
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 857
                localctx.percentage = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.INTEGER_VALUE or _la==fugue_sqlParser.DECIMAL_VALUE):
                    localctx.percentage = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 858
                self.match(fugue_sqlParser.PERCENTLIT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 859
                localctx.rows = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 860
                self.match(fugue_sqlParser.ROWS)
                pass


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


    class FugueZipTypeContext(ParserRuleContext):

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

        def CROSS(self):
            return self.getToken(fugue_sqlParser.CROSS, 0)

        def INNER(self):
            return self.getToken(fugue_sqlParser.INNER, 0)

        def LEFT(self):
            return self.getToken(fugue_sqlParser.LEFT, 0)

        def OUTER(self):
            return self.getToken(fugue_sqlParser.OUTER, 0)

        def RIGHT(self):
            return self.getToken(fugue_sqlParser.RIGHT, 0)

        def FULL(self):
            return self.getToken(fugue_sqlParser.FULL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueZipType

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




    def fugueZipType(self):

        localctx = fugue_sqlParser.FugueZipTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_fugueZipType)
        try:
            self.state = 871
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.CROSS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 863
                self.match(fugue_sqlParser.CROSS)
                pass
            elif token in [fugue_sqlParser.INNER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 864
                self.match(fugue_sqlParser.INNER)
                pass
            elif token in [fugue_sqlParser.LEFT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 865
                self.match(fugue_sqlParser.LEFT)
                self.state = 866
                self.match(fugue_sqlParser.OUTER)
                pass
            elif token in [fugue_sqlParser.RIGHT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 867
                self.match(fugue_sqlParser.RIGHT)
                self.state = 868
                self.match(fugue_sqlParser.OUTER)
                pass
            elif token in [fugue_sqlParser.FULL]:
                self.enterOuterAlt(localctx, 5)
                self.state = 869
                self.match(fugue_sqlParser.FULL)
                self.state = 870
                self.match(fugue_sqlParser.OUTER)
                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 FuguePrepartitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.algo = None # FuguePartitionAlgoContext
            self.num = None # FuguePartitionNumContext
            self.by = None # FugueColsContext
            self.presort = None # FugueColsSortContext

        def PREPARTITION(self):
            return self.getToken(fugue_sqlParser.PREPARTITION, 0)

        def fuguePartitionNum(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePartitionNumContext,0)


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

        def PRESORT(self):
            return self.getToken(fugue_sqlParser.PRESORT, 0)

        def fuguePartitionAlgo(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePartitionAlgoContext,0)


        def fugueCols(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColsContext,0)


        def fugueColsSort(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColsSortContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePrepartition

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




    def fuguePrepartition(self):

        localctx = fugue_sqlParser.FuguePrepartitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_fuguePrepartition)
        self._la = 0 # Token type
        try:
            self.state = 896
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 874
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN))) != 0):
                    self.state = 873
                    localctx.algo = self.fuguePartitionAlgo()


                self.state = 876
                self.match(fugue_sqlParser.PREPARTITION)
                self.state = 877
                localctx.num = self.fuguePartitionNum(0)
                self.state = 880
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
                if la_ == 1:
                    self.state = 878
                    self.match(fugue_sqlParser.BY)
                    self.state = 879
                    localctx.by = self.fugueCols()


                self.state = 884
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
                if la_ == 1:
                    self.state = 882
                    self.match(fugue_sqlParser.PRESORT)
                    self.state = 883
                    localctx.presort = self.fugueColsSort()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 887
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN))) != 0):
                    self.state = 886
                    localctx.algo = self.fuguePartitionAlgo()


                self.state = 889
                self.match(fugue_sqlParser.PREPARTITION)
                self.state = 890
                self.match(fugue_sqlParser.BY)
                self.state = 891
                localctx.by = self.fugueCols()
                self.state = 894
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,95,self._ctx)
                if la_ == 1:
                    self.state = 892
                    self.match(fugue_sqlParser.PRESORT)
                    self.state = 893
                    localctx.presort = self.fugueColsSort()


                pass


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


    class FuguePartitionAlgoContext(ParserRuleContext):

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

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

        def RAND(self):
            return self.getToken(fugue_sqlParser.RAND, 0)

        def EVEN(self):
            return self.getToken(fugue_sqlParser.EVEN, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePartitionAlgo

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




    def fuguePartitionAlgo(self):

        localctx = fugue_sqlParser.FuguePartitionAlgoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_fuguePartitionAlgo)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 898
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.HASH) | (1 << fugue_sqlParser.RAND) | (1 << fugue_sqlParser.EVEN))) != 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 FuguePartitionNumContext(ParserRuleContext):

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

        def fuguePartitionNumber(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePartitionNumberContext,0)


        def fuguePartitionNum(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FuguePartitionNumContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FuguePartitionNumContext,i)


        def PLUS(self):
            return self.getToken(fugue_sqlParser.PLUS, 0)

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

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)

        def SLASH(self):
            return self.getToken(fugue_sqlParser.SLASH, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePartitionNum

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



    def fuguePartitionNum(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = fugue_sqlParser.FuguePartitionNumContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 94
        self.enterRecursionRule(localctx, 94, self.RULE_fuguePartitionNum, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 906
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.ROWCOUNT, fugue_sqlParser.CONCURRENCY, fugue_sqlParser.MINUS, fugue_sqlParser.INTEGER_VALUE, fugue_sqlParser.DECIMAL_VALUE]:
                self.state = 901
                self.fuguePartitionNumber()
                pass
            elif token in [fugue_sqlParser.T__2]:
                self.state = 902
                self.match(fugue_sqlParser.T__2)
                self.state = 903
                self.fuguePartitionNum(0)
                self.state = 904
                self.match(fugue_sqlParser.T__3)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 913
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,98,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = fugue_sqlParser.FuguePartitionNumContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_fuguePartitionNum)
                    self.state = 908
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 909
                    _la = self._input.LA(1)
                    if not(((((_la - 315)) & ~0x3f) == 0 and ((1 << (_la - 315)) & ((1 << (fugue_sqlParser.PLUS - 315)) | (1 << (fugue_sqlParser.MINUS - 315)) | (1 << (fugue_sqlParser.ASTERISK - 315)) | (1 << (fugue_sqlParser.SLASH - 315)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 910
                    self.fuguePartitionNum(2) 
                self.state = 915
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,98,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 FuguePartitionNumberContext(ParserRuleContext):

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

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

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

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

        def ROWCOUNT(self):
            return self.getToken(fugue_sqlParser.ROWCOUNT, 0)

        def CONCURRENCY(self):
            return self.getToken(fugue_sqlParser.CONCURRENCY, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePartitionNumber

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




    def fuguePartitionNumber(self):

        localctx = fugue_sqlParser.FuguePartitionNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_fuguePartitionNumber)
        self._la = 0 # Token type
        try:
            self.state = 926
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 917
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 916
                    self.match(fugue_sqlParser.MINUS)


                self.state = 919
                self.match(fugue_sqlParser.DECIMAL_VALUE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 921
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 920
                    self.match(fugue_sqlParser.MINUS)


                self.state = 923
                self.match(fugue_sqlParser.INTEGER_VALUE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 924
                self.match(fugue_sqlParser.ROWCOUNT)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 925
                self.match(fugue_sqlParser.CONCURRENCY)
                pass


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


    class FugueParamsContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueParams

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



    class FugueParamsPairsContext(FugueParamsContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.FugueParamsContext
            super().__init__(parser)
            self.pairs = None # FugueJsonPairsContext
            self.copyFrom(ctx)

        def PARAMS(self):
            return self.getToken(fugue_sqlParser.PARAMS, 0)
        def fugueJsonPairs(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonPairsContext,0)


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


    class FugueParamsObjContext(FugueParamsContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.FugueParamsContext
            super().__init__(parser)
            self.obj = None # FugueJsonObjContext
            self.copyFrom(ctx)

        def fugueJsonObj(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonObjContext,0)

        def PARAMS(self):
            return self.getToken(fugue_sqlParser.PARAMS, 0)

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



    def fugueParams(self):

        localctx = fugue_sqlParser.FugueParamsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_fugueParams)
        self._la = 0 # Token type
        try:
            self.state = 934
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,103,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.FugueParamsPairsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 928
                self.match(fugue_sqlParser.PARAMS)
                self.state = 929
                localctx.pairs = self.fugueJsonPairs()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.FugueParamsObjContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 931
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARAMS:
                    self.state = 930
                    self.match(fugue_sqlParser.PARAMS)


                self.state = 933
                localctx.obj = self.fugueJsonObj()
                pass


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


    class FugueColsContext(ParserRuleContext):

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

        def fugueColumnIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueColumnIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueColumnIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCols

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




    def fugueCols(self):

        localctx = fugue_sqlParser.FugueColsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_fugueCols)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 936
            self.fugueColumnIdentifier()
            self.state = 941
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,104,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 937
                    self.match(fugue_sqlParser.T__0)
                    self.state = 938
                    self.fugueColumnIdentifier() 
                self.state = 943
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,104,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 FugueColsSortContext(ParserRuleContext):

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

        def fugueColSort(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueColSortContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueColSortContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueColsSort

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




    def fugueColsSort(self):

        localctx = fugue_sqlParser.FugueColsSortContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_fugueColsSort)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 944
            self.fugueColSort()
            self.state = 949
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,105,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 945
                    self.match(fugue_sqlParser.T__0)
                    self.state = 946
                    self.fugueColSort() 
                self.state = 951
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,105,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 FugueColSortContext(ParserRuleContext):

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

        def fugueColumnIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueColumnIdentifierContext,0)


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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueColSort

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




    def fugueColSort(self):

        localctx = fugue_sqlParser.FugueColSortContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_fugueColSort)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 952
            self.fugueColumnIdentifier()
            self.state = 954
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.state = 953
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.ASC or _la==fugue_sqlParser.DESC):
                    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 FugueColumnIdentifierContext(ParserRuleContext):

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

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueColumnIdentifier

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




    def fugueColumnIdentifier(self):

        localctx = fugue_sqlParser.FugueColumnIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_fugueColumnIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 956
            self.fugueIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueRenameExpressionContext(ParserRuleContext):

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

        def fugueRenamePair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueRenamePairContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueRenamePairContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueRenameExpression

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




    def fugueRenameExpression(self):

        localctx = fugue_sqlParser.FugueRenameExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_fugueRenameExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 958
            self.fugueRenamePair()
            self.state = 963
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,107,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 959
                    self.match(fugue_sqlParser.T__0)
                    self.state = 960
                    self.fugueRenamePair() 
                self.state = 965
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,107,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 FugueWildSchemaContext(ParserRuleContext):

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

        def fugueWildSchemaPair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueWildSchemaPairContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueWildSchemaPairContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueWildSchema

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




    def fugueWildSchema(self):

        localctx = fugue_sqlParser.FugueWildSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_fugueWildSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 966
            self.fugueWildSchemaPair()
            self.state = 971
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,108,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 967
                    self.match(fugue_sqlParser.T__0)
                    self.state = 968
                    self.fugueWildSchemaPair() 
                self.state = 973
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,108,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 FugueWildSchemaPairContext(ParserRuleContext):

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

        def fugueSchemaPair(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaPairContext,0)


        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueWildSchemaPair

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




    def fugueWildSchemaPair(self):

        localctx = fugue_sqlParser.FugueWildSchemaPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_fugueWildSchemaPair)
        try:
            self.state = 976
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 974
                localctx.pair = self.fugueSchemaPair()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 975
                self.match(fugue_sqlParser.ASTERISK)
                pass


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


    class FugueSchemaContext(ParserRuleContext):

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

        def fugueSchemaPair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueSchemaPairContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaPairContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchema

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




    def fugueSchema(self):

        localctx = fugue_sqlParser.FugueSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_fugueSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 978
            self.fugueSchemaPair()
            self.state = 983
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,110,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 979
                    self.match(fugue_sqlParser.T__0)
                    self.state = 980
                    self.fugueSchemaPair() 
                self.state = 985
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,110,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 FugueSchemaPairContext(ParserRuleContext):

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

        def fugueSchemaKey(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaKeyContext,0)


        def fugueSchemaType(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaTypeContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchemaPair

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




    def fugueSchemaPair(self):

        localctx = fugue_sqlParser.FugueSchemaPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_fugueSchemaPair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 986
            localctx.key = self.fugueSchemaKey()
            self.state = 987
            self.match(fugue_sqlParser.T__1)
            self.state = 988
            localctx.value = self.fugueSchemaType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueSchemaKeyContext(ParserRuleContext):

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

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchemaKey

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




    def fugueSchemaKey(self):

        localctx = fugue_sqlParser.FugueSchemaKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_fugueSchemaKey)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 990
            self.fugueIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueSchemaTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchemaType

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



    class FugueSchemaSimpleTypeContext(FugueSchemaTypeContext):

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

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)


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


    class FugueSchemaStructTypeContext(FugueSchemaTypeContext):

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

        def fugueSchema(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaContext,0)


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


    class FugueSchemaListTypeContext(FugueSchemaTypeContext):

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

        def fugueSchemaType(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaTypeContext,0)


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



    def fugueSchemaType(self):

        localctx = fugue_sqlParser.FugueSchemaTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_fugueSchemaType)
        try:
            self.state = 1001
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.FugueSchemaSimpleTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 992
                self.fugueIdentifier()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.FugueSchemaListTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 993
                self.match(fugue_sqlParser.T__4)
                self.state = 994
                self.fugueSchemaType()
                self.state = 995
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.FugueSchemaStructTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 997
                self.match(fugue_sqlParser.T__7)
                self.state = 998
                self.fugueSchema()
                self.state = 999
                self.match(fugue_sqlParser.T__8)
                pass


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


    class FugueRenamePairContext(ParserRuleContext):

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

        def fugueSchemaKey(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueSchemaKeyContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaKeyContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueRenamePair

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




    def fugueRenamePair(self):

        localctx = fugue_sqlParser.FugueRenamePairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_fugueRenamePair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1003
            localctx.key = self.fugueSchemaKey()
            self.state = 1004
            self.match(fugue_sqlParser.T__1)
            self.state = 1005
            localctx.value = self.fugueSchemaKey()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueJsonContext(ParserRuleContext):

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

        def fugueJsonValue(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonValueContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJson

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




    def fugueJson(self):

        localctx = fugue_sqlParser.FugueJsonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_fugueJson)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1007
            self.fugueJsonValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueJsonObjContext(ParserRuleContext):

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

        def fugueJsonPairs(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonPairsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonObj

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




    def fugueJsonObj(self):

        localctx = fugue_sqlParser.FugueJsonObjContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_fugueJsonObj)
        self._la = 0 # Token type
        try:
            self.state = 1027
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1009
                self.match(fugue_sqlParser.T__7)
                self.state = 1010
                self.fugueJsonPairs()
                self.state = 1012
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__0:
                    self.state = 1011
                    self.match(fugue_sqlParser.T__0)


                self.state = 1014
                self.match(fugue_sqlParser.T__8)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1016
                self.match(fugue_sqlParser.T__7)
                self.state = 1017
                self.match(fugue_sqlParser.T__8)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1018
                self.match(fugue_sqlParser.T__2)
                self.state = 1019
                self.fugueJsonPairs()
                self.state = 1021
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__0:
                    self.state = 1020
                    self.match(fugue_sqlParser.T__0)


                self.state = 1023
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1025
                self.match(fugue_sqlParser.T__2)
                self.state = 1026
                self.match(fugue_sqlParser.T__3)
                pass


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


    class FugueJsonPairsContext(ParserRuleContext):

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

        def fugueJsonPair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueJsonPairContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueJsonPairContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonPairs

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




    def fugueJsonPairs(self):

        localctx = fugue_sqlParser.FugueJsonPairsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_fugueJsonPairs)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1029
            self.fugueJsonPair()
            self.state = 1034
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,115,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1030
                    self.match(fugue_sqlParser.T__0)
                    self.state = 1031
                    self.fugueJsonPair() 
                self.state = 1036
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,115,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 FugueJsonPairContext(ParserRuleContext):

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

        def fugueJsonKey(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonKeyContext,0)


        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def fugueJsonValue(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonValueContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonPair

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




    def fugueJsonPair(self):

        localctx = fugue_sqlParser.FugueJsonPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_fugueJsonPair)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1037
            localctx.key = self.fugueJsonKey()
            self.state = 1038
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.T__1 or _la==fugue_sqlParser.EQUAL):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1039
            localctx.value = self.fugueJsonValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueJsonKeyContext(ParserRuleContext):

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

        def fugueIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueIdentifierContext,0)


        def fugueJsonString(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonStringContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonKey

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




    def fugueJsonKey(self):

        localctx = fugue_sqlParser.FugueJsonKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_fugueJsonKey)
        try:
            self.state = 1043
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1041
                self.fugueIdentifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1042
                self.fugueJsonString()
                pass


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


    class FugueJsonArrayContext(ParserRuleContext):

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

        def fugueJsonValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueJsonValueContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueJsonValueContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonArray

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




    def fugueJsonArray(self):

        localctx = fugue_sqlParser.FugueJsonArrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_fugueJsonArray)
        self._la = 0 # Token type
        try:
            self.state = 1061
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1045
                self.match(fugue_sqlParser.T__4)
                self.state = 1046
                self.fugueJsonValue()
                self.state = 1051
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,117,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1047
                        self.match(fugue_sqlParser.T__0)
                        self.state = 1048
                        self.fugueJsonValue() 
                    self.state = 1053
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,117,self._ctx)

                self.state = 1055
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__0:
                    self.state = 1054
                    self.match(fugue_sqlParser.T__0)


                self.state = 1057
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1059
                self.match(fugue_sqlParser.T__4)
                self.state = 1060
                self.match(fugue_sqlParser.T__5)
                pass


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


    class FugueJsonValueContext(ParserRuleContext):

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

        def fugueJsonString(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonStringContext,0)


        def fugueJsonNumber(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonNumberContext,0)


        def fugueJsonObj(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonObjContext,0)


        def fugueJsonArray(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonArrayContext,0)


        def fugueJsonBool(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonBoolContext,0)


        def fugueJsonNull(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueJsonNullContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonValue

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




    def fugueJsonValue(self):

        localctx = fugue_sqlParser.FugueJsonValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_fugueJsonValue)
        try:
            self.state = 1069
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,120,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1063
                self.fugueJsonString()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1064
                self.fugueJsonNumber()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1065
                self.fugueJsonObj()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1066
                self.fugueJsonArray()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1067
                self.fugueJsonBool()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1068
                self.fugueJsonNull()
                pass


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


    class FugueJsonNumberContext(ParserRuleContext):

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

        def number(self):
            return self.getTypedRuleContext(fugue_sqlParser.NumberContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonNumber

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




    def fugueJsonNumber(self):

        localctx = fugue_sqlParser.FugueJsonNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_fugueJsonNumber)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1071
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueJsonStringContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonString

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




    def fugueJsonString(self):

        localctx = fugue_sqlParser.FugueJsonStringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_fugueJsonString)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1073
            self.match(fugue_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 FugueJsonBoolContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonBool

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




    def fugueJsonBool(self):

        localctx = fugue_sqlParser.FugueJsonBoolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_fugueJsonBool)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1075
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.T__9 or _la==fugue_sqlParser.T__10 or _la==fugue_sqlParser.FALSE or _la==fugue_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 FugueJsonNullContext(ParserRuleContext):

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

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonNull

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




    def fugueJsonNull(self):

        localctx = fugue_sqlParser.FugueJsonNullContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_fugueJsonNull)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1077
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.T__11 or _la==fugue_sqlParser.NULL):
                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 FugueIdentifierContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueIdentifier

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




    def fugueIdentifier(self):

        localctx = fugue_sqlParser.FugueIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_fugueIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1079
            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 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(fugue_sqlParser.StatementContext,0)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SingleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_singleStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1081
            self.statement()
            self.state = 1085
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__12:
                self.state = 1082
                self.match(fugue_sqlParser.T__12)
                self.state = 1087
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1088
            self.match(fugue_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(fugue_sqlParser.NamedExpressionContext,0)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SingleExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_singleExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1090
            self.namedExpression()
            self.state = 1091
            self.match(fugue_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(fugue_sqlParser.TableIdentifierContext,0)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SingleTableIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_singleTableIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1093
            self.tableIdentifier()
            self.state = 1094
            self.match(fugue_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(fugue_sqlParser.MultipartIdentifierContext,0)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SingleMultipartIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_singleMultipartIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1096
            self.multipartIdentifier()
            self.state = 1097
            self.match(fugue_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(fugue_sqlParser.FunctionIdentifierContext,0)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SingleFunctionIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_singleFunctionIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1099
            self.functionIdentifier()
            self.state = 1100
            self.match(fugue_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(fugue_sqlParser.DataTypeContext,0)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SingleDataTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_singleDataType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1102
            self.dataType()
            self.state = 1103
            self.match(fugue_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(fugue_sqlParser.ColTypeListContext,0)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SingleTableSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_singleTableSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1105
            self.colTypeList()
            self.state = 1106
            self.match(fugue_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 fugue_sqlParser.RULE_statement

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



    class ExplainContext(StatementContext):

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

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

        def LOGICAL(self):
            return self.getToken(fugue_sqlParser.LOGICAL, 0)
        def FORMATTED(self):
            return self.getToken(fugue_sqlParser.FORMATTED, 0)
        def EXTENDED(self):
            return self.getToken(fugue_sqlParser.EXTENDED, 0)
        def CODEGEN(self):
            return self.getToken(fugue_sqlParser.CODEGEN, 0)
        def COST(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def RESET(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def AS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def NAMESPACE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def RESTRICT(self):
            return self.getToken(fugue_sqlParser.RESTRICT, 0)
        def CASCADE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

        def OPTIONS(self):
            return self.getToken(fugue_sqlParser.OPTIONS, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.ifrom = None # MultipartIdentifierContext
            self.to = None # MultipartIdentifierContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def RENAME(self):
            return self.getToken(fugue_sqlParser.RENAME, 0)
        def TO(self):
            return self.getToken(fugue_sqlParser.TO, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)
        def ROLE(self):
            return self.getToken(fugue_sqlParser.ROLE, 0)
        def unsupportedHiveNativeCommands(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CLEAR(self):
            return self.getToken(fugue_sqlParser.CLEAR, 0)
        def CACHE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

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

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def LIKE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def RECOVER(self):
            return self.getToken(fugue_sqlParser.RECOVER, 0)
        def PARTITIONS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(fugue_sqlParser.SHOW, 0)
        def CURRENT(self):
            return self.getToken(fugue_sqlParser.CURRENT, 0)
        def NAMESPACE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.ifrom = None # PartitionSpecContext
            self.to = None # PartitionSpecContext
            self.copyFrom(ctx)

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

        def RENAME(self):
            return self.getToken(fugue_sqlParser.RENAME, 0)
        def TO(self):
            return self.getToken(fugue_sqlParser.TO, 0)
        def partitionSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.PartitionSpecContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def MSCK(self):
            return self.getToken(fugue_sqlParser.MSCK, 0)
        def REPAIR(self):
            return self.getToken(fugue_sqlParser.REPAIR, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def REFRESH(self):
            return self.getToken(fugue_sqlParser.REFRESH, 0)
        def STRING(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)
        def SERDE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

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

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def LIKE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.ns = None # MultipartIdentifierContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(fugue_sqlParser.SHOW, 0)
        def COLUMNS(self):
            return self.getToken(fugue_sqlParser.COLUMNS, 0)
        def FROM(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.FROM)
            else:
                return self.getToken(fugue_sqlParser.FROM, i)
        def IN(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.IN)
            else:
                return self.getToken(fugue_sqlParser.IN, i)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

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

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

        def AS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def ADD(self):
            return self.getToken(fugue_sqlParser.ADD, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)
        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def partitionSpecLocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.PartitionSpecLocationContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)
        def locationSpec(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def REFRESH(self):
            return self.getToken(fugue_sqlParser.REFRESH, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

        def DBPROPERTIES(self):
            return self.getToken(fugue_sqlParser.DBPROPERTIES, 0)
        def PROPERTIES(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

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

        def ADD(self):
            return self.getToken(fugue_sqlParser.ADD, 0)
        def LIST(self):
            return self.getToken(fugue_sqlParser.LIST, 0)
        def STRING(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

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

        def ALL(self):
            return self.getToken(fugue_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 fugue_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(fugue_sqlParser.CreateTableHeaderContext,0)

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

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

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

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

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

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

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

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

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

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

        def AS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.className = None # Token
            self.copyFrom(ctx)

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

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def OR(self):
            return self.getToken(fugue_sqlParser.OR, 0)
        def REPLACE(self):
            return self.getToken(fugue_sqlParser.REPLACE, 0)
        def TEMPORARY(self):
            return self.getToken(fugue_sqlParser.TEMPORARY, 0)
        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def USING(self):
            return self.getToken(fugue_sqlParser.USING, 0)
        def resource(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ResourceContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.ns = None # MultipartIdentifierContext
            self.pattern = None # Token
            self.copyFrom(ctx)

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

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.columns = None # QualifiedColTypeWithPositionListContext
            self.copyFrom(ctx)

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

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

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.comment = None # Token
            self.copyFrom(ctx)

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

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

        def IS(self):
            return self.getToken(fugue_sqlParser.IS, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def NULL(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

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

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

        def AS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def ctes(self):
            return self.getTypedRuleContext(fugue_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 fugue_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(fugue_sqlParser.CREATE, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)
        def tableIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TableIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TableIdentifierContext,i)

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

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

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

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

        def TBLPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.TBLPROPERTIES)
            else:
                return self.getToken(fugue_sqlParser.TBLPROPERTIES, i)
        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def TEMPORARY(self):
            return self.getToken(fugue_sqlParser.TEMPORARY, 0)
        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.option = None # Token
            self.copyFrom(ctx)

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

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

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

        def EXTENDED(self):
            return self.getToken(fugue_sqlParser.EXTENDED, 0)
        def FORMATTED(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.path = None # Token
            self.copyFrom(ctx)

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

        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def LOCAL(self):
            return self.getToken(fugue_sqlParser.LOCAL, 0)
        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(fugue_sqlParser.DESCRIBE, 0)
        def EXTENDED(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.ifrom = None # MultipartIdentifierContext
            self.to = None # ErrorCapturingIdentifierContext
            self.copyFrom(ctx)

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

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.colName = None # MultipartIdentifierContext
            self.copyFrom(ctx)

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

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

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

        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def colPosition(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(fugue_sqlParser.DESCRIBE, 0)
        def QUERY(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def WITH(self):
            return self.getToken(fugue_sqlParser.WITH, 0)
        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

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

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

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

        def GLOBAL(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)
        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def PURGE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SET(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def PURGE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(fugue_sqlParser.DESCRIBE, 0)
        def EXTENDED(self):
            return self.getToken(fugue_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 fugue_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(fugue_sqlParser.ALTER)
            else:
                return self.getToken(fugue_sqlParser.ALTER, i)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,i)

        def CHANGE(self):
            return self.getToken(fugue_sqlParser.CHANGE, 0)
        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def alterColumnAction(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.comment = None # Token
            self.copyFrom(ctx)

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

        def IS(self):
            return self.getToken(fugue_sqlParser.IS, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def NULL(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

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

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

        def DBPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.DBPROPERTIES)
            else:
                return self.getToken(fugue_sqlParser.DBPROPERTIES, i)
        def PROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.PROPERTIES)
            else:
                return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.key = None # TablePropertyKeyContext
            self.copyFrom(ctx)

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

        def tablePropertyKey(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)
        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.columns = None # MultipartIdentifierListContext
            self.copyFrom(ctx)

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

        def DROP(self):
            return self.getToken(fugue_sqlParser.DROP, 0)
        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def COLUMNS(self):
            return self.getToken(fugue_sqlParser.COLUMNS, 0)
        def multipartIdentifierList(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

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

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def LIKE(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

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

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

        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)
        def STRING(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.options = None # TablePropertyListContext
            self.copyFrom(ctx)

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

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

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

        def AS(self):
            return self.getToken(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.columns = None # QualifiedColTypeWithPositionListContext
            self.copyFrom(ctx)

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

        def ADD(self):
            return self.getToken(fugue_sqlParser.ADD, 0)
        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def COLUMNS(self):
            return self.getToken(fugue_sqlParser.COLUMNS, 0)
        def qualifiedColTypeWithPositionList(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(fugue_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 = fugue_sqlParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 1813
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,227,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.StatementDefaultContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1108
                self.query()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.DmlStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1110
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.WITH:
                    self.state = 1109
                    self.ctes()


                self.state = 1112
                self.dmlStatementNoWith()
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.UseContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1113
                self.match(fugue_sqlParser.USE)
                self.state = 1115
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
                if la_ == 1:
                    self.state = 1114
                    self.match(fugue_sqlParser.NAMESPACE)


                self.state = 1117
                self.multipartIdentifier()
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.CreateNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1118
                self.match(fugue_sqlParser.CREATE)
                self.state = 1119
                self.namespace()
                self.state = 1123
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
                if la_ == 1:
                    self.state = 1120
                    self.match(fugue_sqlParser.IF)
                    self.state = 1121
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1122
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1125
                self.multipartIdentifier()
                self.state = 1133
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.COMMENT or _la==fugue_sqlParser.LOCATION or _la==fugue_sqlParser.WITH:
                    self.state = 1131
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [fugue_sqlParser.COMMENT]:
                        self.state = 1126
                        self.commentSpec()
                        pass
                    elif token in [fugue_sqlParser.LOCATION]:
                        self.state = 1127
                        self.locationSpec()
                        pass
                    elif token in [fugue_sqlParser.WITH]:
                        self.state = 1128
                        self.match(fugue_sqlParser.WITH)
                        self.state = 1129
                        _la = self._input.LA(1)
                        if not(_la==fugue_sqlParser.DBPROPERTIES or _la==fugue_sqlParser.PROPERTIES):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1130
                        self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

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

                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.SetNamespacePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1136
                self.match(fugue_sqlParser.ALTER)
                self.state = 1137
                self.namespace()
                self.state = 1138
                self.multipartIdentifier()
                self.state = 1139
                self.match(fugue_sqlParser.SET)
                self.state = 1140
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.DBPROPERTIES or _la==fugue_sqlParser.PROPERTIES):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1141
                self.tablePropertyList()
                pass

            elif la_ == 6:
                localctx = fugue_sqlParser.SetNamespaceLocationContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 1143
                self.match(fugue_sqlParser.ALTER)
                self.state = 1144
                self.namespace()
                self.state = 1145
                self.multipartIdentifier()
                self.state = 1146
                self.match(fugue_sqlParser.SET)
                self.state = 1147
                self.locationSpec()
                pass

            elif la_ == 7:
                localctx = fugue_sqlParser.DropNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 1149
                self.match(fugue_sqlParser.DROP)
                self.state = 1150
                self.namespace()
                self.state = 1153
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
                if la_ == 1:
                    self.state = 1151
                    self.match(fugue_sqlParser.IF)
                    self.state = 1152
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1155
                self.multipartIdentifier()
                self.state = 1157
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.CASCADE or _la==fugue_sqlParser.RESTRICT:
                    self.state = 1156
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.CASCADE or _la==fugue_sqlParser.RESTRICT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                pass

            elif la_ == 8:
                localctx = fugue_sqlParser.ShowNamespacesContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 1159
                self.match(fugue_sqlParser.SHOW)
                self.state = 1160
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.DATABASES or _la==fugue_sqlParser.NAMESPACES):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1163
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN:
                    self.state = 1161
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1162
                    self.multipartIdentifier()


                self.state = 1169
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LIKE or _la==fugue_sqlParser.STRING:
                    self.state = 1166
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.LIKE:
                        self.state = 1165
                        self.match(fugue_sqlParser.LIKE)


                    self.state = 1168
                    localctx.pattern = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 9:
                localctx = fugue_sqlParser.CreateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 1171
                self.createTableHeader()
                self.state = 1176
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__2:
                    self.state = 1172
                    self.match(fugue_sqlParser.T__2)
                    self.state = 1173
                    self.colTypeList()
                    self.state = 1174
                    self.match(fugue_sqlParser.T__3)


                self.state = 1178
                self.tableProvider()
                self.state = 1179
                self.createTableClauses()
                self.state = 1184
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & ((1 << (fugue_sqlParser.FILL - 17)) | (1 << (fugue_sqlParser.TAKE - 17)) | (1 << (fugue_sqlParser.PROCESS - 17)) | (1 << (fugue_sqlParser.ZIP - 17)) | (1 << (fugue_sqlParser.SAVE - 17)) | (1 << (fugue_sqlParser.CONNECT - 17)) | (1 << (fugue_sqlParser.SAMPLE - 17)) | (1 << (fugue_sqlParser.ALTER - 17)) | (1 << (fugue_sqlParser.AS - 17)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (fugue_sqlParser.CREATE - 95)) | (1 << (fugue_sqlParser.DROP - 95)) | (1 << (fugue_sqlParser.FROM - 95)))) != 0) or ((((_la - 178)) & ~0x3f) == 0 and ((1 << (_la - 178)) & ((1 << (fugue_sqlParser.LOAD - 178)) | (1 << (fugue_sqlParser.MAP - 178)) | (1 << (fugue_sqlParser.REDUCE - 178)) | (1 << (fugue_sqlParser.RENAME - 178)))) != 0) or ((((_la - 248)) & ~0x3f) == 0 and ((1 << (_la - 248)) & ((1 << (fugue_sqlParser.SELECT - 248)) | (1 << (fugue_sqlParser.TABLE - 248)) | (1 << (fugue_sqlParser.TRANSFORM - 248)) | (1 << (fugue_sqlParser.VALUES - 248)) | (1 << (fugue_sqlParser.WITH - 248)))) != 0):
                    self.state = 1181
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.AS:
                        self.state = 1180
                        self.match(fugue_sqlParser.AS)


                    self.state = 1183
                    self.query()


                pass

            elif la_ == 10:
                localctx = fugue_sqlParser.CreateHiveTableContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 1186
                self.createTableHeader()
                self.state = 1191
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__2:
                    self.state = 1187
                    self.match(fugue_sqlParser.T__2)
                    self.state = 1188
                    localctx.columns = self.colTypeList()
                    self.state = 1189
                    self.match(fugue_sqlParser.T__3)


                self.state = 1214
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.CLUSTERED or _la==fugue_sqlParser.COMMENT or _la==fugue_sqlParser.LOCATION or _la==fugue_sqlParser.PARTITIONED or ((((_la - 244)) & ~0x3f) == 0 and ((1 << (_la - 244)) & ((1 << (fugue_sqlParser.ROW - 244)) | (1 << (fugue_sqlParser.SKEWED - 244)) | (1 << (fugue_sqlParser.STORED - 244)) | (1 << (fugue_sqlParser.TBLPROPERTIES - 244)))) != 0):
                    self.state = 1212
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [fugue_sqlParser.COMMENT]:
                        self.state = 1193
                        self.commentSpec()
                        pass
                    elif token in [fugue_sqlParser.PARTITIONED]:
                        self.state = 1203
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                        if la_ == 1:
                            self.state = 1194
                            self.match(fugue_sqlParser.PARTITIONED)
                            self.state = 1195
                            self.match(fugue_sqlParser.BY)
                            self.state = 1196
                            self.match(fugue_sqlParser.T__2)
                            self.state = 1197
                            localctx.partitionColumns = self.colTypeList()
                            self.state = 1198
                            self.match(fugue_sqlParser.T__3)
                            pass

                        elif la_ == 2:
                            self.state = 1200
                            self.match(fugue_sqlParser.PARTITIONED)
                            self.state = 1201
                            self.match(fugue_sqlParser.BY)
                            self.state = 1202
                            localctx.partitionColumnNames = self.identifierList()
                            pass


                        pass
                    elif token in [fugue_sqlParser.CLUSTERED]:
                        self.state = 1205
                        self.bucketSpec()
                        pass
                    elif token in [fugue_sqlParser.SKEWED]:
                        self.state = 1206
                        self.skewSpec()
                        pass
                    elif token in [fugue_sqlParser.ROW]:
                        self.state = 1207
                        self.rowFormat()
                        pass
                    elif token in [fugue_sqlParser.STORED]:
                        self.state = 1208
                        self.createFileFormat()
                        pass
                    elif token in [fugue_sqlParser.LOCATION]:
                        self.state = 1209
                        self.locationSpec()
                        pass
                    elif token in [fugue_sqlParser.TBLPROPERTIES]:
                        self.state = 1210
                        self.match(fugue_sqlParser.TBLPROPERTIES)
                        self.state = 1211
                        localctx.tableProps = self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

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

                self.state = 1221
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & ((1 << (fugue_sqlParser.FILL - 17)) | (1 << (fugue_sqlParser.TAKE - 17)) | (1 << (fugue_sqlParser.PROCESS - 17)) | (1 << (fugue_sqlParser.ZIP - 17)) | (1 << (fugue_sqlParser.SAVE - 17)) | (1 << (fugue_sqlParser.CONNECT - 17)) | (1 << (fugue_sqlParser.SAMPLE - 17)) | (1 << (fugue_sqlParser.ALTER - 17)) | (1 << (fugue_sqlParser.AS - 17)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (fugue_sqlParser.CREATE - 95)) | (1 << (fugue_sqlParser.DROP - 95)) | (1 << (fugue_sqlParser.FROM - 95)))) != 0) or ((((_la - 178)) & ~0x3f) == 0 and ((1 << (_la - 178)) & ((1 << (fugue_sqlParser.LOAD - 178)) | (1 << (fugue_sqlParser.MAP - 178)) | (1 << (fugue_sqlParser.REDUCE - 178)) | (1 << (fugue_sqlParser.RENAME - 178)))) != 0) or ((((_la - 248)) & ~0x3f) == 0 and ((1 << (_la - 248)) & ((1 << (fugue_sqlParser.SELECT - 248)) | (1 << (fugue_sqlParser.TABLE - 248)) | (1 << (fugue_sqlParser.TRANSFORM - 248)) | (1 << (fugue_sqlParser.VALUES - 248)) | (1 << (fugue_sqlParser.WITH - 248)))) != 0):
                    self.state = 1218
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.AS:
                        self.state = 1217
                        self.match(fugue_sqlParser.AS)


                    self.state = 1220
                    self.query()


                pass

            elif la_ == 11:
                localctx = fugue_sqlParser.CreateTableLikeContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 1223
                self.match(fugue_sqlParser.CREATE)
                self.state = 1224
                self.match(fugue_sqlParser.TABLE)
                self.state = 1228
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                if la_ == 1:
                    self.state = 1225
                    self.match(fugue_sqlParser.IF)
                    self.state = 1226
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1227
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1230
                localctx.target = self.tableIdentifier()
                self.state = 1231
                self.match(fugue_sqlParser.LIKE)
                self.state = 1232
                localctx.source = self.tableIdentifier()
                self.state = 1241
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.LOCATION or ((((_la - 244)) & ~0x3f) == 0 and ((1 << (_la - 244)) & ((1 << (fugue_sqlParser.ROW - 244)) | (1 << (fugue_sqlParser.STORED - 244)) | (1 << (fugue_sqlParser.TBLPROPERTIES - 244)) | (1 << (fugue_sqlParser.USING - 244)))) != 0):
                    self.state = 1239
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [fugue_sqlParser.USING]:
                        self.state = 1233
                        self.tableProvider()
                        pass
                    elif token in [fugue_sqlParser.ROW]:
                        self.state = 1234
                        self.rowFormat()
                        pass
                    elif token in [fugue_sqlParser.STORED]:
                        self.state = 1235
                        self.createFileFormat()
                        pass
                    elif token in [fugue_sqlParser.LOCATION]:
                        self.state = 1236
                        self.locationSpec()
                        pass
                    elif token in [fugue_sqlParser.TBLPROPERTIES]:
                        self.state = 1237
                        self.match(fugue_sqlParser.TBLPROPERTIES)
                        self.state = 1238
                        localctx.tableProps = self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

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

                pass

            elif la_ == 12:
                localctx = fugue_sqlParser.ReplaceTableContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 1244
                self.replaceTableHeader()
                self.state = 1249
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__2:
                    self.state = 1245
                    self.match(fugue_sqlParser.T__2)
                    self.state = 1246
                    self.colTypeList()
                    self.state = 1247
                    self.match(fugue_sqlParser.T__3)


                self.state = 1251
                self.tableProvider()
                self.state = 1252
                self.createTableClauses()
                self.state = 1257
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & ((1 << (fugue_sqlParser.FILL - 17)) | (1 << (fugue_sqlParser.TAKE - 17)) | (1 << (fugue_sqlParser.PROCESS - 17)) | (1 << (fugue_sqlParser.ZIP - 17)) | (1 << (fugue_sqlParser.SAVE - 17)) | (1 << (fugue_sqlParser.CONNECT - 17)) | (1 << (fugue_sqlParser.SAMPLE - 17)) | (1 << (fugue_sqlParser.ALTER - 17)) | (1 << (fugue_sqlParser.AS - 17)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (fugue_sqlParser.CREATE - 95)) | (1 << (fugue_sqlParser.DROP - 95)) | (1 << (fugue_sqlParser.FROM - 95)))) != 0) or ((((_la - 178)) & ~0x3f) == 0 and ((1 << (_la - 178)) & ((1 << (fugue_sqlParser.LOAD - 178)) | (1 << (fugue_sqlParser.MAP - 178)) | (1 << (fugue_sqlParser.REDUCE - 178)) | (1 << (fugue_sqlParser.RENAME - 178)))) != 0) or ((((_la - 248)) & ~0x3f) == 0 and ((1 << (_la - 248)) & ((1 << (fugue_sqlParser.SELECT - 248)) | (1 << (fugue_sqlParser.TABLE - 248)) | (1 << (fugue_sqlParser.TRANSFORM - 248)) | (1 << (fugue_sqlParser.VALUES - 248)) | (1 << (fugue_sqlParser.WITH - 248)))) != 0):
                    self.state = 1254
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.AS:
                        self.state = 1253
                        self.match(fugue_sqlParser.AS)


                    self.state = 1256
                    self.query()


                pass

            elif la_ == 13:
                localctx = fugue_sqlParser.AnalyzeContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 1259
                self.match(fugue_sqlParser.ANALYZE)
                self.state = 1260
                self.match(fugue_sqlParser.TABLE)
                self.state = 1261
                self.multipartIdentifier()
                self.state = 1263
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1262
                    self.partitionSpec()


                self.state = 1265
                self.match(fugue_sqlParser.COMPUTE)
                self.state = 1266
                self.match(fugue_sqlParser.STATISTICS)
                self.state = 1274
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
                if la_ == 1:
                    self.state = 1267
                    self.identifier()

                elif la_ == 2:
                    self.state = 1268
                    self.match(fugue_sqlParser.FOR)
                    self.state = 1269
                    self.match(fugue_sqlParser.COLUMNS)
                    self.state = 1270
                    self.identifierSeq()

                elif la_ == 3:
                    self.state = 1271
                    self.match(fugue_sqlParser.FOR)
                    self.state = 1272
                    self.match(fugue_sqlParser.ALL)
                    self.state = 1273
                    self.match(fugue_sqlParser.COLUMNS)


                pass

            elif la_ == 14:
                localctx = fugue_sqlParser.AddTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 1276
                self.match(fugue_sqlParser.ALTER)
                self.state = 1277
                self.match(fugue_sqlParser.TABLE)
                self.state = 1278
                self.multipartIdentifier()
                self.state = 1279
                self.match(fugue_sqlParser.ADD)
                self.state = 1280
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.COLUMN or _la==fugue_sqlParser.COLUMNS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1281
                localctx.columns = self.qualifiedColTypeWithPositionList()
                pass

            elif la_ == 15:
                localctx = fugue_sqlParser.AddTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 1283
                self.match(fugue_sqlParser.ALTER)
                self.state = 1284
                self.match(fugue_sqlParser.TABLE)
                self.state = 1285
                self.multipartIdentifier()
                self.state = 1286
                self.match(fugue_sqlParser.ADD)
                self.state = 1287
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.COLUMN or _la==fugue_sqlParser.COLUMNS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1288
                self.match(fugue_sqlParser.T__2)
                self.state = 1289
                localctx.columns = self.qualifiedColTypeWithPositionList()
                self.state = 1290
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 16:
                localctx = fugue_sqlParser.RenameTableColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 1292
                self.match(fugue_sqlParser.ALTER)
                self.state = 1293
                self.match(fugue_sqlParser.TABLE)
                self.state = 1294
                localctx.table = self.multipartIdentifier()
                self.state = 1295
                self.match(fugue_sqlParser.RENAME)
                self.state = 1296
                self.match(fugue_sqlParser.COLUMN)
                self.state = 1297
                localctx.ifrom = self.multipartIdentifier()
                self.state = 1298
                self.match(fugue_sqlParser.TO)
                self.state = 1299
                localctx.to = self.errorCapturingIdentifier()
                pass

            elif la_ == 17:
                localctx = fugue_sqlParser.DropTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 1301
                self.match(fugue_sqlParser.ALTER)
                self.state = 1302
                self.match(fugue_sqlParser.TABLE)
                self.state = 1303
                self.multipartIdentifier()
                self.state = 1304
                self.match(fugue_sqlParser.DROP)
                self.state = 1305
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.COLUMN or _la==fugue_sqlParser.COLUMNS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1306
                self.match(fugue_sqlParser.T__2)
                self.state = 1307
                localctx.columns = self.multipartIdentifierList()
                self.state = 1308
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 18:
                localctx = fugue_sqlParser.DropTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 1310
                self.match(fugue_sqlParser.ALTER)
                self.state = 1311
                self.match(fugue_sqlParser.TABLE)
                self.state = 1312
                self.multipartIdentifier()
                self.state = 1313
                self.match(fugue_sqlParser.DROP)
                self.state = 1314
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.COLUMN or _la==fugue_sqlParser.COLUMNS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1315
                localctx.columns = self.multipartIdentifierList()
                pass

            elif la_ == 19:
                localctx = fugue_sqlParser.RenameTableContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 1317
                self.match(fugue_sqlParser.ALTER)
                self.state = 1318
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.TABLE or _la==fugue_sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1319
                localctx.ifrom = self.multipartIdentifier()
                self.state = 1320
                self.match(fugue_sqlParser.RENAME)
                self.state = 1321
                self.match(fugue_sqlParser.TO)
                self.state = 1322
                localctx.to = self.multipartIdentifier()
                pass

            elif la_ == 20:
                localctx = fugue_sqlParser.SetTablePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 1324
                self.match(fugue_sqlParser.ALTER)
                self.state = 1325
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.TABLE or _la==fugue_sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1326
                self.multipartIdentifier()
                self.state = 1327
                self.match(fugue_sqlParser.SET)
                self.state = 1328
                self.match(fugue_sqlParser.TBLPROPERTIES)
                self.state = 1329
                self.tablePropertyList()
                pass

            elif la_ == 21:
                localctx = fugue_sqlParser.UnsetTablePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 1331
                self.match(fugue_sqlParser.ALTER)
                self.state = 1332
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.TABLE or _la==fugue_sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1333
                self.multipartIdentifier()
                self.state = 1334
                self.match(fugue_sqlParser.UNSET)
                self.state = 1335
                self.match(fugue_sqlParser.TBLPROPERTIES)
                self.state = 1338
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.IF:
                    self.state = 1336
                    self.match(fugue_sqlParser.IF)
                    self.state = 1337
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1340
                self.tablePropertyList()
                pass

            elif la_ == 22:
                localctx = fugue_sqlParser.AlterTableAlterColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 22)
                self.state = 1342
                self.match(fugue_sqlParser.ALTER)
                self.state = 1343
                self.match(fugue_sqlParser.TABLE)
                self.state = 1344
                localctx.table = self.multipartIdentifier()
                self.state = 1345
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.ALTER or _la==fugue_sqlParser.CHANGE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1347
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
                if la_ == 1:
                    self.state = 1346
                    self.match(fugue_sqlParser.COLUMN)


                self.state = 1349
                localctx.column = self.multipartIdentifier()
                self.state = 1351
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.AFTER or ((((_la - 87)) & ~0x3f) == 0 and ((1 << (_la - 87)) & ((1 << (fugue_sqlParser.COMMENT - 87)) | (1 << (fugue_sqlParser.DROP - 87)) | (1 << (fugue_sqlParser.FIRST - 87)))) != 0) or _la==fugue_sqlParser.SET or _la==fugue_sqlParser.TYPE:
                    self.state = 1350
                    self.alterColumnAction()


                pass

            elif la_ == 23:
                localctx = fugue_sqlParser.HiveChangeColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 23)
                self.state = 1353
                self.match(fugue_sqlParser.ALTER)
                self.state = 1354
                self.match(fugue_sqlParser.TABLE)
                self.state = 1355
                localctx.table = self.multipartIdentifier()
                self.state = 1357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1356
                    self.partitionSpec()


                self.state = 1359
                self.match(fugue_sqlParser.CHANGE)
                self.state = 1361
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
                if la_ == 1:
                    self.state = 1360
                    self.match(fugue_sqlParser.COLUMN)


                self.state = 1363
                localctx.colName = self.multipartIdentifier()
                self.state = 1364
                self.colType()
                self.state = 1366
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.AFTER or _la==fugue_sqlParser.FIRST:
                    self.state = 1365
                    self.colPosition()


                pass

            elif la_ == 24:
                localctx = fugue_sqlParser.HiveReplaceColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 24)
                self.state = 1368
                self.match(fugue_sqlParser.ALTER)
                self.state = 1369
                self.match(fugue_sqlParser.TABLE)
                self.state = 1370
                localctx.table = self.multipartIdentifier()
                self.state = 1372
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1371
                    self.partitionSpec()


                self.state = 1374
                self.match(fugue_sqlParser.REPLACE)
                self.state = 1375
                self.match(fugue_sqlParser.COLUMNS)
                self.state = 1376
                self.match(fugue_sqlParser.T__2)
                self.state = 1377
                localctx.columns = self.qualifiedColTypeWithPositionList()
                self.state = 1378
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 25:
                localctx = fugue_sqlParser.SetTableSerDeContext(self, localctx)
                self.enterOuterAlt(localctx, 25)
                self.state = 1380
                self.match(fugue_sqlParser.ALTER)
                self.state = 1381
                self.match(fugue_sqlParser.TABLE)
                self.state = 1382
                self.multipartIdentifier()
                self.state = 1384
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1383
                    self.partitionSpec()


                self.state = 1386
                self.match(fugue_sqlParser.SET)
                self.state = 1387
                self.match(fugue_sqlParser.SERDE)
                self.state = 1388
                self.match(fugue_sqlParser.STRING)
                self.state = 1392
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.WITH:
                    self.state = 1389
                    self.match(fugue_sqlParser.WITH)
                    self.state = 1390
                    self.match(fugue_sqlParser.SERDEPROPERTIES)
                    self.state = 1391
                    self.tablePropertyList()


                pass

            elif la_ == 26:
                localctx = fugue_sqlParser.SetTableSerDeContext(self, localctx)
                self.enterOuterAlt(localctx, 26)
                self.state = 1394
                self.match(fugue_sqlParser.ALTER)
                self.state = 1395
                self.match(fugue_sqlParser.TABLE)
                self.state = 1396
                self.multipartIdentifier()
                self.state = 1398
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1397
                    self.partitionSpec()


                self.state = 1400
                self.match(fugue_sqlParser.SET)
                self.state = 1401
                self.match(fugue_sqlParser.SERDEPROPERTIES)
                self.state = 1402
                self.tablePropertyList()
                pass

            elif la_ == 27:
                localctx = fugue_sqlParser.AddTablePartitionContext(self, localctx)
                self.enterOuterAlt(localctx, 27)
                self.state = 1404
                self.match(fugue_sqlParser.ALTER)
                self.state = 1405
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.TABLE or _la==fugue_sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1406
                self.multipartIdentifier()
                self.state = 1407
                self.match(fugue_sqlParser.ADD)
                self.state = 1411
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.IF:
                    self.state = 1408
                    self.match(fugue_sqlParser.IF)
                    self.state = 1409
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1410
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1414 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1413
                    self.partitionSpecLocation()
                    self.state = 1416 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==fugue_sqlParser.PARTITION):
                        break

                pass

            elif la_ == 28:
                localctx = fugue_sqlParser.RenameTablePartitionContext(self, localctx)
                self.enterOuterAlt(localctx, 28)
                self.state = 1418
                self.match(fugue_sqlParser.ALTER)
                self.state = 1419
                self.match(fugue_sqlParser.TABLE)
                self.state = 1420
                self.multipartIdentifier()
                self.state = 1421
                localctx.ifrom = self.partitionSpec()
                self.state = 1422
                self.match(fugue_sqlParser.RENAME)
                self.state = 1423
                self.match(fugue_sqlParser.TO)
                self.state = 1424
                localctx.to = self.partitionSpec()
                pass

            elif la_ == 29:
                localctx = fugue_sqlParser.DropTablePartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 29)
                self.state = 1426
                self.match(fugue_sqlParser.ALTER)
                self.state = 1427
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.TABLE or _la==fugue_sqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1428
                self.multipartIdentifier()
                self.state = 1429
                self.match(fugue_sqlParser.DROP)
                self.state = 1432
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.IF:
                    self.state = 1430
                    self.match(fugue_sqlParser.IF)
                    self.state = 1431
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1434
                self.partitionSpec()
                self.state = 1439
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 1435
                    self.match(fugue_sqlParser.T__0)
                    self.state = 1436
                    self.partitionSpec()
                    self.state = 1441
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1443
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PURGE:
                    self.state = 1442
                    self.match(fugue_sqlParser.PURGE)


                pass

            elif la_ == 30:
                localctx = fugue_sqlParser.SetTableLocationContext(self, localctx)
                self.enterOuterAlt(localctx, 30)
                self.state = 1445
                self.match(fugue_sqlParser.ALTER)
                self.state = 1446
                self.match(fugue_sqlParser.TABLE)
                self.state = 1447
                self.multipartIdentifier()
                self.state = 1449
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1448
                    self.partitionSpec()


                self.state = 1451
                self.match(fugue_sqlParser.SET)
                self.state = 1452
                self.locationSpec()
                pass

            elif la_ == 31:
                localctx = fugue_sqlParser.RecoverPartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 31)
                self.state = 1454
                self.match(fugue_sqlParser.ALTER)
                self.state = 1455
                self.match(fugue_sqlParser.TABLE)
                self.state = 1456
                self.multipartIdentifier()
                self.state = 1457
                self.match(fugue_sqlParser.RECOVER)
                self.state = 1458
                self.match(fugue_sqlParser.PARTITIONS)
                pass

            elif la_ == 32:
                localctx = fugue_sqlParser.DropTableContext(self, localctx)
                self.enterOuterAlt(localctx, 32)
                self.state = 1460
                self.match(fugue_sqlParser.DROP)
                self.state = 1461
                self.match(fugue_sqlParser.TABLE)
                self.state = 1464
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
                if la_ == 1:
                    self.state = 1462
                    self.match(fugue_sqlParser.IF)
                    self.state = 1463
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1466
                self.multipartIdentifier()
                self.state = 1468
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PURGE:
                    self.state = 1467
                    self.match(fugue_sqlParser.PURGE)


                pass

            elif la_ == 33:
                localctx = fugue_sqlParser.DropViewContext(self, localctx)
                self.enterOuterAlt(localctx, 33)
                self.state = 1470
                self.match(fugue_sqlParser.DROP)
                self.state = 1471
                self.match(fugue_sqlParser.VIEW)
                self.state = 1474
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
                if la_ == 1:
                    self.state = 1472
                    self.match(fugue_sqlParser.IF)
                    self.state = 1473
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1476
                self.multipartIdentifier()
                pass

            elif la_ == 34:
                localctx = fugue_sqlParser.CreateViewContext(self, localctx)
                self.enterOuterAlt(localctx, 34)
                self.state = 1477
                self.match(fugue_sqlParser.CREATE)
                self.state = 1480
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OR:
                    self.state = 1478
                    self.match(fugue_sqlParser.OR)
                    self.state = 1479
                    self.match(fugue_sqlParser.REPLACE)


                self.state = 1486
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.GLOBAL or _la==fugue_sqlParser.TEMPORARY:
                    self.state = 1483
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.GLOBAL:
                        self.state = 1482
                        self.match(fugue_sqlParser.GLOBAL)


                    self.state = 1485
                    self.match(fugue_sqlParser.TEMPORARY)


                self.state = 1488
                self.match(fugue_sqlParser.VIEW)
                self.state = 1492
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
                if la_ == 1:
                    self.state = 1489
                    self.match(fugue_sqlParser.IF)
                    self.state = 1490
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1491
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1494
                self.multipartIdentifier()
                self.state = 1496
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__2:
                    self.state = 1495
                    self.identifierCommentList()


                self.state = 1506
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.COMMENT or _la==fugue_sqlParser.PARTITIONED or _la==fugue_sqlParser.TBLPROPERTIES:
                    self.state = 1504
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [fugue_sqlParser.COMMENT]:
                        self.state = 1498
                        self.commentSpec()
                        pass
                    elif token in [fugue_sqlParser.PARTITIONED]:
                        self.state = 1499
                        self.match(fugue_sqlParser.PARTITIONED)
                        self.state = 1500
                        self.match(fugue_sqlParser.ON)
                        self.state = 1501
                        self.identifierList()
                        pass
                    elif token in [fugue_sqlParser.TBLPROPERTIES]:
                        self.state = 1502
                        self.match(fugue_sqlParser.TBLPROPERTIES)
                        self.state = 1503
                        self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

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

                self.state = 1509
                self.match(fugue_sqlParser.AS)
                self.state = 1510
                self.query()
                pass

            elif la_ == 35:
                localctx = fugue_sqlParser.CreateTempViewUsingContext(self, localctx)
                self.enterOuterAlt(localctx, 35)
                self.state = 1512
                self.match(fugue_sqlParser.CREATE)
                self.state = 1515
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OR:
                    self.state = 1513
                    self.match(fugue_sqlParser.OR)
                    self.state = 1514
                    self.match(fugue_sqlParser.REPLACE)


                self.state = 1518
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.GLOBAL:
                    self.state = 1517
                    self.match(fugue_sqlParser.GLOBAL)


                self.state = 1520
                self.match(fugue_sqlParser.TEMPORARY)
                self.state = 1521
                self.match(fugue_sqlParser.VIEW)
                self.state = 1522
                self.tableIdentifier()
                self.state = 1527
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__2:
                    self.state = 1523
                    self.match(fugue_sqlParser.T__2)
                    self.state = 1524
                    self.colTypeList()
                    self.state = 1525
                    self.match(fugue_sqlParser.T__3)


                self.state = 1529
                self.tableProvider()
                self.state = 1532
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OPTIONS:
                    self.state = 1530
                    self.match(fugue_sqlParser.OPTIONS)
                    self.state = 1531
                    self.tablePropertyList()


                pass

            elif la_ == 36:
                localctx = fugue_sqlParser.AlterViewQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 36)
                self.state = 1534
                self.match(fugue_sqlParser.ALTER)
                self.state = 1535
                self.match(fugue_sqlParser.VIEW)
                self.state = 1536
                self.multipartIdentifier()
                self.state = 1538
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.AS:
                    self.state = 1537
                    self.match(fugue_sqlParser.AS)


                self.state = 1540
                self.query()
                pass

            elif la_ == 37:
                localctx = fugue_sqlParser.CreateFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 37)
                self.state = 1542
                self.match(fugue_sqlParser.CREATE)
                self.state = 1545
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OR:
                    self.state = 1543
                    self.match(fugue_sqlParser.OR)
                    self.state = 1544
                    self.match(fugue_sqlParser.REPLACE)


                self.state = 1548
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.TEMPORARY:
                    self.state = 1547
                    self.match(fugue_sqlParser.TEMPORARY)


                self.state = 1550
                self.match(fugue_sqlParser.FUNCTION)
                self.state = 1554
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
                if la_ == 1:
                    self.state = 1551
                    self.match(fugue_sqlParser.IF)
                    self.state = 1552
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1553
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1556
                self.multipartIdentifier()
                self.state = 1557
                self.match(fugue_sqlParser.AS)
                self.state = 1558
                localctx.className = self.match(fugue_sqlParser.STRING)
                self.state = 1568
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.USING:
                    self.state = 1559
                    self.match(fugue_sqlParser.USING)
                    self.state = 1560
                    self.resource()
                    self.state = 1565
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==fugue_sqlParser.T__0:
                        self.state = 1561
                        self.match(fugue_sqlParser.T__0)
                        self.state = 1562
                        self.resource()
                        self.state = 1567
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                pass

            elif la_ == 38:
                localctx = fugue_sqlParser.DropFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 38)
                self.state = 1570
                self.match(fugue_sqlParser.DROP)
                self.state = 1572
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.TEMPORARY:
                    self.state = 1571
                    self.match(fugue_sqlParser.TEMPORARY)


                self.state = 1574
                self.match(fugue_sqlParser.FUNCTION)
                self.state = 1577
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
                if la_ == 1:
                    self.state = 1575
                    self.match(fugue_sqlParser.IF)
                    self.state = 1576
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1579
                self.multipartIdentifier()
                pass

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


                self.state = 1584
                self.statement()
                pass

            elif la_ == 40:
                localctx = fugue_sqlParser.ShowTablesContext(self, localctx)
                self.enterOuterAlt(localctx, 40)
                self.state = 1585
                self.match(fugue_sqlParser.SHOW)
                self.state = 1586
                self.match(fugue_sqlParser.TABLES)
                self.state = 1589
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN:
                    self.state = 1587
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1588
                    self.multipartIdentifier()


                self.state = 1595
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LIKE or _la==fugue_sqlParser.STRING:
                    self.state = 1592
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.LIKE:
                        self.state = 1591
                        self.match(fugue_sqlParser.LIKE)


                    self.state = 1594
                    localctx.pattern = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 41:
                localctx = fugue_sqlParser.ShowTableContext(self, localctx)
                self.enterOuterAlt(localctx, 41)
                self.state = 1597
                self.match(fugue_sqlParser.SHOW)
                self.state = 1598
                self.match(fugue_sqlParser.TABLE)
                self.state = 1599
                self.match(fugue_sqlParser.EXTENDED)
                self.state = 1602
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN:
                    self.state = 1600
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1601
                    localctx.ns = self.multipartIdentifier()


                self.state = 1604
                self.match(fugue_sqlParser.LIKE)
                self.state = 1605
                localctx.pattern = self.match(fugue_sqlParser.STRING)
                self.state = 1607
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1606
                    self.partitionSpec()


                pass

            elif la_ == 42:
                localctx = fugue_sqlParser.ShowTblPropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 42)
                self.state = 1609
                self.match(fugue_sqlParser.SHOW)
                self.state = 1610
                self.match(fugue_sqlParser.TBLPROPERTIES)
                self.state = 1611
                localctx.table = self.multipartIdentifier()
                self.state = 1616
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__2:
                    self.state = 1612
                    self.match(fugue_sqlParser.T__2)
                    self.state = 1613
                    localctx.key = self.tablePropertyKey()
                    self.state = 1614
                    self.match(fugue_sqlParser.T__3)


                pass

            elif la_ == 43:
                localctx = fugue_sqlParser.ShowColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 43)
                self.state = 1618
                self.match(fugue_sqlParser.SHOW)
                self.state = 1619
                self.match(fugue_sqlParser.COLUMNS)
                self.state = 1620
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1621
                localctx.table = self.multipartIdentifier()
                self.state = 1624
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN:
                    self.state = 1622
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1623
                    localctx.ns = self.multipartIdentifier()


                pass

            elif la_ == 44:
                localctx = fugue_sqlParser.ShowViewsContext(self, localctx)
                self.enterOuterAlt(localctx, 44)
                self.state = 1626
                self.match(fugue_sqlParser.SHOW)
                self.state = 1627
                self.match(fugue_sqlParser.VIEWS)
                self.state = 1630
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN:
                    self.state = 1628
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.FROM or _la==fugue_sqlParser.IN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1629
                    self.multipartIdentifier()


                self.state = 1636
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LIKE or _la==fugue_sqlParser.STRING:
                    self.state = 1633
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.LIKE:
                        self.state = 1632
                        self.match(fugue_sqlParser.LIKE)


                    self.state = 1635
                    localctx.pattern = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 45:
                localctx = fugue_sqlParser.ShowPartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 45)
                self.state = 1638
                self.match(fugue_sqlParser.SHOW)
                self.state = 1639
                self.match(fugue_sqlParser.PARTITIONS)
                self.state = 1640
                self.multipartIdentifier()
                self.state = 1642
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1641
                    self.partitionSpec()


                pass

            elif la_ == 46:
                localctx = fugue_sqlParser.ShowFunctionsContext(self, localctx)
                self.enterOuterAlt(localctx, 46)
                self.state = 1644
                self.match(fugue_sqlParser.SHOW)
                self.state = 1646
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
                if la_ == 1:
                    self.state = 1645
                    self.identifier()


                self.state = 1648
                self.match(fugue_sqlParser.FUNCTIONS)
                self.state = 1656
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,202,self._ctx)
                if la_ == 1:
                    self.state = 1650
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
                    if la_ == 1:
                        self.state = 1649
                        self.match(fugue_sqlParser.LIKE)


                    self.state = 1654
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
                    if la_ == 1:
                        self.state = 1652
                        self.multipartIdentifier()
                        pass

                    elif la_ == 2:
                        self.state = 1653
                        localctx.pattern = self.match(fugue_sqlParser.STRING)
                        pass




                pass

            elif la_ == 47:
                localctx = fugue_sqlParser.ShowCreateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 47)
                self.state = 1658
                self.match(fugue_sqlParser.SHOW)
                self.state = 1659
                self.match(fugue_sqlParser.CREATE)
                self.state = 1660
                self.match(fugue_sqlParser.TABLE)
                self.state = 1661
                self.multipartIdentifier()
                self.state = 1664
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.AS:
                    self.state = 1662
                    self.match(fugue_sqlParser.AS)
                    self.state = 1663
                    self.match(fugue_sqlParser.SERDE)


                pass

            elif la_ == 48:
                localctx = fugue_sqlParser.ShowCurrentNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 48)
                self.state = 1666
                self.match(fugue_sqlParser.SHOW)
                self.state = 1667
                self.match(fugue_sqlParser.CURRENT)
                self.state = 1668
                self.match(fugue_sqlParser.NAMESPACE)
                pass

            elif la_ == 49:
                localctx = fugue_sqlParser.DescribeFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 49)
                self.state = 1669
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.DESC or _la==fugue_sqlParser.DESCRIBE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1670
                self.match(fugue_sqlParser.FUNCTION)
                self.state = 1672
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,204,self._ctx)
                if la_ == 1:
                    self.state = 1671
                    self.match(fugue_sqlParser.EXTENDED)


                self.state = 1674
                self.describeFuncName()
                pass

            elif la_ == 50:
                localctx = fugue_sqlParser.DescribeNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 50)
                self.state = 1675
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.DESC or _la==fugue_sqlParser.DESCRIBE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1676
                self.namespace()
                self.state = 1678
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
                if la_ == 1:
                    self.state = 1677
                    self.match(fugue_sqlParser.EXTENDED)


                self.state = 1680
                self.multipartIdentifier()
                pass

            elif la_ == 51:
                localctx = fugue_sqlParser.DescribeRelationContext(self, localctx)
                self.enterOuterAlt(localctx, 51)
                self.state = 1682
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.DESC or _la==fugue_sqlParser.DESCRIBE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1684
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
                if la_ == 1:
                    self.state = 1683
                    self.match(fugue_sqlParser.TABLE)


                self.state = 1687
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,207,self._ctx)
                if la_ == 1:
                    self.state = 1686
                    localctx.option = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.EXTENDED or _la==fugue_sqlParser.FORMATTED):
                        localctx.option = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1689
                self.multipartIdentifier()
                self.state = 1691
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
                if la_ == 1:
                    self.state = 1690
                    self.partitionSpec()


                self.state = 1694
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
                if la_ == 1:
                    self.state = 1693
                    self.describeColName()


                pass

            elif la_ == 52:
                localctx = fugue_sqlParser.DescribeQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 52)
                self.state = 1696
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.DESC or _la==fugue_sqlParser.DESCRIBE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1698
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.QUERY:
                    self.state = 1697
                    self.match(fugue_sqlParser.QUERY)


                self.state = 1700
                self.query()
                pass

            elif la_ == 53:
                localctx = fugue_sqlParser.CommentNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 53)
                self.state = 1701
                self.match(fugue_sqlParser.COMMENT)
                self.state = 1702
                self.match(fugue_sqlParser.ON)
                self.state = 1703
                self.namespace()
                self.state = 1704
                self.multipartIdentifier()
                self.state = 1705
                self.match(fugue_sqlParser.IS)
                self.state = 1706
                localctx.comment = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.NULL or _la==fugue_sqlParser.STRING):
                    localctx.comment = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 54:
                localctx = fugue_sqlParser.CommentTableContext(self, localctx)
                self.enterOuterAlt(localctx, 54)
                self.state = 1708
                self.match(fugue_sqlParser.COMMENT)
                self.state = 1709
                self.match(fugue_sqlParser.ON)
                self.state = 1710
                self.match(fugue_sqlParser.TABLE)
                self.state = 1711
                self.multipartIdentifier()
                self.state = 1712
                self.match(fugue_sqlParser.IS)
                self.state = 1713
                localctx.comment = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.NULL or _la==fugue_sqlParser.STRING):
                    localctx.comment = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 55:
                localctx = fugue_sqlParser.RefreshTableContext(self, localctx)
                self.enterOuterAlt(localctx, 55)
                self.state = 1715
                self.match(fugue_sqlParser.REFRESH)
                self.state = 1716
                self.match(fugue_sqlParser.TABLE)
                self.state = 1717
                self.multipartIdentifier()
                pass

            elif la_ == 56:
                localctx = fugue_sqlParser.RefreshResourceContext(self, localctx)
                self.enterOuterAlt(localctx, 56)
                self.state = 1718
                self.match(fugue_sqlParser.REFRESH)
                self.state = 1726
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
                if la_ == 1:
                    self.state = 1719
                    self.match(fugue_sqlParser.STRING)
                    pass

                elif la_ == 2:
                    self.state = 1723
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,211,self._ctx)
                    while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1+1:
                            self.state = 1720
                            self.matchWildcard() 
                        self.state = 1725
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,211,self._ctx)

                    pass


                pass

            elif la_ == 57:
                localctx = fugue_sqlParser.CacheTableContext(self, localctx)
                self.enterOuterAlt(localctx, 57)
                self.state = 1728
                self.match(fugue_sqlParser.CACHE)
                self.state = 1730
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LAZY:
                    self.state = 1729
                    self.match(fugue_sqlParser.LAZY)


                self.state = 1732
                self.match(fugue_sqlParser.TABLE)
                self.state = 1733
                self.multipartIdentifier()
                self.state = 1736
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OPTIONS:
                    self.state = 1734
                    self.match(fugue_sqlParser.OPTIONS)
                    self.state = 1735
                    localctx.options = self.tablePropertyList()


                self.state = 1742
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & ((1 << (fugue_sqlParser.FILL - 17)) | (1 << (fugue_sqlParser.TAKE - 17)) | (1 << (fugue_sqlParser.PROCESS - 17)) | (1 << (fugue_sqlParser.ZIP - 17)) | (1 << (fugue_sqlParser.SAVE - 17)) | (1 << (fugue_sqlParser.CONNECT - 17)) | (1 << (fugue_sqlParser.SAMPLE - 17)) | (1 << (fugue_sqlParser.ALTER - 17)) | (1 << (fugue_sqlParser.AS - 17)))) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (fugue_sqlParser.CREATE - 95)) | (1 << (fugue_sqlParser.DROP - 95)) | (1 << (fugue_sqlParser.FROM - 95)))) != 0) or ((((_la - 178)) & ~0x3f) == 0 and ((1 << (_la - 178)) & ((1 << (fugue_sqlParser.LOAD - 178)) | (1 << (fugue_sqlParser.MAP - 178)) | (1 << (fugue_sqlParser.REDUCE - 178)) | (1 << (fugue_sqlParser.RENAME - 178)))) != 0) or ((((_la - 248)) & ~0x3f) == 0 and ((1 << (_la - 248)) & ((1 << (fugue_sqlParser.SELECT - 248)) | (1 << (fugue_sqlParser.TABLE - 248)) | (1 << (fugue_sqlParser.TRANSFORM - 248)) | (1 << (fugue_sqlParser.VALUES - 248)) | (1 << (fugue_sqlParser.WITH - 248)))) != 0):
                    self.state = 1739
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.AS:
                        self.state = 1738
                        self.match(fugue_sqlParser.AS)


                    self.state = 1741
                    self.query()


                pass

            elif la_ == 58:
                localctx = fugue_sqlParser.UncacheTableContext(self, localctx)
                self.enterOuterAlt(localctx, 58)
                self.state = 1744
                self.match(fugue_sqlParser.UNCACHE)
                self.state = 1745
                self.match(fugue_sqlParser.TABLE)
                self.state = 1748
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,217,self._ctx)
                if la_ == 1:
                    self.state = 1746
                    self.match(fugue_sqlParser.IF)
                    self.state = 1747
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1750
                self.multipartIdentifier()
                pass

            elif la_ == 59:
                localctx = fugue_sqlParser.ClearCacheContext(self, localctx)
                self.enterOuterAlt(localctx, 59)
                self.state = 1751
                self.match(fugue_sqlParser.CLEAR)
                self.state = 1752
                self.match(fugue_sqlParser.CACHE)
                pass

            elif la_ == 60:
                localctx = fugue_sqlParser.LoadDataContext(self, localctx)
                self.enterOuterAlt(localctx, 60)
                self.state = 1753
                self.match(fugue_sqlParser.LOAD)
                self.state = 1754
                self.match(fugue_sqlParser.DATA)
                self.state = 1756
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LOCAL:
                    self.state = 1755
                    self.match(fugue_sqlParser.LOCAL)


                self.state = 1758
                self.match(fugue_sqlParser.INPATH)
                self.state = 1759
                localctx.path = self.match(fugue_sqlParser.STRING)
                self.state = 1761
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OVERWRITE:
                    self.state = 1760
                    self.match(fugue_sqlParser.OVERWRITE)


                self.state = 1763
                self.match(fugue_sqlParser.INTO)
                self.state = 1764
                self.match(fugue_sqlParser.TABLE)
                self.state = 1765
                self.multipartIdentifier()
                self.state = 1767
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1766
                    self.partitionSpec()


                pass

            elif la_ == 61:
                localctx = fugue_sqlParser.TruncateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 61)
                self.state = 1769
                self.match(fugue_sqlParser.TRUNCATE)
                self.state = 1770
                self.match(fugue_sqlParser.TABLE)
                self.state = 1771
                self.multipartIdentifier()
                self.state = 1773
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1772
                    self.partitionSpec()


                pass

            elif la_ == 62:
                localctx = fugue_sqlParser.RepairTableContext(self, localctx)
                self.enterOuterAlt(localctx, 62)
                self.state = 1775
                self.match(fugue_sqlParser.MSCK)
                self.state = 1776
                self.match(fugue_sqlParser.REPAIR)
                self.state = 1777
                self.match(fugue_sqlParser.TABLE)
                self.state = 1778
                self.multipartIdentifier()
                pass

            elif la_ == 63:
                localctx = fugue_sqlParser.ManageResourceContext(self, localctx)
                self.enterOuterAlt(localctx, 63)
                self.state = 1779
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.ADD or _la==fugue_sqlParser.LIST):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1780
                self.identifier()
                self.state = 1788
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
                if la_ == 1:
                    self.state = 1781
                    self.match(fugue_sqlParser.STRING)
                    pass

                elif la_ == 2:
                    self.state = 1785
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,222,self._ctx)
                    while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1+1:
                            self.state = 1782
                            self.matchWildcard() 
                        self.state = 1787
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,222,self._ctx)

                    pass


                pass

            elif la_ == 64:
                localctx = fugue_sqlParser.FailNativeCommandContext(self, localctx)
                self.enterOuterAlt(localctx, 64)
                self.state = 1790
                self.match(fugue_sqlParser.SET)
                self.state = 1791
                self.match(fugue_sqlParser.ROLE)
                self.state = 1795
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,224,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 1792
                        self.matchWildcard() 
                    self.state = 1797
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,224,self._ctx)

                pass

            elif la_ == 65:
                localctx = fugue_sqlParser.SetConfigurationContext(self, localctx)
                self.enterOuterAlt(localctx, 65)
                self.state = 1798
                self.match(fugue_sqlParser.SET)
                self.state = 1802
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,225,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 1799
                        self.matchWildcard() 
                    self.state = 1804
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,225,self._ctx)

                pass

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

            elif la_ == 67:
                localctx = fugue_sqlParser.FailNativeCommandContext(self, localctx)
                self.enterOuterAlt(localctx, 67)
                self.state = 1806
                self.unsupportedHiveNativeCommands()
                self.state = 1810
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,226,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 1807
                        self.matchWildcard() 
                    self.state = 1812
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,226,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(fugue_sqlParser.CREATE, 0)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.UnsupportedHiveNativeCommandsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_unsupportedHiveNativeCommands)
        self._la = 0 # Token type
        try:
            self.state = 1983
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,235,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1815
                localctx.kw1 = self.match(fugue_sqlParser.CREATE)
                self.state = 1816
                localctx.kw2 = self.match(fugue_sqlParser.ROLE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1817
                localctx.kw1 = self.match(fugue_sqlParser.DROP)
                self.state = 1818
                localctx.kw2 = self.match(fugue_sqlParser.ROLE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1819
                localctx.kw1 = self.match(fugue_sqlParser.GRANT)
                self.state = 1821
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,228,self._ctx)
                if la_ == 1:
                    self.state = 1820
                    localctx.kw2 = self.match(fugue_sqlParser.ROLE)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1823
                localctx.kw1 = self.match(fugue_sqlParser.REVOKE)
                self.state = 1825
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
                if la_ == 1:
                    self.state = 1824
                    localctx.kw2 = self.match(fugue_sqlParser.ROLE)


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1827
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1828
                localctx.kw2 = self.match(fugue_sqlParser.GRANT)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1829
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1830
                localctx.kw2 = self.match(fugue_sqlParser.ROLE)
                self.state = 1832
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
                if la_ == 1:
                    self.state = 1831
                    localctx.kw3 = self.match(fugue_sqlParser.GRANT)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1834
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1835
                localctx.kw2 = self.match(fugue_sqlParser.PRINCIPALS)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1836
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1837
                localctx.kw2 = self.match(fugue_sqlParser.ROLES)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1838
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1839
                localctx.kw2 = self.match(fugue_sqlParser.CURRENT)
                self.state = 1840
                localctx.kw3 = self.match(fugue_sqlParser.ROLES)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1841
                localctx.kw1 = self.match(fugue_sqlParser.EXPORT)
                self.state = 1842
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1843
                localctx.kw1 = self.match(fugue_sqlParser.IMPORT)
                self.state = 1844
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1845
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1846
                localctx.kw2 = self.match(fugue_sqlParser.COMPACTIONS)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1847
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1848
                localctx.kw2 = self.match(fugue_sqlParser.CREATE)
                self.state = 1849
                localctx.kw3 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1850
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1851
                localctx.kw2 = self.match(fugue_sqlParser.TRANSACTIONS)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1852
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1853
                localctx.kw2 = self.match(fugue_sqlParser.INDEXES)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1854
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1855
                localctx.kw2 = self.match(fugue_sqlParser.LOCKS)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1856
                localctx.kw1 = self.match(fugue_sqlParser.CREATE)
                self.state = 1857
                localctx.kw2 = self.match(fugue_sqlParser.INDEX)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1858
                localctx.kw1 = self.match(fugue_sqlParser.DROP)
                self.state = 1859
                localctx.kw2 = self.match(fugue_sqlParser.INDEX)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1860
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1861
                localctx.kw2 = self.match(fugue_sqlParser.INDEX)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 1862
                localctx.kw1 = self.match(fugue_sqlParser.LOCK)
                self.state = 1863
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 1864
                localctx.kw1 = self.match(fugue_sqlParser.LOCK)
                self.state = 1865
                localctx.kw2 = self.match(fugue_sqlParser.DATABASE)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 1866
                localctx.kw1 = self.match(fugue_sqlParser.UNLOCK)
                self.state = 1867
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 1868
                localctx.kw1 = self.match(fugue_sqlParser.UNLOCK)
                self.state = 1869
                localctx.kw2 = self.match(fugue_sqlParser.DATABASE)
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 1870
                localctx.kw1 = self.match(fugue_sqlParser.CREATE)
                self.state = 1871
                localctx.kw2 = self.match(fugue_sqlParser.TEMPORARY)
                self.state = 1872
                localctx.kw3 = self.match(fugue_sqlParser.MACRO)
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 1873
                localctx.kw1 = self.match(fugue_sqlParser.DROP)
                self.state = 1874
                localctx.kw2 = self.match(fugue_sqlParser.TEMPORARY)
                self.state = 1875
                localctx.kw3 = self.match(fugue_sqlParser.MACRO)
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 1876
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1877
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1878
                self.tableIdentifier()
                self.state = 1879
                localctx.kw3 = self.match(fugue_sqlParser.NOT)
                self.state = 1880
                localctx.kw4 = self.match(fugue_sqlParser.CLUSTERED)
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 1882
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1883
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1884
                self.tableIdentifier()
                self.state = 1885
                localctx.kw3 = self.match(fugue_sqlParser.CLUSTERED)
                self.state = 1886
                localctx.kw4 = self.match(fugue_sqlParser.BY)
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 1888
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1889
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1890
                self.tableIdentifier()
                self.state = 1891
                localctx.kw3 = self.match(fugue_sqlParser.NOT)
                self.state = 1892
                localctx.kw4 = self.match(fugue_sqlParser.SORTED)
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 1894
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1895
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1896
                self.tableIdentifier()
                self.state = 1897
                localctx.kw3 = self.match(fugue_sqlParser.SKEWED)
                self.state = 1898
                localctx.kw4 = self.match(fugue_sqlParser.BY)
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 1900
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1901
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1902
                self.tableIdentifier()
                self.state = 1903
                localctx.kw3 = self.match(fugue_sqlParser.NOT)
                self.state = 1904
                localctx.kw4 = self.match(fugue_sqlParser.SKEWED)
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 1906
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1907
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1908
                self.tableIdentifier()
                self.state = 1909
                localctx.kw3 = self.match(fugue_sqlParser.NOT)
                self.state = 1910
                localctx.kw4 = self.match(fugue_sqlParser.STORED)
                self.state = 1911
                localctx.kw5 = self.match(fugue_sqlParser.AS)
                self.state = 1912
                localctx.kw6 = self.match(fugue_sqlParser.DIRECTORIES)
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 1914
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1915
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1916
                self.tableIdentifier()
                self.state = 1917
                localctx.kw3 = self.match(fugue_sqlParser.SET)
                self.state = 1918
                localctx.kw4 = self.match(fugue_sqlParser.SKEWED)
                self.state = 1919
                localctx.kw5 = self.match(fugue_sqlParser.LOCATION)
                pass

            elif la_ == 33:
                self.enterOuterAlt(localctx, 33)
                self.state = 1921
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1922
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1923
                self.tableIdentifier()
                self.state = 1924
                localctx.kw3 = self.match(fugue_sqlParser.EXCHANGE)
                self.state = 1925
                localctx.kw4 = self.match(fugue_sqlParser.PARTITION)
                pass

            elif la_ == 34:
                self.enterOuterAlt(localctx, 34)
                self.state = 1927
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1928
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1929
                self.tableIdentifier()
                self.state = 1930
                localctx.kw3 = self.match(fugue_sqlParser.ARCHIVE)
                self.state = 1931
                localctx.kw4 = self.match(fugue_sqlParser.PARTITION)
                pass

            elif la_ == 35:
                self.enterOuterAlt(localctx, 35)
                self.state = 1933
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1934
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1935
                self.tableIdentifier()
                self.state = 1936
                localctx.kw3 = self.match(fugue_sqlParser.UNARCHIVE)
                self.state = 1937
                localctx.kw4 = self.match(fugue_sqlParser.PARTITION)
                pass

            elif la_ == 36:
                self.enterOuterAlt(localctx, 36)
                self.state = 1939
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1940
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1941
                self.tableIdentifier()
                self.state = 1942
                localctx.kw3 = self.match(fugue_sqlParser.TOUCH)
                pass

            elif la_ == 37:
                self.enterOuterAlt(localctx, 37)
                self.state = 1944
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1945
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1946
                self.tableIdentifier()
                self.state = 1948
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1947
                    self.partitionSpec()


                self.state = 1950
                localctx.kw3 = self.match(fugue_sqlParser.COMPACT)
                pass

            elif la_ == 38:
                self.enterOuterAlt(localctx, 38)
                self.state = 1952
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1953
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1954
                self.tableIdentifier()
                self.state = 1956
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1955
                    self.partitionSpec()


                self.state = 1958
                localctx.kw3 = self.match(fugue_sqlParser.CONCATENATE)
                pass

            elif la_ == 39:
                self.enterOuterAlt(localctx, 39)
                self.state = 1960
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1961
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1962
                self.tableIdentifier()
                self.state = 1964
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1963
                    self.partitionSpec()


                self.state = 1966
                localctx.kw3 = self.match(fugue_sqlParser.SET)
                self.state = 1967
                localctx.kw4 = self.match(fugue_sqlParser.FILEFORMAT)
                pass

            elif la_ == 40:
                self.enterOuterAlt(localctx, 40)
                self.state = 1969
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1970
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1971
                self.tableIdentifier()
                self.state = 1973
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 1972
                    self.partitionSpec()


                self.state = 1975
                localctx.kw3 = self.match(fugue_sqlParser.REPLACE)
                self.state = 1976
                localctx.kw4 = self.match(fugue_sqlParser.COLUMNS)
                pass

            elif la_ == 41:
                self.enterOuterAlt(localctx, 41)
                self.state = 1978
                localctx.kw1 = self.match(fugue_sqlParser.START)
                self.state = 1979
                localctx.kw2 = self.match(fugue_sqlParser.TRANSACTION)
                pass

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

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

            elif la_ == 44:
                self.enterOuterAlt(localctx, 44)
                self.state = 1982
                localctx.kw1 = self.match(fugue_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(fugue_sqlParser.CREATE, 0)

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

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


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

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

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

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

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.CreateTableHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_createTableHeader)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1985
            self.match(fugue_sqlParser.CREATE)
            self.state = 1987
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.TEMPORARY:
                self.state = 1986
                self.match(fugue_sqlParser.TEMPORARY)


            self.state = 1990
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.EXTERNAL:
                self.state = 1989
                self.match(fugue_sqlParser.EXTERNAL)


            self.state = 1992
            self.match(fugue_sqlParser.TABLE)
            self.state = 1996
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
            if la_ == 1:
                self.state = 1993
                self.match(fugue_sqlParser.IF)
                self.state = 1994
                self.match(fugue_sqlParser.NOT)
                self.state = 1995
                self.match(fugue_sqlParser.EXISTS)


            self.state = 1998
            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(fugue_sqlParser.REPLACE, 0)

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

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


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

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ReplaceTableHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_replaceTableHeader)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.CREATE:
                self.state = 2000
                self.match(fugue_sqlParser.CREATE)
                self.state = 2001
                self.match(fugue_sqlParser.OR)


            self.state = 2004
            self.match(fugue_sqlParser.REPLACE)
            self.state = 2005
            self.match(fugue_sqlParser.TABLE)
            self.state = 2006
            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(fugue_sqlParser.CLUSTERED, 0)

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

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


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

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

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

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

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.BucketSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_bucketSpec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2008
            self.match(fugue_sqlParser.CLUSTERED)
            self.state = 2009
            self.match(fugue_sqlParser.BY)
            self.state = 2010
            self.identifierList()
            self.state = 2014
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.SORTED:
                self.state = 2011
                self.match(fugue_sqlParser.SORTED)
                self.state = 2012
                self.match(fugue_sqlParser.BY)
                self.state = 2013
                self.orderedIdentifierList()


            self.state = 2016
            self.match(fugue_sqlParser.INTO)
            self.state = 2017
            self.match(fugue_sqlParser.INTEGER_VALUE)
            self.state = 2018
            self.match(fugue_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(fugue_sqlParser.SKEWED, 0)

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

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


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

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


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


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

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

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SkewSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_skewSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2020
            self.match(fugue_sqlParser.SKEWED)
            self.state = 2021
            self.match(fugue_sqlParser.BY)
            self.state = 2022
            self.identifierList()
            self.state = 2023
            self.match(fugue_sqlParser.ON)
            self.state = 2026
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
            if la_ == 1:
                self.state = 2024
                self.constantList()
                pass

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


            self.state = 2031
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,242,self._ctx)
            if la_ == 1:
                self.state = 2028
                self.match(fugue_sqlParser.STORED)
                self.state = 2029
                self.match(fugue_sqlParser.AS)
                self.state = 2030
                self.match(fugue_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(fugue_sqlParser.LOCATION, 0)

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.LocationSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_locationSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2033
            self.match(fugue_sqlParser.LOCATION)
            self.state = 2034
            self.match(fugue_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(fugue_sqlParser.COMMENT, 0)

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.CommentSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_commentSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2036
            self.match(fugue_sqlParser.COMMENT)
            self.state = 2037
            self.match(fugue_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(fugue_sqlParser.QueryTermContext,0)


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


        def fugueSqlEngine(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSqlEngineContext,0)


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.QueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_query)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2040
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.CONNECT:
                self.state = 2039
                self.fugueSqlEngine()


            self.state = 2043
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.WITH:
                self.state = 2042
                self.ctes()


            self.state = 2045
            self.queryTerm(0)
            self.state = 2046
            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 fugue_sqlParser.RULE_insertInto

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



    class InsertOverwriteHiveDirContext(InsertIntoContext):

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

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

        def createFileFormat(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.InsertIntoContext
            super().__init__(parser)
            self.path = None # Token
            self.options = None # TablePropertyListContext
            self.copyFrom(ctx)

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

        def LOCAL(self):
            return self.getToken(fugue_sqlParser.LOCAL, 0)
        def OPTIONS(self):
            return self.getToken(fugue_sqlParser.OPTIONS, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.InsertIntoContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(fugue_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 fugue_sqlParser.InsertIntoContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(fugue_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 = fugue_sqlParser.InsertIntoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_insertInto)
        self._la = 0 # Token type
        try:
            self.state = 2103
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,257,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.InsertOverwriteTableContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2048
                self.match(fugue_sqlParser.INSERT)
                self.state = 2049
                self.match(fugue_sqlParser.OVERWRITE)
                self.state = 2051
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
                if la_ == 1:
                    self.state = 2050
                    self.match(fugue_sqlParser.TABLE)


                self.state = 2053
                self.multipartIdentifier()
                self.state = 2060
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 2054
                    self.partitionSpec()
                    self.state = 2058
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.IF:
                        self.state = 2055
                        self.match(fugue_sqlParser.IF)
                        self.state = 2056
                        self.match(fugue_sqlParser.NOT)
                        self.state = 2057
                        self.match(fugue_sqlParser.EXISTS)




                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.InsertIntoTableContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2062
                self.match(fugue_sqlParser.INSERT)
                self.state = 2063
                self.match(fugue_sqlParser.INTO)
                self.state = 2065
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,248,self._ctx)
                if la_ == 1:
                    self.state = 2064
                    self.match(fugue_sqlParser.TABLE)


                self.state = 2067
                self.multipartIdentifier()
                self.state = 2069
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PARTITION:
                    self.state = 2068
                    self.partitionSpec()


                self.state = 2074
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.IF:
                    self.state = 2071
                    self.match(fugue_sqlParser.IF)
                    self.state = 2072
                    self.match(fugue_sqlParser.NOT)
                    self.state = 2073
                    self.match(fugue_sqlParser.EXISTS)


                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.InsertOverwriteHiveDirContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2076
                self.match(fugue_sqlParser.INSERT)
                self.state = 2077
                self.match(fugue_sqlParser.OVERWRITE)
                self.state = 2079
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LOCAL:
                    self.state = 2078
                    self.match(fugue_sqlParser.LOCAL)


                self.state = 2081
                self.match(fugue_sqlParser.DIRECTORY)
                self.state = 2082
                localctx.path = self.match(fugue_sqlParser.STRING)
                self.state = 2084
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.ROW:
                    self.state = 2083
                    self.rowFormat()


                self.state = 2087
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.STORED:
                    self.state = 2086
                    self.createFileFormat()


                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.InsertOverwriteDirContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2089
                self.match(fugue_sqlParser.INSERT)
                self.state = 2090
                self.match(fugue_sqlParser.OVERWRITE)
                self.state = 2092
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LOCAL:
                    self.state = 2091
                    self.match(fugue_sqlParser.LOCAL)


                self.state = 2094
                self.match(fugue_sqlParser.DIRECTORY)
                self.state = 2096
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.STRING:
                    self.state = 2095
                    localctx.path = self.match(fugue_sqlParser.STRING)


                self.state = 2098
                self.tableProvider()
                self.state = 2101
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OPTIONS:
                    self.state = 2099
                    self.match(fugue_sqlParser.OPTIONS)
                    self.state = 2100
                    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(fugue_sqlParser.PartitionSpecContext,0)


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.PartitionSpecLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_partitionSpecLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2105
            self.partitionSpec()
            self.state = 2107
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.LOCATION:
                self.state = 2106
                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(fugue_sqlParser.PARTITION, 0)

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.PartitionSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_partitionSpec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2109
            self.match(fugue_sqlParser.PARTITION)
            self.state = 2110
            self.match(fugue_sqlParser.T__2)
            self.state = 2111
            self.partitionVal()
            self.state = 2116
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2112
                self.match(fugue_sqlParser.T__0)
                self.state = 2113
                self.partitionVal()
                self.state = 2118
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class 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(fugue_sqlParser.IdentifierContext,0)


        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.PartitionValContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_partitionVal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2121
            self.identifier()
            self.state = 2124
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.EQUAL:
                self.state = 2122
                self.match(fugue_sqlParser.EQUAL)
                self.state = 2123
                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(fugue_sqlParser.NAMESPACE, 0)

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

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_namespace)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2126
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.DATABASE or _la==fugue_sqlParser.NAMESPACE or _la==fugue_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(fugue_sqlParser.QualifiedNameContext,0)


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

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


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


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.DescribeFuncNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_describeFuncName)
        try:
            self.state = 2133
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2128
                self.qualifiedName()
                pass

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

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

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

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2132
                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(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.DescribeColNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_describeColName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2135
            localctx._identifier = self.identifier()
            localctx.nameParts.append(localctx._identifier)
            self.state = 2140
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__6:
                self.state = 2136
                self.match(fugue_sqlParser.T__6)
                self.state = 2137
                localctx._identifier = self.identifier()
                localctx.nameParts.append(localctx._identifier)
                self.state = 2142
                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(fugue_sqlParser.WITH, 0)

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.CtesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_ctes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2143
            self.match(fugue_sqlParser.WITH)
            self.state = 2144
            self.namedQuery()
            self.state = 2149
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2145
                self.match(fugue_sqlParser.T__0)
                self.state = 2146
                self.namedQuery()
                self.state = 2151
                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(fugue_sqlParser.QueryContext,0)


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


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

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NamedQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_namedQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2152
            localctx.name = self.errorCapturingIdentifier()
            self.state = 2154
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,264,self._ctx)
            if la_ == 1:
                self.state = 2153
                localctx.columnAliases = self.identifierList()


            self.state = 2157
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.AS:
                self.state = 2156
                self.match(fugue_sqlParser.AS)


            self.state = 2159
            self.match(fugue_sqlParser.T__2)
            self.state = 2160
            self.query()
            self.state = 2161
            self.match(fugue_sqlParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class 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(fugue_sqlParser.USING, 0)

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TableProviderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_tableProvider)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2163
            self.match(fugue_sqlParser.USING)
            self.state = 2164
            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(fugue_sqlParser.BucketSpecContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.BucketSpecContext,i)


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


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


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

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

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

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

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


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.CreateTableClausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_createTableClauses)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2178
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.CLUSTERED or _la==fugue_sqlParser.COMMENT or ((((_la - 180)) & ~0x3f) == 0 and ((1 << (_la - 180)) & ((1 << (fugue_sqlParser.LOCATION - 180)) | (1 << (fugue_sqlParser.OPTIONS - 180)) | (1 << (fugue_sqlParser.PARTITIONED - 180)))) != 0) or _la==fugue_sqlParser.TBLPROPERTIES:
                self.state = 2176
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [fugue_sqlParser.OPTIONS]:
                    self.state = 2166
                    self.match(fugue_sqlParser.OPTIONS)
                    self.state = 2167
                    localctx.options = self.tablePropertyList()
                    pass
                elif token in [fugue_sqlParser.PARTITIONED]:
                    self.state = 2168
                    self.match(fugue_sqlParser.PARTITIONED)
                    self.state = 2169
                    self.match(fugue_sqlParser.BY)
                    self.state = 2170
                    localctx.partitioning = self.transformList()
                    pass
                elif token in [fugue_sqlParser.CLUSTERED]:
                    self.state = 2171
                    self.bucketSpec()
                    pass
                elif token in [fugue_sqlParser.LOCATION]:
                    self.state = 2172
                    self.locationSpec()
                    pass
                elif token in [fugue_sqlParser.COMMENT]:
                    self.state = 2173
                    self.commentSpec()
                    pass
                elif token in [fugue_sqlParser.TBLPROPERTIES]:
                    self.state = 2174
                    self.match(fugue_sqlParser.TBLPROPERTIES)
                    self.state = 2175
                    localctx.tableProps = self.tablePropertyList()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2180
                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(fugue_sqlParser.TablePropertyContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TablePropertyContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TablePropertyListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_tablePropertyList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2181
            self.match(fugue_sqlParser.T__2)
            self.state = 2182
            self.tableProperty()
            self.state = 2187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2183
                self.match(fugue_sqlParser.T__0)
                self.state = 2184
                self.tableProperty()
                self.state = 2189
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class 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(fugue_sqlParser.TablePropertyKeyContext,0)


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


        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TablePropertyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_tableProperty)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2192
            localctx.key = self.tablePropertyKey()
            self.state = 2197
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.FALSE or ((((_la - 283)) & ~0x3f) == 0 and ((1 << (_la - 283)) & ((1 << (fugue_sqlParser.TRUE - 283)) | (1 << (fugue_sqlParser.EQUAL - 283)) | (1 << (fugue_sqlParser.STRING - 283)) | (1 << (fugue_sqlParser.INTEGER_VALUE - 283)) | (1 << (fugue_sqlParser.DECIMAL_VALUE - 283)))) != 0):
                self.state = 2194
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.EQUAL:
                    self.state = 2193
                    self.match(fugue_sqlParser.EQUAL)


                self.state = 2196
                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(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TablePropertyKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_tablePropertyKey)
        self._la = 0 # Token type
        try:
            self.state = 2208
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,272,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2199
                self.identifier()
                self.state = 2204
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__6:
                    self.state = 2200
                    self.match(fugue_sqlParser.T__6)
                    self.state = 2201
                    self.identifier()
                    self.state = 2206
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2207
                self.match(fugue_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(fugue_sqlParser.INTEGER_VALUE, 0)

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

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


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TablePropertyValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_tablePropertyValue)
        try:
            self.state = 2214
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.INTEGER_VALUE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2210
                self.match(fugue_sqlParser.INTEGER_VALUE)
                pass
            elif token in [fugue_sqlParser.DECIMAL_VALUE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2211
                self.match(fugue_sqlParser.DECIMAL_VALUE)
                pass
            elif token in [fugue_sqlParser.FALSE, fugue_sqlParser.TRUE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2212
                self.booleanValue()
                pass
            elif token in [fugue_sqlParser.STRING]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2213
                self.match(fugue_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(fugue_sqlParser.ConstantContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ConstantContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ConstantListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_constantList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2216
            self.match(fugue_sqlParser.T__2)
            self.state = 2217
            self.constant()
            self.state = 2222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2218
                self.match(fugue_sqlParser.T__0)
                self.state = 2219
                self.constant()
                self.state = 2224
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class 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(fugue_sqlParser.ConstantListContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ConstantListContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NestedConstantListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_nestedConstantList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2227
            self.match(fugue_sqlParser.T__2)
            self.state = 2228
            self.constantList()
            self.state = 2233
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2229
                self.match(fugue_sqlParser.T__0)
                self.state = 2230
                self.constantList()
                self.state = 2235
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class 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(fugue_sqlParser.STORED, 0)

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

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


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

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.CreateFileFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_createFileFormat)
        try:
            self.state = 2244
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,276,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2238
                self.match(fugue_sqlParser.STORED)
                self.state = 2239
                self.match(fugue_sqlParser.AS)
                self.state = 2240
                self.fileFormat()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2241
                self.match(fugue_sqlParser.STORED)
                self.state = 2242
                self.match(fugue_sqlParser.BY)
                self.state = 2243
                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 fugue_sqlParser.RULE_fileFormat

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



    class TableFileFormatContext(FileFormatContext):

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

        def INPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.INPUTFORMAT, 0)
        def OUTPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.OUTPUTFORMAT, 0)
        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.STRING)
            else:
                return self.getToken(fugue_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 fugue_sqlParser.FileFormatContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.FileFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_fileFormat)
        try:
            self.state = 2251
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,277,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.TableFileFormatContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2246
                self.match(fugue_sqlParser.INPUTFORMAT)
                self.state = 2247
                localctx.inFmt = self.match(fugue_sqlParser.STRING)
                self.state = 2248
                self.match(fugue_sqlParser.OUTPUTFORMAT)
                self.state = 2249
                localctx.outFmt = self.match(fugue_sqlParser.STRING)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.GenericFileFormatContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2250
                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(fugue_sqlParser.STRING, 0)

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

        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.StorageHandlerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_storageHandler)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2253
            self.match(fugue_sqlParser.STRING)
            self.state = 2257
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,278,self._ctx)
            if la_ == 1:
                self.state = 2254
                self.match(fugue_sqlParser.WITH)
                self.state = 2255
                self.match(fugue_sqlParser.SERDEPROPERTIES)
                self.state = 2256
                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(fugue_sqlParser.IdentifierContext,0)


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ResourceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_resource)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2259
            self.identifier()
            self.state = 2260
            self.match(fugue_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 fugue_sqlParser.RULE_dmlStatementNoWith

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



    class DeleteFromTableContext(DmlStatementNoWithContext):

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

        def DELETE(self):
            return self.getToken(fugue_sqlParser.DELETE, 0)
        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def whereClause(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def insertInto(self):
            return self.getTypedRuleContext(fugue_sqlParser.InsertIntoContext,0)

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

        def queryOrganization(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def multiInsertQueryBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultiInsertQueryBodyContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def UPDATE(self):
            return self.getToken(fugue_sqlParser.UPDATE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def setClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.SetClauseContext,0)

        def whereClause(self):
            return self.getTypedRuleContext(fugue_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 fugue_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(fugue_sqlParser.MERGE, 0)
        def INTO(self):
            return self.getToken(fugue_sqlParser.INTO, 0)
        def USING(self):
            return self.getToken(fugue_sqlParser.USING, 0)
        def ON(self):
            return self.getToken(fugue_sqlParser.ON, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,i)

        def tableAlias(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TableAliasContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,i)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)

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

        def matchedClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MatchedClauseContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MatchedClauseContext,i)

        def notMatchedClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NotMatchedClauseContext)
            else:
                return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.DmlStatementNoWithContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_dmlStatementNoWith)
        self._la = 0 # Token type
        try:
            self.state = 2313
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.INSERT]:
                localctx = fugue_sqlParser.SingleInsertQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2262
                self.insertInto()
                self.state = 2263
                self.queryTerm(0)
                self.state = 2264
                self.queryOrganization()
                pass
            elif token in [fugue_sqlParser.FROM]:
                localctx = fugue_sqlParser.MultiInsertQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2266
                self.fromClause()
                self.state = 2268 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2267
                    self.multiInsertQueryBody()
                    self.state = 2270 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==fugue_sqlParser.INSERT):
                        break

                pass
            elif token in [fugue_sqlParser.DELETE]:
                localctx = fugue_sqlParser.DeleteFromTableContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2272
                self.match(fugue_sqlParser.DELETE)
                self.state = 2273
                self.match(fugue_sqlParser.FROM)
                self.state = 2274
                self.multipartIdentifier()
                self.state = 2275
                self.tableAlias()
                self.state = 2277
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.WHERE:
                    self.state = 2276
                    self.whereClause()


                pass
            elif token in [fugue_sqlParser.UPDATE]:
                localctx = fugue_sqlParser.UpdateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2279
                self.match(fugue_sqlParser.UPDATE)
                self.state = 2280
                self.multipartIdentifier()
                self.state = 2281
                self.tableAlias()
                self.state = 2282
                self.setClause()
                self.state = 2284
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.WHERE:
                    self.state = 2283
                    self.whereClause()


                pass
            elif token in [fugue_sqlParser.MERGE]:
                localctx = fugue_sqlParser.MergeIntoTableContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2286
                self.match(fugue_sqlParser.MERGE)
                self.state = 2287
                self.match(fugue_sqlParser.INTO)
                self.state = 2288
                localctx.target = self.multipartIdentifier()
                self.state = 2289
                localctx.targetAlias = self.tableAlias()
                self.state = 2290
                self.match(fugue_sqlParser.USING)
                self.state = 2296
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,282,self._ctx)
                if la_ == 1:
                    self.state = 2291
                    localctx.source = self.multipartIdentifier()
                    pass

                elif la_ == 2:
                    self.state = 2292
                    self.match(fugue_sqlParser.T__2)
                    self.state = 2293
                    localctx.sourceQuery = self.query()
                    self.state = 2294
                    self.match(fugue_sqlParser.T__3)
                    pass


                self.state = 2298
                localctx.sourceAlias = self.tableAlias()
                self.state = 2299
                self.match(fugue_sqlParser.ON)
                self.state = 2300
                localctx.mergeCondition = self.booleanExpression(0)
                self.state = 2304
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,283,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2301
                        self.matchedClause() 
                    self.state = 2306
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,283,self._ctx)

                self.state = 2310
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.WHEN:
                    self.state = 2307
                    self.notMatchedClause()
                    self.state = 2312
                    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(fugue_sqlParser.ORDER, 0)

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

        def CLUSTER(self):
            return self.getToken(fugue_sqlParser.CLUSTER, 0)

        def DISTRIBUTE(self):
            return self.getToken(fugue_sqlParser.DISTRIBUTE, 0)

        def SORT(self):
            return self.getToken(fugue_sqlParser.SORT, 0)

        def windowClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowClauseContext,0)


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

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.SortItemContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.SortItemContext,i)


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


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.QueryOrganizationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_queryOrganization)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2325
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,287,self._ctx)
            if la_ == 1:
                self.state = 2315
                self.match(fugue_sqlParser.ORDER)
                self.state = 2316
                self.match(fugue_sqlParser.BY)
                self.state = 2317
                localctx._sortItem = self.sortItem()
                localctx.order.append(localctx._sortItem)
                self.state = 2322
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,286,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2318
                        self.match(fugue_sqlParser.T__0)
                        self.state = 2319
                        localctx._sortItem = self.sortItem()
                        localctx.order.append(localctx._sortItem) 
                    self.state = 2324
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,286,self._ctx)



            self.state = 2337
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
            if la_ == 1:
                self.state = 2327
                self.match(fugue_sqlParser.CLUSTER)
                self.state = 2328
                self.match(fugue_sqlParser.BY)
                self.state = 2329
                localctx._expression = self.expression()
                localctx.clusterBy.append(localctx._expression)
                self.state = 2334
                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 = 2330
                        self.match(fugue_sqlParser.T__0)
                        self.state = 2331
                        localctx._expression = self.expression()
                        localctx.clusterBy.append(localctx._expression) 
                    self.state = 2336
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,288,self._ctx)



            self.state = 2349
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,291,self._ctx)
            if la_ == 1:
                self.state = 2339
                self.match(fugue_sqlParser.DISTRIBUTE)
                self.state = 2340
                self.match(fugue_sqlParser.BY)
                self.state = 2341
                localctx._expression = self.expression()
                localctx.distributeBy.append(localctx._expression)
                self.state = 2346
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,290,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2342
                        self.match(fugue_sqlParser.T__0)
                        self.state = 2343
                        localctx._expression = self.expression()
                        localctx.distributeBy.append(localctx._expression) 
                    self.state = 2348
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,290,self._ctx)



            self.state = 2361
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,293,self._ctx)
            if la_ == 1:
                self.state = 2351
                self.match(fugue_sqlParser.SORT)
                self.state = 2352
                self.match(fugue_sqlParser.BY)
                self.state = 2353
                localctx._sortItem = self.sortItem()
                localctx.sort.append(localctx._sortItem)
                self.state = 2358
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,292,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2354
                        self.match(fugue_sqlParser.T__0)
                        self.state = 2355
                        localctx._sortItem = self.sortItem()
                        localctx.sort.append(localctx._sortItem) 
                    self.state = 2360
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,292,self._ctx)



            self.state = 2364
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,294,self._ctx)
            if la_ == 1:
                self.state = 2363
                self.windowClause()


            self.state = 2371
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,296,self._ctx)
            if la_ == 1:
                self.state = 2366
                self.match(fugue_sqlParser.LIMIT)
                self.state = 2369
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,295,self._ctx)
                if la_ == 1:
                    self.state = 2367
                    self.match(fugue_sqlParser.ALL)
                    pass

                elif la_ == 2:
                    self.state = 2368
                    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(fugue_sqlParser.InsertIntoContext,0)


        def fromStatementBody(self):
            return self.getTypedRuleContext(fugue_sqlParser.FromStatementBodyContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.MultiInsertQueryBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_multiInsertQueryBody)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2373
            self.insertInto()
            self.state = 2374
            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 fugue_sqlParser.RULE_queryTerm

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


    class QueryTermDefaultContext(QueryTermContext):

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

        def queryPrimary(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryPrimaryContext,0)


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


    class FugueTermContext(QueryTermContext):

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

        def fugueNestableTaskCollectionNoSelect(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueNestableTaskCollectionNoSelectContext,0)


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


    class SetOperationContext(QueryTermContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_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(fugue_sqlParser.QueryTermContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.QueryTermContext,i)

        def INTERSECT(self):
            return self.getToken(fugue_sqlParser.INTERSECT, 0)
        def UNION(self):
            return self.getToken(fugue_sqlParser.UNION, 0)
        def EXCEPT(self):
            return self.getToken(fugue_sqlParser.EXCEPT, 0)
        def SETMINUS(self):
            return self.getToken(fugue_sqlParser.SETMINUS, 0)
        def setQuantifier(self):
            return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.QueryTermContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 228
        self.enterRecursionRule(localctx, 228, self.RULE_queryTerm, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2379
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.FROM, fugue_sqlParser.MAP, fugue_sqlParser.REDUCE, fugue_sqlParser.SELECT, fugue_sqlParser.TABLE, fugue_sqlParser.VALUES]:
                localctx = fugue_sqlParser.QueryTermDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2377
                self.queryPrimary()
                pass
            elif token in [fugue_sqlParser.FILL, fugue_sqlParser.TAKE, fugue_sqlParser.PROCESS, fugue_sqlParser.ZIP, fugue_sqlParser.SAVE, fugue_sqlParser.SAMPLE, fugue_sqlParser.ALTER, fugue_sqlParser.CREATE, fugue_sqlParser.DROP, fugue_sqlParser.LOAD, fugue_sqlParser.RENAME, fugue_sqlParser.TRANSFORM]:
                localctx = fugue_sqlParser.FugueTermContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2378
                self.fugueNestableTaskCollectionNoSelect()
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 2404
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,302,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 = 2402
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,301,self._ctx)
                    if la_ == 1:
                        localctx = fugue_sqlParser.SetOperationContext(self, fugue_sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 2381
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 2382
                        if not fugue_sqlParser.legacy_setops_precedence_enbled:
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "fugue_sqlParser.legacy_setops_precedence_enbled")
                        self.state = 2383
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==fugue_sqlParser.EXCEPT or _la==fugue_sqlParser.INTERSECT or _la==fugue_sqlParser.SETMINUS or _la==fugue_sqlParser.UNION):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2385
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==fugue_sqlParser.ALL or _la==fugue_sqlParser.DISTINCT:
                            self.state = 2384
                            self.setQuantifier()


                        self.state = 2387
                        localctx.right = self.queryTerm(4)
                        pass

                    elif la_ == 2:
                        localctx = fugue_sqlParser.SetOperationContext(self, fugue_sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 2388
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 2389
                        if not not fugue_sqlParser.legacy_setops_precedence_enbled:
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "not fugue_sqlParser.legacy_setops_precedence_enbled")
                        self.state = 2390
                        localctx.operator = self.match(fugue_sqlParser.INTERSECT)
                        self.state = 2392
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==fugue_sqlParser.ALL or _la==fugue_sqlParser.DISTINCT:
                            self.state = 2391
                            self.setQuantifier()


                        self.state = 2394
                        localctx.right = self.queryTerm(3)
                        pass

                    elif la_ == 3:
                        localctx = fugue_sqlParser.SetOperationContext(self, fugue_sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 2395
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 2396
                        if not not fugue_sqlParser.legacy_setops_precedence_enbled:
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "not fugue_sqlParser.legacy_setops_precedence_enbled")
                        self.state = 2397
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==fugue_sqlParser.EXCEPT or _la==fugue_sqlParser.SETMINUS or _la==fugue_sqlParser.UNION):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2399
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==fugue_sqlParser.ALL or _la==fugue_sqlParser.DISTINCT:
                            self.state = 2398
                            self.setQuantifier()


                        self.state = 2401
                        localctx.right = self.queryTerm(2)
                        pass

             
                self.state = 2406
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,302,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 fugue_sqlParser.RULE_queryPrimary

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



    class QueryPrimaryDefaultContext(QueryPrimaryContext):

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

        def querySpecification(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def inlineTable(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def fromStatement(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.QueryPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_queryPrimary)
        try:
            self.state = 2412
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.MAP, fugue_sqlParser.REDUCE, fugue_sqlParser.SELECT]:
                localctx = fugue_sqlParser.QueryPrimaryDefaultContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2407
                self.querySpecification()
                pass
            elif token in [fugue_sqlParser.FROM]:
                localctx = fugue_sqlParser.FromStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2408
                self.fromStatement()
                pass
            elif token in [fugue_sqlParser.TABLE]:
                localctx = fugue_sqlParser.TableContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2409
                self.match(fugue_sqlParser.TABLE)
                self.state = 2410
                self.multipartIdentifier()
                pass
            elif token in [fugue_sqlParser.VALUES]:
                localctx = fugue_sqlParser.InlineTableDefault1Context(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2411
                self.inlineTable()
                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(fugue_sqlParser.ExpressionContext,0)


        def NULLS(self):
            return self.getToken(fugue_sqlParser.NULLS, 0)

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

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

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SortItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_sortItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2414
            self.expression()
            self.state = 2416
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,304,self._ctx)
            if la_ == 1:
                self.state = 2415
                localctx.ordering = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.ASC or _la==fugue_sqlParser.DESC):
                    localctx.ordering = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2420
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,305,self._ctx)
            if la_ == 1:
                self.state = 2418
                self.match(fugue_sqlParser.NULLS)
                self.state = 2419
                localctx.nullOrder = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.FIRST or _la==fugue_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(fugue_sqlParser.FromClauseContext,0)


        def fromStatementBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FromStatementBodyContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FromStatementBodyContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.FromStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_fromStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2422
            self.fromClause()
            self.state = 2424 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2423
                    self.fromStatementBody()

                else:
                    raise NoViableAltException(self)
                self.state = 2426 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,306,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(fugue_sqlParser.TransformClauseContext,0)


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


        def whereClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WhereClauseContext,0)


        def selectClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.SelectClauseContext,0)


        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.LateralViewContext,i)


        def aggregationClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.AggregationClauseContext,0)


        def havingClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.HavingClauseContext,0)


        def windowClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowClauseContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.FromStatementBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_fromStatementBody)
        try:
            self.state = 2455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,313,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2428
                self.transformClause()
                self.state = 2430
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,307,self._ctx)
                if la_ == 1:
                    self.state = 2429
                    self.whereClause()


                self.state = 2432
                self.queryOrganization()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2434
                self.selectClause()
                self.state = 2438
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,308,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2435
                        self.lateralView() 
                    self.state = 2440
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,308,self._ctx)

                self.state = 2442
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,309,self._ctx)
                if la_ == 1:
                    self.state = 2441
                    self.whereClause()


                self.state = 2445
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,310,self._ctx)
                if la_ == 1:
                    self.state = 2444
                    self.aggregationClause()


                self.state = 2448
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,311,self._ctx)
                if la_ == 1:
                    self.state = 2447
                    self.havingClause()


                self.state = 2451
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,312,self._ctx)
                if la_ == 1:
                    self.state = 2450
                    self.windowClause()


                self.state = 2453
                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 fugue_sqlParser.RULE_querySpecification

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



    class RegularQuerySpecificationContext(QuerySpecificationContext):

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

        def selectClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.SelectClauseContext,0)

        def optionalFromClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.OptionalFromClauseContext,0)

        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.LateralViewContext,i)

        def whereClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WhereClauseContext,0)

        def aggregationClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.AggregationClauseContext,0)

        def havingClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.HavingClauseContext,0)

        def windowClause(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.QuerySpecificationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def transformClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.TransformClauseContext,0)

        def optionalFromClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.OptionalFromClauseContext,0)

        def whereClause(self):
            return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.QuerySpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_querySpecification)
        try:
            self.state = 2482
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,320,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.TransformQuerySpecificationContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2457
                self.transformClause()
                self.state = 2458
                self.optionalFromClause()
                self.state = 2460
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,314,self._ctx)
                if la_ == 1:
                    self.state = 2459
                    self.whereClause()


                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.RegularQuerySpecificationContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2462
                self.selectClause()
                self.state = 2463
                self.optionalFromClause()
                self.state = 2467
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,315,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2464
                        self.lateralView() 
                    self.state = 2469
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,315,self._ctx)

                self.state = 2471
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,316,self._ctx)
                if la_ == 1:
                    self.state = 2470
                    self.whereClause()


                self.state = 2474
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,317,self._ctx)
                if la_ == 1:
                    self.state = 2473
                    self.aggregationClause()


                self.state = 2477
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,318,self._ctx)
                if la_ == 1:
                    self.state = 2476
                    self.havingClause()


                self.state = 2480
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,319,self._ctx)
                if la_ == 1:
                    self.state = 2479
                    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 OptionalFromClauseContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_optionalFromClause

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




    def optionalFromClause(self):

        localctx = fugue_sqlParser.OptionalFromClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_optionalFromClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2485
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,321,self._ctx)
            if la_ == 1:
                self.state = 2484
                self.fromClause()


        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(fugue_sqlParser.USING, 0)

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

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

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionSeqContext,0)


        def TRANSFORM(self):
            return self.getToken(fugue_sqlParser.TRANSFORM, 0)

        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)

        def REDUCE(self):
            return self.getToken(fugue_sqlParser.REDUCE, 0)

        def RECORDWRITER(self):
            return self.getToken(fugue_sqlParser.RECORDWRITER, 0)

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

        def RECORDREADER(self):
            return self.getToken(fugue_sqlParser.RECORDREADER, 0)

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


        def identifierSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierSeqContext,0)


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TransformClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_transformClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2497
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.SELECT]:
                self.state = 2487
                self.match(fugue_sqlParser.SELECT)
                self.state = 2488
                localctx.kind = self.match(fugue_sqlParser.TRANSFORM)
                self.state = 2489
                self.match(fugue_sqlParser.T__2)
                self.state = 2490
                self.namedExpressionSeq()
                self.state = 2491
                self.match(fugue_sqlParser.T__3)
                pass
            elif token in [fugue_sqlParser.MAP]:
                self.state = 2493
                localctx.kind = self.match(fugue_sqlParser.MAP)
                self.state = 2494
                self.namedExpressionSeq()
                pass
            elif token in [fugue_sqlParser.REDUCE]:
                self.state = 2495
                localctx.kind = self.match(fugue_sqlParser.REDUCE)
                self.state = 2496
                self.namedExpressionSeq()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 2500
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.ROW:
                self.state = 2499
                localctx.inRowFormat = self.rowFormat()


            self.state = 2504
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.RECORDWRITER:
                self.state = 2502
                self.match(fugue_sqlParser.RECORDWRITER)
                self.state = 2503
                localctx.recordWriter = self.match(fugue_sqlParser.STRING)


            self.state = 2506
            self.match(fugue_sqlParser.USING)
            self.state = 2507
            localctx.script = self.match(fugue_sqlParser.STRING)
            self.state = 2520
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,327,self._ctx)
            if la_ == 1:
                self.state = 2508
                self.match(fugue_sqlParser.AS)
                self.state = 2518
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,326,self._ctx)
                if la_ == 1:
                    self.state = 2509
                    self.identifierSeq()
                    pass

                elif la_ == 2:
                    self.state = 2510
                    self.colTypeList()
                    pass

                elif la_ == 3:
                    self.state = 2511
                    self.match(fugue_sqlParser.T__2)
                    self.state = 2514
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,325,self._ctx)
                    if la_ == 1:
                        self.state = 2512
                        self.identifierSeq()
                        pass

                    elif la_ == 2:
                        self.state = 2513
                        self.colTypeList()
                        pass


                    self.state = 2516
                    self.match(fugue_sqlParser.T__3)
                    pass




            self.state = 2523
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,328,self._ctx)
            if la_ == 1:
                self.state = 2522
                localctx.outRowFormat = self.rowFormat()


            self.state = 2527
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,329,self._ctx)
            if la_ == 1:
                self.state = 2525
                self.match(fugue_sqlParser.RECORDREADER)
                self.state = 2526
                localctx.recordReader = self.match(fugue_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(fugue_sqlParser.SELECT, 0)

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionSeqContext,0)


        def setQuantifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.SetQuantifierContext,0)


        def hint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.HintContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.HintContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SelectClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_selectClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2529
            self.match(fugue_sqlParser.SELECT)
            self.state = 2533
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,330,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2530
                    localctx._hint = self.hint()
                    localctx.hints.append(localctx._hint) 
                self.state = 2535
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,330,self._ctx)

            self.state = 2537
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,331,self._ctx)
            if la_ == 1:
                self.state = 2536
                self.setQuantifier()


            self.state = 2539
            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(fugue_sqlParser.SET, 0)

        def assignmentList(self):
            return self.getTypedRuleContext(fugue_sqlParser.AssignmentListContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SetClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_setClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2541
            self.match(fugue_sqlParser.SET)
            self.state = 2542
            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(fugue_sqlParser.WHEN, 0)

        def MATCHED(self):
            return self.getToken(fugue_sqlParser.MATCHED, 0)

        def THEN(self):
            return self.getToken(fugue_sqlParser.THEN, 0)

        def matchedAction(self):
            return self.getTypedRuleContext(fugue_sqlParser.MatchedActionContext,0)


        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.MatchedClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_matchedClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2544
            self.match(fugue_sqlParser.WHEN)
            self.state = 2545
            self.match(fugue_sqlParser.MATCHED)
            self.state = 2548
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.AND:
                self.state = 2546
                self.match(fugue_sqlParser.AND)
                self.state = 2547
                localctx.matchedCond = self.booleanExpression(0)


            self.state = 2550
            self.match(fugue_sqlParser.THEN)
            self.state = 2551
            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(fugue_sqlParser.WHEN, 0)

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

        def MATCHED(self):
            return self.getToken(fugue_sqlParser.MATCHED, 0)

        def THEN(self):
            return self.getToken(fugue_sqlParser.THEN, 0)

        def notMatchedAction(self):
            return self.getTypedRuleContext(fugue_sqlParser.NotMatchedActionContext,0)


        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NotMatchedClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_notMatchedClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2553
            self.match(fugue_sqlParser.WHEN)
            self.state = 2554
            self.match(fugue_sqlParser.NOT)
            self.state = 2555
            self.match(fugue_sqlParser.MATCHED)
            self.state = 2558
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.AND:
                self.state = 2556
                self.match(fugue_sqlParser.AND)
                self.state = 2557
                localctx.notMatchedCond = self.booleanExpression(0)


            self.state = 2560
            self.match(fugue_sqlParser.THEN)
            self.state = 2561
            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(fugue_sqlParser.DELETE, 0)

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

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

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)

        def assignmentList(self):
            return self.getTypedRuleContext(fugue_sqlParser.AssignmentListContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.MatchedActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_matchedAction)
        try:
            self.state = 2570
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,334,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2563
                self.match(fugue_sqlParser.DELETE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2564
                self.match(fugue_sqlParser.UPDATE)
                self.state = 2565
                self.match(fugue_sqlParser.SET)
                self.state = 2566
                self.match(fugue_sqlParser.ASTERISK)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2567
                self.match(fugue_sqlParser.UPDATE)
                self.state = 2568
                self.match(fugue_sqlParser.SET)
                self.state = 2569
                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(fugue_sqlParser.INSERT, 0)

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)

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

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


        def multipartIdentifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierListContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NotMatchedActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_notMatchedAction)
        self._la = 0 # Token type
        try:
            self.state = 2590
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,336,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2572
                self.match(fugue_sqlParser.INSERT)
                self.state = 2573
                self.match(fugue_sqlParser.ASTERISK)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2574
                self.match(fugue_sqlParser.INSERT)
                self.state = 2575
                self.match(fugue_sqlParser.T__2)
                self.state = 2576
                localctx.columns = self.multipartIdentifierList()
                self.state = 2577
                self.match(fugue_sqlParser.T__3)
                self.state = 2578
                self.match(fugue_sqlParser.VALUES)
                self.state = 2579
                self.match(fugue_sqlParser.T__2)
                self.state = 2580
                self.expression()
                self.state = 2585
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 2581
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2582
                    self.expression()
                    self.state = 2587
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2588
                self.match(fugue_sqlParser.T__3)
                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(fugue_sqlParser.AssignmentContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.AssignmentContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.AssignmentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_assignmentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2592
            self.assignment()
            self.state = 2597
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2593
                self.match(fugue_sqlParser.T__0)
                self.state = 2594
                self.assignment()
                self.state = 2599
                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 EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

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


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2600
            localctx.key = self.multipartIdentifier()
            self.state = 2601
            self.match(fugue_sqlParser.EQUAL)
            self.state = 2602
            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(fugue_sqlParser.WHERE, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.WhereClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_whereClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2604
            self.match(fugue_sqlParser.WHERE)
            self.state = 2605
            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(fugue_sqlParser.HAVING, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.HavingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_havingClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2607
            self.match(fugue_sqlParser.HAVING)
            self.state = 2608
            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(fugue_sqlParser.HintStatementContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.HintStatementContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.HintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_hint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2610
            self.match(fugue_sqlParser.T__13)
            self.state = 2611
            localctx._hintStatement = self.hintStatement()
            localctx.hintStatements.append(localctx._hintStatement)
            self.state = 2618
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,339,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2613
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,338,self._ctx)
                    if la_ == 1:
                        self.state = 2612
                        self.match(fugue_sqlParser.T__0)


                    self.state = 2615
                    localctx._hintStatement = self.hintStatement()
                    localctx.hintStatements.append(localctx._hintStatement) 
                self.state = 2620
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,339,self._ctx)

            self.state = 2621
            self.match(fugue_sqlParser.T__14)
        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(fugue_sqlParser.IdentifierContext,0)


        def primaryExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.PrimaryExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.PrimaryExpressionContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.HintStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_hintStatement)
        self._la = 0 # Token type
        try:
            self.state = 2636
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,341,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2623
                localctx.hintName = self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2624
                localctx.hintName = self.identifier()
                self.state = 2625
                self.match(fugue_sqlParser.T__2)
                self.state = 2626
                localctx._primaryExpression = self.primaryExpression(0)
                localctx.parameters.append(localctx._primaryExpression)
                self.state = 2631
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 2627
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2628
                    localctx._primaryExpression = self.primaryExpression(0)
                    localctx.parameters.append(localctx._primaryExpression)
                    self.state = 2633
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2634
                self.match(fugue_sqlParser.T__3)
                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(fugue_sqlParser.FROM, 0)

        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.RelationContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.RelationContext,i)


        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.LateralViewContext,i)


        def pivotClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.PivotClauseContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.FromClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_fromClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2638
            self.match(fugue_sqlParser.FROM)
            self.state = 2639
            self.relation()
            self.state = 2644
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,342,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2640
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2641
                    self.relation() 
                self.state = 2646
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,342,self._ctx)

            self.state = 2650
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,343,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2647
                    self.lateralView() 
                self.state = 2652
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,343,self._ctx)

            self.state = 2654
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,344,self._ctx)
            if la_ == 1:
                self.state = 2653
                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(fugue_sqlParser.GROUP, 0)

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

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


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

        def SETS(self):
            return self.getToken(fugue_sqlParser.SETS, 0)

        def groupingSet(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.GroupingSetContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.GroupingSetContext,i)


        def ROLLUP(self):
            return self.getToken(fugue_sqlParser.ROLLUP, 0)

        def CUBE(self):
            return self.getToken(fugue_sqlParser.CUBE, 0)

        def GROUPING(self):
            return self.getToken(fugue_sqlParser.GROUPING, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.AggregationClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_aggregationClause)
        self._la = 0 # Token type
        try:
            self.state = 2700
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,349,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2656
                self.match(fugue_sqlParser.GROUP)
                self.state = 2657
                self.match(fugue_sqlParser.BY)
                self.state = 2658
                localctx._expression = self.expression()
                localctx.groupingExpressions.append(localctx._expression)
                self.state = 2663
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,345,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2659
                        self.match(fugue_sqlParser.T__0)
                        self.state = 2660
                        localctx._expression = self.expression()
                        localctx.groupingExpressions.append(localctx._expression) 
                    self.state = 2665
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,345,self._ctx)

                self.state = 2683
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,347,self._ctx)
                if la_ == 1:
                    self.state = 2666
                    self.match(fugue_sqlParser.WITH)
                    self.state = 2667
                    localctx.kind = self.match(fugue_sqlParser.ROLLUP)

                elif la_ == 2:
                    self.state = 2668
                    self.match(fugue_sqlParser.WITH)
                    self.state = 2669
                    localctx.kind = self.match(fugue_sqlParser.CUBE)

                elif la_ == 3:
                    self.state = 2670
                    localctx.kind = self.match(fugue_sqlParser.GROUPING)
                    self.state = 2671
                    self.match(fugue_sqlParser.SETS)
                    self.state = 2672
                    self.match(fugue_sqlParser.T__2)
                    self.state = 2673
                    self.groupingSet()
                    self.state = 2678
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==fugue_sqlParser.T__0:
                        self.state = 2674
                        self.match(fugue_sqlParser.T__0)
                        self.state = 2675
                        self.groupingSet()
                        self.state = 2680
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2681
                    self.match(fugue_sqlParser.T__3)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2685
                self.match(fugue_sqlParser.GROUP)
                self.state = 2686
                self.match(fugue_sqlParser.BY)
                self.state = 2687
                localctx.kind = self.match(fugue_sqlParser.GROUPING)
                self.state = 2688
                self.match(fugue_sqlParser.SETS)
                self.state = 2689
                self.match(fugue_sqlParser.T__2)
                self.state = 2690
                self.groupingSet()
                self.state = 2695
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 2691
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2692
                    self.groupingSet()
                    self.state = 2697
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2698
                self.match(fugue_sqlParser.T__3)
                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(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.GroupingSetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_groupingSet)
        self._la = 0 # Token type
        try:
            self.state = 2715
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,352,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2702
                self.match(fugue_sqlParser.T__2)
                self.state = 2711
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,351,self._ctx)
                if la_ == 1:
                    self.state = 2703
                    self.expression()
                    self.state = 2708
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==fugue_sqlParser.T__0:
                        self.state = 2704
                        self.match(fugue_sqlParser.T__0)
                        self.state = 2705
                        self.expression()
                        self.state = 2710
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2713
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2714
                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(fugue_sqlParser.PIVOT, 0)

        def FOR(self):
            return self.getToken(fugue_sqlParser.FOR, 0)

        def pivotColumn(self):
            return self.getTypedRuleContext(fugue_sqlParser.PivotColumnContext,0)


        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionSeqContext,0)


        def pivotValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.PivotValueContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.PivotValueContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.PivotClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_pivotClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2717
            self.match(fugue_sqlParser.PIVOT)
            self.state = 2718
            self.match(fugue_sqlParser.T__2)
            self.state = 2719
            localctx.aggregates = self.namedExpressionSeq()
            self.state = 2720
            self.match(fugue_sqlParser.FOR)
            self.state = 2721
            self.pivotColumn()
            self.state = 2722
            self.match(fugue_sqlParser.IN)
            self.state = 2723
            self.match(fugue_sqlParser.T__2)
            self.state = 2724
            localctx._pivotValue = self.pivotValue()
            localctx.pivotValues.append(localctx._pivotValue)
            self.state = 2729
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2725
                self.match(fugue_sqlParser.T__0)
                self.state = 2726
                localctx._pivotValue = self.pivotValue()
                localctx.pivotValues.append(localctx._pivotValue)
                self.state = 2731
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class 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(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.PivotColumnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_pivotColumn)
        self._la = 0 # Token type
        try:
            self.state = 2747
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,355,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2735
                localctx._identifier = self.identifier()
                localctx.identifiers.append(localctx._identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2736
                self.match(fugue_sqlParser.T__2)
                self.state = 2737
                localctx._identifier = self.identifier()
                localctx.identifiers.append(localctx._identifier)
                self.state = 2742
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 2738
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2739
                    localctx._identifier = self.identifier()
                    localctx.identifiers.append(localctx._identifier)
                    self.state = 2744
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2745
                self.match(fugue_sqlParser.T__3)
                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(fugue_sqlParser.ExpressionContext,0)


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


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.PivotValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_pivotValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2749
            self.expression()
            self.state = 2754
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,357,self._ctx)
            if la_ == 1:
                self.state = 2751
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,356,self._ctx)
                if la_ == 1:
                    self.state = 2750
                    self.match(fugue_sqlParser.AS)


                self.state = 2753
                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(fugue_sqlParser.LATERAL, 0)

        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)

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


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


        def OUTER(self):
            return self.getToken(fugue_sqlParser.OUTER, 0)

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


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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.LateralViewContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_lateralView)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2756
            self.match(fugue_sqlParser.LATERAL)
            self.state = 2757
            self.match(fugue_sqlParser.VIEW)
            self.state = 2759
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,358,self._ctx)
            if la_ == 1:
                self.state = 2758
                self.match(fugue_sqlParser.OUTER)


            self.state = 2761
            self.qualifiedName()
            self.state = 2762
            self.match(fugue_sqlParser.T__2)
            self.state = 2771
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,360,self._ctx)
            if la_ == 1:
                self.state = 2763
                self.expression()
                self.state = 2768
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 2764
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2765
                    self.expression()
                    self.state = 2770
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 2773
            self.match(fugue_sqlParser.T__3)
            self.state = 2774
            localctx.tblName = self.identifier()
            self.state = 2786
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,363,self._ctx)
            if la_ == 1:
                self.state = 2776
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,361,self._ctx)
                if la_ == 1:
                    self.state = 2775
                    self.match(fugue_sqlParser.AS)


                self.state = 2778
                localctx._identifier = self.identifier()
                localctx.colName.append(localctx._identifier)
                self.state = 2783
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,362,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2779
                        self.match(fugue_sqlParser.T__0)
                        self.state = 2780
                        localctx._identifier = self.identifier()
                        localctx.colName.append(localctx._identifier) 
                    self.state = 2785
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,362,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(fugue_sqlParser.DISTINCT, 0)

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SetQuantifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_setQuantifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2788
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.ALL or _la==fugue_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(fugue_sqlParser.RelationPrimaryContext,0)


        def joinRelation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.JoinRelationContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.JoinRelationContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.RelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_relation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2790
            self.relationPrimary()
            self.state = 2794
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,364,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2791
                    self.joinRelation() 
                self.state = 2796
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,364,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(fugue_sqlParser.JOIN, 0)

        def relationPrimary(self):
            return self.getTypedRuleContext(fugue_sqlParser.RelationPrimaryContext,0)


        def joinType(self):
            return self.getTypedRuleContext(fugue_sqlParser.JoinTypeContext,0)


        def joinCriteria(self):
            return self.getTypedRuleContext(fugue_sqlParser.JoinCriteriaContext,0)


        def NATURAL(self):
            return self.getToken(fugue_sqlParser.NATURAL, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.JoinRelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_joinRelation)
        try:
            self.state = 2808
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.ANTI, fugue_sqlParser.CROSS, fugue_sqlParser.FULL, fugue_sqlParser.INNER, fugue_sqlParser.JOIN, fugue_sqlParser.LEFT, fugue_sqlParser.RIGHT, fugue_sqlParser.SEMI]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2797
                self.joinType()
                self.state = 2798
                self.match(fugue_sqlParser.JOIN)
                self.state = 2799
                localctx.right = self.relationPrimary()
                self.state = 2801
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,365,self._ctx)
                if la_ == 1:
                    self.state = 2800
                    self.joinCriteria()


                pass
            elif token in [fugue_sqlParser.NATURAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2803
                self.match(fugue_sqlParser.NATURAL)
                self.state = 2804
                self.joinType()
                self.state = 2805
                self.match(fugue_sqlParser.JOIN)
                self.state = 2806
                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(fugue_sqlParser.INNER, 0)

        def CROSS(self):
            return self.getToken(fugue_sqlParser.CROSS, 0)

        def LEFT(self):
            return self.getToken(fugue_sqlParser.LEFT, 0)

        def OUTER(self):
            return self.getToken(fugue_sqlParser.OUTER, 0)

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

        def RIGHT(self):
            return self.getToken(fugue_sqlParser.RIGHT, 0)

        def FULL(self):
            return self.getToken(fugue_sqlParser.FULL, 0)

        def ANTI(self):
            return self.getToken(fugue_sqlParser.ANTI, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.JoinTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_joinType)
        self._la = 0 # Token type
        try:
            self.state = 2834
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,373,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2811
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.INNER:
                    self.state = 2810
                    self.match(fugue_sqlParser.INNER)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2813
                self.match(fugue_sqlParser.CROSS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2814
                self.match(fugue_sqlParser.LEFT)
                self.state = 2816
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OUTER:
                    self.state = 2815
                    self.match(fugue_sqlParser.OUTER)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2819
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LEFT:
                    self.state = 2818
                    self.match(fugue_sqlParser.LEFT)


                self.state = 2821
                self.match(fugue_sqlParser.SEMI)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2822
                self.match(fugue_sqlParser.RIGHT)
                self.state = 2824
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OUTER:
                    self.state = 2823
                    self.match(fugue_sqlParser.OUTER)


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2826
                self.match(fugue_sqlParser.FULL)
                self.state = 2828
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.OUTER:
                    self.state = 2827
                    self.match(fugue_sqlParser.OUTER)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.LEFT:
                    self.state = 2830
                    self.match(fugue_sqlParser.LEFT)


                self.state = 2833
                self.match(fugue_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(fugue_sqlParser.ON, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


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

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.JoinCriteriaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_joinCriteria)
        try:
            self.state = 2840
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.ON]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2836
                self.match(fugue_sqlParser.ON)
                self.state = 2837
                self.booleanExpression(0)
                pass
            elif token in [fugue_sqlParser.USING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2838
                self.match(fugue_sqlParser.USING)
                self.state = 2839
                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(fugue_sqlParser.TABLESAMPLE, 0)

        def sampleMethod(self):
            return self.getTypedRuleContext(fugue_sqlParser.SampleMethodContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.SampleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_sample)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2842
            self.match(fugue_sqlParser.TABLESAMPLE)
            self.state = 2843
            self.match(fugue_sqlParser.T__2)
            self.state = 2845
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,375,self._ctx)
            if la_ == 1:
                self.state = 2844
                self.sampleMethod()


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


    class SampleMethodContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_sampleMethod

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



    class SampleByRowsContext(SampleMethodContext):

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

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

        def ROWS(self):
            return self.getToken(fugue_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 fugue_sqlParser.SampleMethodContext
            super().__init__(parser)
            self.negativeSign = None # Token
            self.percentage = None # Token
            self.copyFrom(ctx)

        def PERCENTLIT(self):
            return self.getToken(fugue_sqlParser.PERCENTLIT, 0)
        def INTEGER_VALUE(self):
            return self.getToken(fugue_sqlParser.INTEGER_VALUE, 0)
        def DECIMAL_VALUE(self):
            return self.getToken(fugue_sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_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(fugue_sqlParser.OUT, 0)
        def OF(self):
            return self.getToken(fugue_sqlParser.OF, 0)
        def BUCKET(self):
            return self.getToken(fugue_sqlParser.BUCKET, 0)
        def INTEGER_VALUE(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.INTEGER_VALUE)
            else:
                return self.getToken(fugue_sqlParser.INTEGER_VALUE, i)
        def ON(self):
            return self.getToken(fugue_sqlParser.ON, 0)
        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)

        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.SampleMethodContext
            super().__init__(parser)
            self.bytes = None # ExpressionContext
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.SampleMethodContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_sampleMethod)
        self._la = 0 # Token type
        try:
            self.state = 2873
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,379,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.SampleByPercentileContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2850
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 2849
                    localctx.negativeSign = self.match(fugue_sqlParser.MINUS)


                self.state = 2852
                localctx.percentage = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.INTEGER_VALUE or _la==fugue_sqlParser.DECIMAL_VALUE):
                    localctx.percentage = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2853
                self.match(fugue_sqlParser.PERCENTLIT)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.SampleByRowsContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2854
                self.expression()
                self.state = 2855
                self.match(fugue_sqlParser.ROWS)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.SampleByBucketContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2857
                localctx.sampleType = self.match(fugue_sqlParser.BUCKET)
                self.state = 2858
                localctx.numerator = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 2859
                self.match(fugue_sqlParser.OUT)
                self.state = 2860
                self.match(fugue_sqlParser.OF)
                self.state = 2861
                localctx.denominator = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 2870
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.ON:
                    self.state = 2862
                    self.match(fugue_sqlParser.ON)
                    self.state = 2868
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,377,self._ctx)
                    if la_ == 1:
                        self.state = 2863
                        self.identifier()
                        pass

                    elif la_ == 2:
                        self.state = 2864
                        self.qualifiedName()
                        self.state = 2865
                        self.match(fugue_sqlParser.T__2)
                        self.state = 2866
                        self.match(fugue_sqlParser.T__3)
                        pass




                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.SampleByBytesContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2872
                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(fugue_sqlParser.IdentifierSeqContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_identifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2875
            self.match(fugue_sqlParser.T__2)
            self.state = 2876
            self.identifierSeq()
            self.state = 2877
            self.match(fugue_sqlParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class 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(fugue_sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.IdentifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_identifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2879
            localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
            localctx.ident.append(localctx._errorCapturingIdentifier)
            self.state = 2884
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,380,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2880
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2881
                    localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
                    localctx.ident.append(localctx._errorCapturingIdentifier) 
                self.state = 2886
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,380,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(fugue_sqlParser.OrderedIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.OrderedIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.OrderedIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_orderedIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2887
            self.match(fugue_sqlParser.T__2)
            self.state = 2888
            self.orderedIdentifier()
            self.state = 2893
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2889
                self.match(fugue_sqlParser.T__0)
                self.state = 2890
                self.orderedIdentifier()
                self.state = 2895
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class 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(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


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

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.OrderedIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_orderedIdentifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2898
            localctx.ident = self.errorCapturingIdentifier()
            self.state = 2900
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.ASC or _la==fugue_sqlParser.DESC:
                self.state = 2899
                localctx.ordering = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.ASC or _la==fugue_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(fugue_sqlParser.IdentifierCommentContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierCommentContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.IdentifierCommentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_identifierCommentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2902
            self.match(fugue_sqlParser.T__2)
            self.state = 2903
            self.identifierComment()
            self.state = 2908
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 2904
                self.match(fugue_sqlParser.T__0)
                self.state = 2905
                self.identifierComment()
                self.state = 2910
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class 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(fugue_sqlParser.IdentifierContext,0)


        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.IdentifierCommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_identifierComment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2913
            self.identifier()
            self.state = 2915
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.COMMENT:
                self.state = 2914
                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 fugue_sqlParser.RULE_relationPrimary

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



    class TableValuedFunctionContext(RelationPrimaryContext):

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

        def functionTable(self):
            return self.getTypedRuleContext(fugue_sqlParser.FunctionTableContext,0)


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


    class InlineTableDefault2Context(RelationPrimaryContext):

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

        def inlineTable(self):
            return self.getTypedRuleContext(fugue_sqlParser.InlineTableContext,0)


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


    class AliasedRelationContext(RelationPrimaryContext):

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

        def relation(self):
            return self.getTypedRuleContext(fugue_sqlParser.RelationContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def sample(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def sample(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def fugueDataFrameMember(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameMemberContext,0)

        def sample(self):
            return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.RelationPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_relationPrimary)
        try:
            self.state = 2944
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,389,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.TableNameContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2917
                self.multipartIdentifier()
                self.state = 2919
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,385,self._ctx)
                if la_ == 1:
                    self.state = 2918
                    self.fugueDataFrameMember()


                self.state = 2922
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,386,self._ctx)
                if la_ == 1:
                    self.state = 2921
                    self.sample()


                self.state = 2924
                self.tableAlias()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.AliasedQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2926
                self.match(fugue_sqlParser.T__2)
                self.state = 2927
                self.query()
                self.state = 2928
                self.match(fugue_sqlParser.T__3)
                self.state = 2930
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,387,self._ctx)
                if la_ == 1:
                    self.state = 2929
                    self.sample()


                self.state = 2932
                self.tableAlias()
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.AliasedRelationContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2934
                self.match(fugue_sqlParser.T__2)
                self.state = 2935
                self.relation()
                self.state = 2936
                self.match(fugue_sqlParser.T__3)
                self.state = 2938
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,388,self._ctx)
                if la_ == 1:
                    self.state = 2937
                    self.sample()


                self.state = 2940
                self.tableAlias()
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.InlineTableDefault2Context(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2942
                self.inlineTable()
                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.TableValuedFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2943
                self.functionTable()
                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(fugue_sqlParser.VALUES, 0)

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


        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.InlineTableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_inlineTable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2946
            self.match(fugue_sqlParser.VALUES)
            self.state = 2947
            self.expression()
            self.state = 2952
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,390,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2948
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2949
                    self.expression() 
                self.state = 2954
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,390,self._ctx)

            self.state = 2955
            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(fugue_sqlParser.TableAliasContext,0)


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


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.FunctionTableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_functionTable)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2957
            localctx.funcName = self.errorCapturingIdentifier()
            self.state = 2958
            self.match(fugue_sqlParser.T__2)
            self.state = 2967
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,392,self._ctx)
            if la_ == 1:
                self.state = 2959
                self.expression()
                self.state = 2964
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 2960
                    self.match(fugue_sqlParser.T__0)
                    self.state = 2961
                    self.expression()
                    self.state = 2966
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 2969
            self.match(fugue_sqlParser.T__3)
            self.state = 2970
            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(fugue_sqlParser.StrictIdentifierContext,0)


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

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TableAliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_tableAlias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2979
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,395,self._ctx)
            if la_ == 1:
                self.state = 2973
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,393,self._ctx)
                if la_ == 1:
                    self.state = 2972
                    self.match(fugue_sqlParser.AS)


                self.state = 2975
                self.strictIdentifier()
                self.state = 2977
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,394,self._ctx)
                if la_ == 1:
                    self.state = 2976
                    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 fugue_sqlParser.RULE_rowFormat

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



    class RowFormatSerdeContext(RowFormatContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.RowFormatContext
            super().__init__(parser)
            self.name = None # Token
            self.props = None # TablePropertyListContext
            self.copyFrom(ctx)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)
        def FORMAT(self):
            return self.getToken(fugue_sqlParser.FORMAT, 0)
        def SERDE(self):
            return self.getToken(fugue_sqlParser.SERDE, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def WITH(self):
            return self.getToken(fugue_sqlParser.WITH, 0)
        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_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 fugue_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(fugue_sqlParser.ROW, 0)
        def FORMAT(self):
            return self.getToken(fugue_sqlParser.FORMAT, 0)
        def DELIMITED(self):
            return self.getToken(fugue_sqlParser.DELIMITED, 0)
        def FIELDS(self):
            return self.getToken(fugue_sqlParser.FIELDS, 0)
        def TERMINATED(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.TERMINATED)
            else:
                return self.getToken(fugue_sqlParser.TERMINATED, i)
        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.BY)
            else:
                return self.getToken(fugue_sqlParser.BY, i)
        def COLLECTION(self):
            return self.getToken(fugue_sqlParser.COLLECTION, 0)
        def ITEMS(self):
            return self.getToken(fugue_sqlParser.ITEMS, 0)
        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)
        def KEYS(self):
            return self.getToken(fugue_sqlParser.KEYS, 0)
        def LINES(self):
            return self.getToken(fugue_sqlParser.LINES, 0)
        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)
        def DEFINED(self):
            return self.getToken(fugue_sqlParser.DEFINED, 0)
        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)
        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.STRING)
            else:
                return self.getToken(fugue_sqlParser.STRING, i)
        def ESCAPED(self):
            return self.getToken(fugue_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 = fugue_sqlParser.RowFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_rowFormat)
        try:
            self.state = 3030
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,403,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.RowFormatSerdeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2981
                self.match(fugue_sqlParser.ROW)
                self.state = 2982
                self.match(fugue_sqlParser.FORMAT)
                self.state = 2983
                self.match(fugue_sqlParser.SERDE)
                self.state = 2984
                localctx.name = self.match(fugue_sqlParser.STRING)
                self.state = 2988
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,396,self._ctx)
                if la_ == 1:
                    self.state = 2985
                    self.match(fugue_sqlParser.WITH)
                    self.state = 2986
                    self.match(fugue_sqlParser.SERDEPROPERTIES)
                    self.state = 2987
                    localctx.props = self.tablePropertyList()


                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.RowFormatDelimitedContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2990
                self.match(fugue_sqlParser.ROW)
                self.state = 2991
                self.match(fugue_sqlParser.FORMAT)
                self.state = 2992
                self.match(fugue_sqlParser.DELIMITED)
                self.state = 3002
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,398,self._ctx)
                if la_ == 1:
                    self.state = 2993
                    self.match(fugue_sqlParser.FIELDS)
                    self.state = 2994
                    self.match(fugue_sqlParser.TERMINATED)
                    self.state = 2995
                    self.match(fugue_sqlParser.BY)
                    self.state = 2996
                    localctx.fieldsTerminatedBy = self.match(fugue_sqlParser.STRING)
                    self.state = 3000
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,397,self._ctx)
                    if la_ == 1:
                        self.state = 2997
                        self.match(fugue_sqlParser.ESCAPED)
                        self.state = 2998
                        self.match(fugue_sqlParser.BY)
                        self.state = 2999
                        localctx.escapedBy = self.match(fugue_sqlParser.STRING)




                self.state = 3009
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,399,self._ctx)
                if la_ == 1:
                    self.state = 3004
                    self.match(fugue_sqlParser.COLLECTION)
                    self.state = 3005
                    self.match(fugue_sqlParser.ITEMS)
                    self.state = 3006
                    self.match(fugue_sqlParser.TERMINATED)
                    self.state = 3007
                    self.match(fugue_sqlParser.BY)
                    self.state = 3008
                    localctx.collectionItemsTerminatedBy = self.match(fugue_sqlParser.STRING)


                self.state = 3016
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,400,self._ctx)
                if la_ == 1:
                    self.state = 3011
                    self.match(fugue_sqlParser.MAP)
                    self.state = 3012
                    self.match(fugue_sqlParser.KEYS)
                    self.state = 3013
                    self.match(fugue_sqlParser.TERMINATED)
                    self.state = 3014
                    self.match(fugue_sqlParser.BY)
                    self.state = 3015
                    localctx.keysTerminatedBy = self.match(fugue_sqlParser.STRING)


                self.state = 3022
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,401,self._ctx)
                if la_ == 1:
                    self.state = 3018
                    self.match(fugue_sqlParser.LINES)
                    self.state = 3019
                    self.match(fugue_sqlParser.TERMINATED)
                    self.state = 3020
                    self.match(fugue_sqlParser.BY)
                    self.state = 3021
                    localctx.linesSeparatedBy = self.match(fugue_sqlParser.STRING)


                self.state = 3028
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,402,self._ctx)
                if la_ == 1:
                    self.state = 3024
                    self.match(fugue_sqlParser.NULL)
                    self.state = 3025
                    self.match(fugue_sqlParser.DEFINED)
                    self.state = 3026
                    self.match(fugue_sqlParser.AS)
                    self.state = 3027
                    localctx.nullDefinedAs = self.match(fugue_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(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.MultipartIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_multipartIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3032
            self.multipartIdentifier()
            self.state = 3037
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 3033
                self.match(fugue_sqlParser.T__0)
                self.state = 3034
                self.multipartIdentifier()
                self.state = 3039
                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(fugue_sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.MultipartIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_multipartIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3040
            localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
            localctx.parts.append(localctx._errorCapturingIdentifier)
            self.state = 3045
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,405,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3041
                    self.match(fugue_sqlParser.T__6)
                    self.state = 3042
                    localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
                    localctx.parts.append(localctx._errorCapturingIdentifier) 
                self.state = 3047
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,405,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(fugue_sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TableIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_tableIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3051
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,406,self._ctx)
            if la_ == 1:
                self.state = 3048
                localctx.db = self.errorCapturingIdentifier()
                self.state = 3049
                self.match(fugue_sqlParser.T__6)


            self.state = 3053
            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(fugue_sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.FunctionIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_functionIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3058
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,407,self._ctx)
            if la_ == 1:
                self.state = 3055
                localctx.db = self.errorCapturingIdentifier()
                self.state = 3056
                self.match(fugue_sqlParser.T__6)


            self.state = 3060
            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(fugue_sqlParser.ExpressionContext,0)


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


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

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NamedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_namedExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3062
            self.expression()
            self.state = 3070
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,410,self._ctx)
            if la_ == 1:
                self.state = 3064
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,408,self._ctx)
                if la_ == 1:
                    self.state = 3063
                    self.match(fugue_sqlParser.AS)


                self.state = 3068
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,409,self._ctx)
                if la_ == 1:
                    self.state = 3066
                    localctx.name = self.errorCapturingIdentifier()
                    pass

                elif la_ == 2:
                    self.state = 3067
                    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(fugue_sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NamedExpressionSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_namedExpressionSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3072
            self.namedExpression()
            self.state = 3077
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,411,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3073
                    self.match(fugue_sqlParser.T__0)
                    self.state = 3074
                    self.namedExpression() 
                self.state = 3079
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,411,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(fugue_sqlParser.TransformContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TransformContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TransformListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_transformList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3080
            self.match(fugue_sqlParser.T__2)
            self.state = 3081
            localctx._transform = self.transform()
            localctx.transforms.append(localctx._transform)
            self.state = 3086
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 3082
                self.match(fugue_sqlParser.T__0)
                self.state = 3083
                localctx._transform = self.transform()
                localctx.transforms.append(localctx._transform)
                self.state = 3088
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class TransformContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_transform

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



    class IdentityTransformContext(TransformContext):

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

        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_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 fugue_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(fugue_sqlParser.IdentifierContext,0)

        def transformArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TransformArgumentContext)
            else:
                return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.TransformContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_transform)
        self._la = 0 # Token type
        try:
            self.state = 3104
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,414,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.IdentityTransformContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3091
                self.qualifiedName()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.ApplyTransformContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3092
                localctx.transformName = self.identifier()
                self.state = 3093
                self.match(fugue_sqlParser.T__2)
                self.state = 3094
                localctx._transformArgument = self.transformArgument()
                localctx.argument.append(localctx._transformArgument)
                self.state = 3099
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 3095
                    self.match(fugue_sqlParser.T__0)
                    self.state = 3096
                    localctx._transformArgument = self.transformArgument()
                    localctx.argument.append(localctx._transformArgument)
                    self.state = 3101
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 3102
                self.match(fugue_sqlParser.T__3)
                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(fugue_sqlParser.QualifiedNameContext,0)


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.TransformArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_transformArgument)
        try:
            self.state = 3108
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,415,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3106
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3107
                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(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3110
            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 fugue_sqlParser.RULE_booleanExpression

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


    class LogicalNotContext(BooleanExpressionContext):

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

        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.BooleanExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def valueExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,0)

        def predicate(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.BooleanExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def query(self):
            return self.getTypedRuleContext(fugue_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 fugue_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(fugue_sqlParser.BooleanExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,i)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)
        def OR(self):
            return self.getToken(fugue_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 = fugue_sqlParser.BooleanExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 338
        self.enterRecursionRule(localctx, 338, self.RULE_booleanExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3124
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,417,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.LogicalNotContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 3113
                self.match(fugue_sqlParser.NOT)
                self.state = 3114
                self.booleanExpression(5)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.ExistsContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3115
                self.match(fugue_sqlParser.EXISTS)
                self.state = 3116
                self.match(fugue_sqlParser.T__2)
                self.state = 3117
                self.query()
                self.state = 3118
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.PredicatedContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3120
                self.valueExpression(0)
                self.state = 3122
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,416,self._ctx)
                if la_ == 1:
                    self.state = 3121
                    self.predicate()


                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 3134
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,419,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 = 3132
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,418,self._ctx)
                    if la_ == 1:
                        localctx = fugue_sqlParser.LogicalBinaryContext(self, fugue_sqlParser.BooleanExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpression)
                        self.state = 3126
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 3127
                        localctx.operator = self.match(fugue_sqlParser.AND)
                        self.state = 3128
                        localctx.right = self.booleanExpression(3)
                        pass

                    elif la_ == 2:
                        localctx = fugue_sqlParser.LogicalBinaryContext(self, fugue_sqlParser.BooleanExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpression)
                        self.state = 3129
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 3130
                        localctx.operator = self.match(fugue_sqlParser.OR)
                        self.state = 3131
                        localctx.right = self.booleanExpression(2)
                        pass

             
                self.state = 3136
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,419,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(fugue_sqlParser.AND, 0)

        def BETWEEN(self):
            return self.getToken(fugue_sqlParser.BETWEEN, 0)

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)


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

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


        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)

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


        def RLIKE(self):
            return self.getToken(fugue_sqlParser.RLIKE, 0)

        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)

        def ANY(self):
            return self.getToken(fugue_sqlParser.ANY, 0)

        def SOME(self):
            return self.getToken(fugue_sqlParser.SOME, 0)

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

        def ESCAPE(self):
            return self.getToken(fugue_sqlParser.ESCAPE, 0)

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

        def IS(self):
            return self.getToken(fugue_sqlParser.IS, 0)

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

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

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

        def UNKNOWN(self):
            return self.getToken(fugue_sqlParser.UNKNOWN, 0)

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

        def DISTINCT(self):
            return self.getToken(fugue_sqlParser.DISTINCT, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.PredicateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_predicate)
        self._la = 0 # Token type
        try:
            self.state = 3219
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,433,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3138
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3137
                    self.match(fugue_sqlParser.NOT)


                self.state = 3140
                localctx.kind = self.match(fugue_sqlParser.BETWEEN)
                self.state = 3141
                localctx.lower = self.valueExpression(0)
                self.state = 3142
                self.match(fugue_sqlParser.AND)
                self.state = 3143
                localctx.upper = self.valueExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3146
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3145
                    self.match(fugue_sqlParser.NOT)


                self.state = 3148
                localctx.kind = self.match(fugue_sqlParser.IN)
                self.state = 3149
                self.match(fugue_sqlParser.T__2)
                self.state = 3150
                self.expression()
                self.state = 3155
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==fugue_sqlParser.T__0:
                    self.state = 3151
                    self.match(fugue_sqlParser.T__0)
                    self.state = 3152
                    self.expression()
                    self.state = 3157
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 3158
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3161
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3160
                    self.match(fugue_sqlParser.NOT)


                self.state = 3163
                localctx.kind = self.match(fugue_sqlParser.IN)
                self.state = 3164
                self.match(fugue_sqlParser.T__2)
                self.state = 3165
                self.query()
                self.state = 3166
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3169
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3168
                    self.match(fugue_sqlParser.NOT)


                self.state = 3171
                localctx.kind = self.match(fugue_sqlParser.RLIKE)
                self.state = 3172
                localctx.pattern = self.valueExpression(0)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 3174
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3173
                    self.match(fugue_sqlParser.NOT)


                self.state = 3176
                localctx.kind = self.match(fugue_sqlParser.LIKE)
                self.state = 3177
                localctx.quantifier = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.ALL or _la==fugue_sqlParser.ANY or _la==fugue_sqlParser.SOME):
                    localctx.quantifier = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3191
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,427,self._ctx)
                if la_ == 1:
                    self.state = 3178
                    self.match(fugue_sqlParser.T__2)
                    self.state = 3179
                    self.match(fugue_sqlParser.T__3)
                    pass

                elif la_ == 2:
                    self.state = 3180
                    self.match(fugue_sqlParser.T__2)
                    self.state = 3181
                    self.expression()
                    self.state = 3186
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==fugue_sqlParser.T__0:
                        self.state = 3182
                        self.match(fugue_sqlParser.T__0)
                        self.state = 3183
                        self.expression()
                        self.state = 3188
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 3189
                    self.match(fugue_sqlParser.T__3)
                    pass


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 3194
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3193
                    self.match(fugue_sqlParser.NOT)


                self.state = 3196
                localctx.kind = self.match(fugue_sqlParser.LIKE)
                self.state = 3197
                localctx.pattern = self.valueExpression(0)
                self.state = 3200
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,429,self._ctx)
                if la_ == 1:
                    self.state = 3198
                    self.match(fugue_sqlParser.ESCAPE)
                    self.state = 3199
                    localctx.escapeChar = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 3202
                self.match(fugue_sqlParser.IS)
                self.state = 3204
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3203
                    self.match(fugue_sqlParser.NOT)


                self.state = 3206
                localctx.kind = self.match(fugue_sqlParser.NULL)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 3207
                self.match(fugue_sqlParser.IS)
                self.state = 3209
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3208
                    self.match(fugue_sqlParser.NOT)


                self.state = 3211
                localctx.kind = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.FALSE or _la==fugue_sqlParser.TRUE or _la==fugue_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 = 3212
                self.match(fugue_sqlParser.IS)
                self.state = 3214
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.NOT:
                    self.state = 3213
                    self.match(fugue_sqlParser.NOT)


                self.state = 3216
                localctx.kind = self.match(fugue_sqlParser.DISTINCT)
                self.state = 3217
                self.match(fugue_sqlParser.FROM)
                self.state = 3218
                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 fugue_sqlParser.RULE_valueExpression

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


    class ValueExpressionDefaultContext(ValueExpressionContext):

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

        def primaryExpression(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.left = None # ValueExpressionContext
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

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

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_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(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)
        def SLASH(self):
            return self.getToken(fugue_sqlParser.SLASH, 0)
        def PERCENT(self):
            return self.getToken(fugue_sqlParser.PERCENT, 0)
        def DIV(self):
            return self.getToken(fugue_sqlParser.DIV, 0)
        def PLUS(self):
            return self.getToken(fugue_sqlParser.PLUS, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)
        def CONCAT_PIPE(self):
            return self.getToken(fugue_sqlParser.CONCAT_PIPE, 0)
        def AMPERSAND(self):
            return self.getToken(fugue_sqlParser.AMPERSAND, 0)
        def HAT(self):
            return self.getToken(fugue_sqlParser.HAT, 0)
        def PIPE(self):
            return self.getToken(fugue_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 fugue_sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.operator = None # Token
            self.copyFrom(ctx)

        def valueExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,0)

        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)
        def PLUS(self):
            return self.getToken(fugue_sqlParser.PLUS, 0)
        def TILDE(self):
            return self.getToken(fugue_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 = fugue_sqlParser.ValueExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 342
        self.enterRecursionRule(localctx, 342, self.RULE_valueExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3225
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,434,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.ValueExpressionDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 3222
                self.primaryExpression(0)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.ArithmeticUnaryContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3223
                localctx.operator = self._input.LT(1)
                _la = self._input.LA(1)
                if not(((((_la - 315)) & ~0x3f) == 0 and ((1 << (_la - 315)) & ((1 << (fugue_sqlParser.PLUS - 315)) | (1 << (fugue_sqlParser.MINUS - 315)) | (1 << (fugue_sqlParser.TILDE - 315)))) != 0)):
                    localctx.operator = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3224
                self.valueExpression(7)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 3248
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,436,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 = 3246
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,435,self._ctx)
                    if la_ == 1:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3227
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 3228
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 317)) & ~0x3f) == 0 and ((1 << (_la - 317)) & ((1 << (fugue_sqlParser.ASTERISK - 317)) | (1 << (fugue_sqlParser.SLASH - 317)) | (1 << (fugue_sqlParser.PERCENT - 317)) | (1 << (fugue_sqlParser.DIV - 317)))) != 0)):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 3229
                        localctx.right = self.valueExpression(7)
                        pass

                    elif la_ == 2:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3230
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 3231
                        localctx.operator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 315)) & ~0x3f) == 0 and ((1 << (_la - 315)) & ((1 << (fugue_sqlParser.PLUS - 315)) | (1 << (fugue_sqlParser.MINUS - 315)) | (1 << (fugue_sqlParser.CONCAT_PIPE - 315)))) != 0)):
                            localctx.operator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 3232
                        localctx.right = self.valueExpression(6)
                        pass

                    elif la_ == 3:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3233
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 3234
                        localctx.operator = self.match(fugue_sqlParser.AMPERSAND)
                        self.state = 3235
                        localctx.right = self.valueExpression(5)
                        pass

                    elif la_ == 4:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3236
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 3237
                        localctx.operator = self.match(fugue_sqlParser.HAT)
                        self.state = 3238
                        localctx.right = self.valueExpression(4)
                        pass

                    elif la_ == 5:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3239
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 3240
                        localctx.operator = self.match(fugue_sqlParser.PIPE)
                        self.state = 3241
                        localctx.right = self.valueExpression(3)
                        pass

                    elif la_ == 6:
                        localctx = fugue_sqlParser.ComparisonContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3242
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 3243
                        self.comparisonOperator()
                        self.state = 3244
                        localctx.right = self.valueExpression(2)
                        pass

             
                self.state = 3250
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,436,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 fugue_sqlParser.RULE_primaryExpression

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


    class StructContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self._namedExpression = None # NamedExpressionContext
            self.argument = list() # of NamedExpressionContexts
            self.copyFrom(ctx)

        def STRUCT(self):
            return self.getToken(fugue_sqlParser.STRUCT, 0)
        def namedExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.base = None # PrimaryExpressionContext
            self.fieldName = None # IdentifierContext
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.PrimaryExpressionContext,0)

        def identifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.value = None # ExpressionContext
            self.elseExpression = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(fugue_sqlParser.CASE, 0)
        def END(self):
            return self.getToken(fugue_sqlParser.END, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)

        def whenClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.WhenClauseContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.WhenClauseContext,i)

        def ELSE(self):
            return self.getToken(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def namedExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)
        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)

        def IGNORE(self):
            return self.getToken(fugue_sqlParser.IGNORE, 0)
        def NULLS(self):
            return self.getToken(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.iinput = None # ValueExpressionContext
            self.replace = None # ValueExpressionContext
            self.position = None # ValueExpressionContext
            self.length = None # ValueExpressionContext
            self.copyFrom(ctx)

        def OVERLAY(self):
            return self.getToken(fugue_sqlParser.OVERLAY, 0)
        def PLACING(self):
            return self.getToken(fugue_sqlParser.PLACING, 0)
        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)

        def FOR(self):
            return self.getToken(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.value = None # PrimaryExpressionContext
            self.index = None # ValueExpressionContext
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.PrimaryExpressionContext,0)

        def valueExpression(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.istr = None # ValueExpressionContext
            self.pos = None # ValueExpressionContext
            self.ilen = None # ValueExpressionContext
            self.copyFrom(ctx)

        def SUBSTR(self):
            return self.getToken(fugue_sqlParser.SUBSTR, 0)
        def SUBSTRING(self):
            return self.getToken(fugue_sqlParser.SUBSTRING, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def FOR(self):
            return self.getToken(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def CURRENT_DATE(self):
            return self.getToken(fugue_sqlParser.CURRENT_DATE, 0)
        def CURRENT_TIMESTAMP(self):
            return self.getToken(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CAST(self):
            return self.getToken(fugue_sqlParser.CAST, 0)
        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)
        def dataType(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def constant(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def expression(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.field = None # IdentifierContext
            self.source = None # ValueExpressionContext
            self.copyFrom(ctx)

        def EXTRACT(self):
            return self.getToken(fugue_sqlParser.EXTRACT, 0)
        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)

        def valueExpression(self):
            return self.getTypedRuleContext(fugue_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 fugue_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(fugue_sqlParser.TRIM, 0)
        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)

        def BOTH(self):
            return self.getToken(fugue_sqlParser.BOTH, 0)
        def LEADING(self):
            return self.getToken(fugue_sqlParser.LEADING, 0)
        def TRAILING(self):
            return self.getToken(fugue_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 fugue_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(fugue_sqlParser.FunctionNameContext,0)

        def FILTER(self):
            return self.getToken(fugue_sqlParser.FILTER, 0)
        def WHERE(self):
            return self.getToken(fugue_sqlParser.WHERE, 0)
        def OVER(self):
            return self.getToken(fugue_sqlParser.OVER, 0)
        def windowSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowSpecContext,0)

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

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)

        def setQuantifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.elseExpression = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(fugue_sqlParser.CASE, 0)
        def END(self):
            return self.getToken(fugue_sqlParser.END, 0)
        def whenClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.WhenClauseContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.WhenClauseContext,i)

        def ELSE(self):
            return self.getToken(fugue_sqlParser.ELSE, 0)
        def expression(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.substr = None # ValueExpressionContext
            self.istr = None # ValueExpressionContext
            self.copyFrom(ctx)

        def POSITION(self):
            return self.getToken(fugue_sqlParser.POSITION, 0)
        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)
        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)

        def IGNORE(self):
            return self.getToken(fugue_sqlParser.IGNORE, 0)
        def NULLS(self):
            return self.getToken(fugue_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 = fugue_sqlParser.PrimaryExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 344
        self.enterRecursionRule(localctx, 344, self.RULE_primaryExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3435
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,456,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.CurrentDatetimeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 3252
                localctx.name = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.CURRENT_DATE or _la==fugue_sqlParser.CURRENT_TIMESTAMP):
                    localctx.name = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.SearchedCaseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3253
                self.match(fugue_sqlParser.CASE)
                self.state = 3255 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 3254
                    self.whenClause()
                    self.state = 3257 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==fugue_sqlParser.WHEN):
                        break

                self.state = 3261
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.ELSE:
                    self.state = 3259
                    self.match(fugue_sqlParser.ELSE)
                    self.state = 3260
                    localctx.elseExpression = self.expression()


                self.state = 3263
                self.match(fugue_sqlParser.END)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.SimpleCaseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3265
                self.match(fugue_sqlParser.CASE)
                self.state = 3266
                localctx.value = self.expression()
                self.state = 3268 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 3267
                    self.whenClause()
                    self.state = 3270 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==fugue_sqlParser.WHEN):
                        break

                self.state = 3274
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.ELSE:
                    self.state = 3272
                    self.match(fugue_sqlParser.ELSE)
                    self.state = 3273
                    localctx.elseExpression = self.expression()


                self.state = 3276
                self.match(fugue_sqlParser.END)
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.CastContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3278
                self.match(fugue_sqlParser.CAST)
                self.state = 3279
                self.match(fugue_sqlParser.T__2)
                self.state = 3280
                self.expression()
                self.state = 3281
                self.match(fugue_sqlParser.AS)
                self.state = 3282
                self.dataType()
                self.state = 3283
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.StructContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3285
                self.match(fugue_sqlParser.STRUCT)
                self.state = 3286
                self.match(fugue_sqlParser.T__2)
                self.state = 3295
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,442,self._ctx)
                if la_ == 1:
                    self.state = 3287
                    localctx._namedExpression = self.namedExpression()
                    localctx.argument.append(localctx._namedExpression)
                    self.state = 3292
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==fugue_sqlParser.T__0:
                        self.state = 3288
                        self.match(fugue_sqlParser.T__0)
                        self.state = 3289
                        localctx._namedExpression = self.namedExpression()
                        localctx.argument.append(localctx._namedExpression)
                        self.state = 3294
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 3297
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 6:
                localctx = fugue_sqlParser.FirstContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3298
                self.match(fugue_sqlParser.FIRST)
                self.state = 3299
                self.match(fugue_sqlParser.T__2)
                self.state = 3300
                self.expression()
                self.state = 3303
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.IGNORE:
                    self.state = 3301
                    self.match(fugue_sqlParser.IGNORE)
                    self.state = 3302
                    self.match(fugue_sqlParser.NULLS)


                self.state = 3305
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 7:
                localctx = fugue_sqlParser.LastContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3307
                self.match(fugue_sqlParser.LAST)
                self.state = 3308
                self.match(fugue_sqlParser.T__2)
                self.state = 3309
                self.expression()
                self.state = 3312
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.IGNORE:
                    self.state = 3310
                    self.match(fugue_sqlParser.IGNORE)
                    self.state = 3311
                    self.match(fugue_sqlParser.NULLS)


                self.state = 3314
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 8:
                localctx = fugue_sqlParser.PositionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3316
                self.match(fugue_sqlParser.POSITION)
                self.state = 3317
                self.match(fugue_sqlParser.T__2)
                self.state = 3318
                localctx.substr = self.valueExpression(0)
                self.state = 3319
                self.match(fugue_sqlParser.IN)
                self.state = 3320
                localctx.istr = self.valueExpression(0)
                self.state = 3321
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 9:
                localctx = fugue_sqlParser.ConstantDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3323
                self.constant()
                pass

            elif la_ == 10:
                localctx = fugue_sqlParser.StarContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3324
                self.match(fugue_sqlParser.ASTERISK)
                pass

            elif la_ == 11:
                localctx = fugue_sqlParser.StarContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3325
                self.qualifiedName()
                self.state = 3326
                self.match(fugue_sqlParser.T__6)
                self.state = 3327
                self.match(fugue_sqlParser.ASTERISK)
                pass

            elif la_ == 12:
                localctx = fugue_sqlParser.RowConstructorContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3329
                self.match(fugue_sqlParser.T__2)
                self.state = 3330
                self.namedExpression()
                self.state = 3333 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 3331
                    self.match(fugue_sqlParser.T__0)
                    self.state = 3332
                    self.namedExpression()
                    self.state = 3335 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==fugue_sqlParser.T__0):
                        break

                self.state = 3337
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 13:
                localctx = fugue_sqlParser.SubqueryExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3339
                self.match(fugue_sqlParser.T__2)
                self.state = 3340
                self.query()
                self.state = 3341
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 14:
                localctx = fugue_sqlParser.FunctionCallContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3343
                self.functionName()
                self.state = 3344
                self.match(fugue_sqlParser.T__2)
                self.state = 3356
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,448,self._ctx)
                if la_ == 1:
                    self.state = 3346
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,446,self._ctx)
                    if la_ == 1:
                        self.state = 3345
                        self.setQuantifier()


                    self.state = 3348
                    localctx._expression = self.expression()
                    localctx.argument.append(localctx._expression)
                    self.state = 3353
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==fugue_sqlParser.T__0:
                        self.state = 3349
                        self.match(fugue_sqlParser.T__0)
                        self.state = 3350
                        localctx._expression = self.expression()
                        localctx.argument.append(localctx._expression)
                        self.state = 3355
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 3358
                self.match(fugue_sqlParser.T__3)
                self.state = 3365
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,449,self._ctx)
                if la_ == 1:
                    self.state = 3359
                    self.match(fugue_sqlParser.FILTER)
                    self.state = 3360
                    self.match(fugue_sqlParser.T__2)
                    self.state = 3361
                    self.match(fugue_sqlParser.WHERE)
                    self.state = 3362
                    localctx.where = self.booleanExpression(0)
                    self.state = 3363
                    self.match(fugue_sqlParser.T__3)


                self.state = 3369
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,450,self._ctx)
                if la_ == 1:
                    self.state = 3367
                    self.match(fugue_sqlParser.OVER)
                    self.state = 3368
                    self.windowSpec()


                pass

            elif la_ == 15:
                localctx = fugue_sqlParser.LambdaContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3371
                self.identifier()
                self.state = 3372
                self.match(fugue_sqlParser.T__15)
                self.state = 3373
                self.expression()
                pass

            elif la_ == 16:
                localctx = fugue_sqlParser.LambdaContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3375
                self.match(fugue_sqlParser.T__2)
                self.state = 3376
                self.identifier()
                self.state = 3379 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 3377
                    self.match(fugue_sqlParser.T__0)
                    self.state = 3378
                    self.identifier()
                    self.state = 3381 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==fugue_sqlParser.T__0):
                        break

                self.state = 3383
                self.match(fugue_sqlParser.T__3)
                self.state = 3384
                self.match(fugue_sqlParser.T__15)
                self.state = 3385
                self.expression()
                pass

            elif la_ == 17:
                localctx = fugue_sqlParser.ColumnReferenceContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3387
                self.identifier()
                pass

            elif la_ == 18:
                localctx = fugue_sqlParser.ParenthesizedExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3388
                self.match(fugue_sqlParser.T__2)
                self.state = 3389
                self.expression()
                self.state = 3390
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 19:
                localctx = fugue_sqlParser.ExtractContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3392
                self.match(fugue_sqlParser.EXTRACT)
                self.state = 3393
                self.match(fugue_sqlParser.T__2)
                self.state = 3394
                localctx.field = self.identifier()
                self.state = 3395
                self.match(fugue_sqlParser.FROM)
                self.state = 3396
                localctx.source = self.valueExpression(0)
                self.state = 3397
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 20:
                localctx = fugue_sqlParser.SubstringContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3399
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.SUBSTR or _la==fugue_sqlParser.SUBSTRING):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3400
                self.match(fugue_sqlParser.T__2)
                self.state = 3401
                localctx.istr = self.valueExpression(0)
                self.state = 3402
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.T__0 or _la==fugue_sqlParser.FROM):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3403
                localctx.pos = self.valueExpression(0)
                self.state = 3406
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.T__0 or _la==fugue_sqlParser.FOR:
                    self.state = 3404
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.T__0 or _la==fugue_sqlParser.FOR):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 3405
                    localctx.ilen = self.valueExpression(0)


                self.state = 3408
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 21:
                localctx = fugue_sqlParser.TrimContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3410
                self.match(fugue_sqlParser.TRIM)
                self.state = 3411
                self.match(fugue_sqlParser.T__2)
                self.state = 3413
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,453,self._ctx)
                if la_ == 1:
                    self.state = 3412
                    localctx.trimOption = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.BOTH or _la==fugue_sqlParser.LEADING or _la==fugue_sqlParser.TRAILING):
                        localctx.trimOption = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 3416
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,454,self._ctx)
                if la_ == 1:
                    self.state = 3415
                    localctx.trimStr = self.valueExpression(0)


                self.state = 3418
                self.match(fugue_sqlParser.FROM)
                self.state = 3419
                localctx.srcStr = self.valueExpression(0)
                self.state = 3420
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 22:
                localctx = fugue_sqlParser.OverlayContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3422
                self.match(fugue_sqlParser.OVERLAY)
                self.state = 3423
                self.match(fugue_sqlParser.T__2)
                self.state = 3424
                localctx.iinput = self.valueExpression(0)
                self.state = 3425
                self.match(fugue_sqlParser.PLACING)
                self.state = 3426
                localctx.replace = self.valueExpression(0)
                self.state = 3427
                self.match(fugue_sqlParser.FROM)
                self.state = 3428
                localctx.position = self.valueExpression(0)
                self.state = 3431
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.FOR:
                    self.state = 3429
                    self.match(fugue_sqlParser.FOR)
                    self.state = 3430
                    localctx.length = self.valueExpression(0)


                self.state = 3433
                self.match(fugue_sqlParser.T__3)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 3447
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,458,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 = 3445
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,457,self._ctx)
                    if la_ == 1:
                        localctx = fugue_sqlParser.SubscriptContext(self, fugue_sqlParser.PrimaryExpressionContext(self, _parentctx, _parentState))
                        localctx.value = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_primaryExpression)
                        self.state = 3437
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 3438
                        self.match(fugue_sqlParser.T__4)
                        self.state = 3439
                        localctx.index = self.valueExpression(0)
                        self.state = 3440
                        self.match(fugue_sqlParser.T__5)
                        pass

                    elif la_ == 2:
                        localctx = fugue_sqlParser.DereferenceContext(self, fugue_sqlParser.PrimaryExpressionContext(self, _parentctx, _parentState))
                        localctx.base = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_primaryExpression)
                        self.state = 3442
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 3443
                        self.match(fugue_sqlParser.T__6)
                        self.state = 3444
                        localctx.fieldName = self.identifier()
                        pass

             
                self.state = 3449
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,458,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 fugue_sqlParser.RULE_constant

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



    class NullLiteralContext(ConstantContext):

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

        def NULL(self):
            return self.getToken(fugue_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 fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.STRING)
            else:
                return self.getToken(fugue_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 fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def STRING(self):
            return self.getToken(fugue_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 fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def interval(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def number(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def booleanValue(self):
            return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_constant)
        try:
            self.state = 3462
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,460,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.NullLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3450
                self.match(fugue_sqlParser.NULL)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.IntervalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3451
                self.interval()
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.TypeConstructorContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3452
                self.identifier()
                self.state = 3453
                self.match(fugue_sqlParser.STRING)
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.NumericLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 3455
                self.number()
                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.BooleanLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 3456
                self.booleanValue()
                pass

            elif la_ == 6:
                localctx = fugue_sqlParser.StringLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 3458 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 3457
                        self.match(fugue_sqlParser.STRING)

                    else:
                        raise NoViableAltException(self)
                    self.state = 3460 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,459,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 comparisonEqualOperator(self):
            return self.getTypedRuleContext(fugue_sqlParser.ComparisonEqualOperatorContext,0)


        def NEQ(self):
            return self.getToken(fugue_sqlParser.NEQ, 0)

        def NEQJ(self):
            return self.getToken(fugue_sqlParser.NEQJ, 0)

        def LT(self):
            return self.getToken(fugue_sqlParser.LT, 0)

        def LTE(self):
            return self.getToken(fugue_sqlParser.LTE, 0)

        def GT(self):
            return self.getToken(fugue_sqlParser.GT, 0)

        def GTE(self):
            return self.getToken(fugue_sqlParser.GTE, 0)

        def NSEQ(self):
            return self.getToken(fugue_sqlParser.NSEQ, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ComparisonOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_comparisonOperator)
        try:
            self.state = 3472
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.EQUAL, fugue_sqlParser.DOUBLEEQUAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3464
                self.comparisonEqualOperator()
                pass
            elif token in [fugue_sqlParser.NEQ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3465
                self.match(fugue_sqlParser.NEQ)
                pass
            elif token in [fugue_sqlParser.NEQJ]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3466
                self.match(fugue_sqlParser.NEQJ)
                pass
            elif token in [fugue_sqlParser.LT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 3467
                self.match(fugue_sqlParser.LT)
                pass
            elif token in [fugue_sqlParser.LTE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 3468
                self.match(fugue_sqlParser.LTE)
                pass
            elif token in [fugue_sqlParser.GT]:
                self.enterOuterAlt(localctx, 6)
                self.state = 3469
                self.match(fugue_sqlParser.GT)
                pass
            elif token in [fugue_sqlParser.GTE]:
                self.enterOuterAlt(localctx, 7)
                self.state = 3470
                self.match(fugue_sqlParser.GTE)
                pass
            elif token in [fugue_sqlParser.NSEQ]:
                self.enterOuterAlt(localctx, 8)
                self.state = 3471
                self.match(fugue_sqlParser.NSEQ)
                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 ComparisonEqualOperatorContext(ParserRuleContext):

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

        def DOUBLEEQUAL(self):
            return self.getToken(fugue_sqlParser.DOUBLEEQUAL, 0)

        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_comparisonEqualOperator

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




    def comparisonEqualOperator(self):

        localctx = fugue_sqlParser.ComparisonEqualOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_comparisonEqualOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3474
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.EQUAL or _la==fugue_sqlParser.DOUBLEEQUAL):
                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(fugue_sqlParser.PLUS, 0)

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

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)

        def SLASH(self):
            return self.getToken(fugue_sqlParser.SLASH, 0)

        def PERCENT(self):
            return self.getToken(fugue_sqlParser.PERCENT, 0)

        def DIV(self):
            return self.getToken(fugue_sqlParser.DIV, 0)

        def TILDE(self):
            return self.getToken(fugue_sqlParser.TILDE, 0)

        def AMPERSAND(self):
            return self.getToken(fugue_sqlParser.AMPERSAND, 0)

        def PIPE(self):
            return self.getToken(fugue_sqlParser.PIPE, 0)

        def CONCAT_PIPE(self):
            return self.getToken(fugue_sqlParser.CONCAT_PIPE, 0)

        def HAT(self):
            return self.getToken(fugue_sqlParser.HAT, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ArithmeticOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_arithmeticOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3476
            _la = self._input.LA(1)
            if not(((((_la - 315)) & ~0x3f) == 0 and ((1 << (_la - 315)) & ((1 << (fugue_sqlParser.PLUS - 315)) | (1 << (fugue_sqlParser.MINUS - 315)) | (1 << (fugue_sqlParser.ASTERISK - 315)) | (1 << (fugue_sqlParser.SLASH - 315)) | (1 << (fugue_sqlParser.PERCENT - 315)) | (1 << (fugue_sqlParser.DIV - 315)) | (1 << (fugue_sqlParser.TILDE - 315)) | (1 << (fugue_sqlParser.AMPERSAND - 315)) | (1 << (fugue_sqlParser.PIPE - 315)) | (1 << (fugue_sqlParser.CONCAT_PIPE - 315)) | (1 << (fugue_sqlParser.HAT - 315)))) != 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(fugue_sqlParser.OR, 0)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.PredicateOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_predicateOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3478
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.AND or ((((_la - 155)) & ~0x3f) == 0 and ((1 << (_la - 155)) & ((1 << (fugue_sqlParser.IN - 155)) | (1 << (fugue_sqlParser.NOT - 155)) | (1 << (fugue_sqlParser.OR - 155)))) != 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(fugue_sqlParser.TRUE, 0)

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.BooleanValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_booleanValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3480
            _la = self._input.LA(1)
            if not(_la==fugue_sqlParser.FALSE or _la==fugue_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(fugue_sqlParser.INTERVAL, 0)

        def errorCapturingMultiUnitsInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingMultiUnitsIntervalContext,0)


        def errorCapturingUnitToUnitInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingUnitToUnitIntervalContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.IntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_interval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3482
            self.match(fugue_sqlParser.INTERVAL)
            self.state = 3485
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,462,self._ctx)
            if la_ == 1:
                self.state = 3483
                self.errorCapturingMultiUnitsInterval()

            elif la_ == 2:
                self.state = 3484
                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(fugue_sqlParser.MultiUnitsIntervalContext,0)


        def unitToUnitInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.UnitToUnitIntervalContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ErrorCapturingMultiUnitsIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_errorCapturingMultiUnitsInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3487
            self.multiUnitsInterval()
            self.state = 3489
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,463,self._ctx)
            if la_ == 1:
                self.state = 3488
                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(fugue_sqlParser.IntervalValueContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IntervalValueContext,i)


        def intervalUnit(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IntervalUnitContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IntervalUnitContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.MultiUnitsIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_multiUnitsInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3494 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 3491
                    self.intervalValue()
                    self.state = 3492
                    self.intervalUnit()

                else:
                    raise NoViableAltException(self)
                self.state = 3496 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,464,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(fugue_sqlParser.UnitToUnitIntervalContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.UnitToUnitIntervalContext,i)


        def multiUnitsInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultiUnitsIntervalContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ErrorCapturingUnitToUnitIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_errorCapturingUnitToUnitInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3498
            localctx.body = self.unitToUnitInterval()
            self.state = 3501
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,465,self._ctx)
            if la_ == 1:
                self.state = 3499
                localctx.error1 = self.multiUnitsInterval()

            elif la_ == 2:
                self.state = 3500
                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.ifrom = None # IntervalUnitContext
            self.to = None # IntervalUnitContext

        def TO(self):
            return self.getToken(fugue_sqlParser.TO, 0)

        def intervalValue(self):
            return self.getTypedRuleContext(fugue_sqlParser.IntervalValueContext,0)


        def intervalUnit(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IntervalUnitContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IntervalUnitContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.UnitToUnitIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_unitToUnitInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3503
            localctx.value = self.intervalValue()
            self.state = 3504
            localctx.ifrom = self.intervalUnit()
            self.state = 3505
            self.match(fugue_sqlParser.TO)
            self.state = 3506
            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(fugue_sqlParser.INTEGER_VALUE, 0)

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

        def PLUS(self):
            return self.getToken(fugue_sqlParser.PLUS, 0)

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

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.IntervalValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_intervalValue)
        self._la = 0 # Token type
        try:
            self.state = 3513
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.PLUS, fugue_sqlParser.MINUS, fugue_sqlParser.INTEGER_VALUE, fugue_sqlParser.DECIMAL_VALUE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3509
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.PLUS or _la==fugue_sqlParser.MINUS:
                    self.state = 3508
                    _la = self._input.LA(1)
                    if not(_la==fugue_sqlParser.PLUS or _la==fugue_sqlParser.MINUS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 3511
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.INTEGER_VALUE or _la==fugue_sqlParser.DECIMAL_VALUE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [fugue_sqlParser.STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3512
                self.match(fugue_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(fugue_sqlParser.DAY, 0)

        def HOUR(self):
            return self.getToken(fugue_sqlParser.HOUR, 0)

        def MINUTE(self):
            return self.getToken(fugue_sqlParser.MINUTE, 0)

        def MONTH(self):
            return self.getToken(fugue_sqlParser.MONTH, 0)

        def SECOND(self):
            return self.getToken(fugue_sqlParser.SECOND, 0)

        def YEAR(self):
            return self.getToken(fugue_sqlParser.YEAR, 0)

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.IntervalUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_intervalUnit)
        try:
            self.state = 3522
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,468,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3515
                self.match(fugue_sqlParser.DAY)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3516
                self.match(fugue_sqlParser.HOUR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3517
                self.match(fugue_sqlParser.MINUTE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3518
                self.match(fugue_sqlParser.MONTH)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 3519
                self.match(fugue_sqlParser.SECOND)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 3520
                self.match(fugue_sqlParser.YEAR)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 3521
                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(fugue_sqlParser.FIRST, 0)

        def AFTER(self):
            return self.getToken(fugue_sqlParser.AFTER, 0)

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ColPositionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_colPosition)
        try:
            self.state = 3527
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.FIRST]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3524
                localctx.position = self.match(fugue_sqlParser.FIRST)
                pass
            elif token in [fugue_sqlParser.AFTER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3525
                localctx.position = self.match(fugue_sqlParser.AFTER)
                self.state = 3526
                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 fugue_sqlParser.RULE_dataType

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



    class ComplexDataTypeContext(DataTypeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.DataTypeContext
            super().__init__(parser)
            self.icomplex = None # Token
            self.copyFrom(ctx)

        def LT(self):
            return self.getToken(fugue_sqlParser.LT, 0)
        def dataType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.DataTypeContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.DataTypeContext,i)

        def GT(self):
            return self.getToken(fugue_sqlParser.GT, 0)
        def ARRAY(self):
            return self.getToken(fugue_sqlParser.ARRAY, 0)
        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)
        def STRUCT(self):
            return self.getToken(fugue_sqlParser.STRUCT, 0)
        def NEQ(self):
            return self.getToken(fugue_sqlParser.NEQ, 0)
        def complexColTypeList(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.DataTypeContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def INTEGER_VALUE(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.INTEGER_VALUE)
            else:
                return self.getToken(fugue_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 = fugue_sqlParser.DataTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_dataType)
        self._la = 0 # Token type
        try:
            self.state = 3563
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,474,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3529
                localctx.icomplex = self.match(fugue_sqlParser.ARRAY)
                self.state = 3530
                self.match(fugue_sqlParser.LT)
                self.state = 3531
                self.dataType()
                self.state = 3532
                self.match(fugue_sqlParser.GT)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3534
                localctx.icomplex = self.match(fugue_sqlParser.MAP)
                self.state = 3535
                self.match(fugue_sqlParser.LT)
                self.state = 3536
                self.dataType()
                self.state = 3537
                self.match(fugue_sqlParser.T__0)
                self.state = 3538
                self.dataType()
                self.state = 3539
                self.match(fugue_sqlParser.GT)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3541
                localctx.icomplex = self.match(fugue_sqlParser.STRUCT)
                self.state = 3548
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [fugue_sqlParser.LT]:
                    self.state = 3542
                    self.match(fugue_sqlParser.LT)
                    self.state = 3544
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,470,self._ctx)
                    if la_ == 1:
                        self.state = 3543
                        self.complexColTypeList()


                    self.state = 3546
                    self.match(fugue_sqlParser.GT)
                    pass
                elif token in [fugue_sqlParser.NEQ]:
                    self.state = 3547
                    self.match(fugue_sqlParser.NEQ)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.PrimitiveDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 3550
                self.identifier()
                self.state = 3561
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,473,self._ctx)
                if la_ == 1:
                    self.state = 3551
                    self.match(fugue_sqlParser.T__2)
                    self.state = 3552
                    self.match(fugue_sqlParser.INTEGER_VALUE)
                    self.state = 3557
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==fugue_sqlParser.T__0:
                        self.state = 3553
                        self.match(fugue_sqlParser.T__0)
                        self.state = 3554
                        self.match(fugue_sqlParser.INTEGER_VALUE)
                        self.state = 3559
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 3560
                    self.match(fugue_sqlParser.T__3)


                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(fugue_sqlParser.QualifiedColTypeWithPositionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.QualifiedColTypeWithPositionContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.QualifiedColTypeWithPositionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_qualifiedColTypeWithPositionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3565
            self.qualifiedColTypeWithPosition()
            self.state = 3570
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 3566
                self.match(fugue_sqlParser.T__0)
                self.state = 3567
                self.qualifiedColTypeWithPosition()
                self.state = 3572
                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(fugue_sqlParser.DataTypeContext,0)


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


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

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def colPosition(self):
            return self.getTypedRuleContext(fugue_sqlParser.ColPositionContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.QualifiedColTypeWithPositionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_qualifiedColTypeWithPosition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3573
            localctx.name = self.multipartIdentifier()
            self.state = 3574
            self.dataType()
            self.state = 3577
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.NOT:
                self.state = 3575
                self.match(fugue_sqlParser.NOT)
                self.state = 3576
                self.match(fugue_sqlParser.NULL)


            self.state = 3580
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.COMMENT:
                self.state = 3579
                self.commentSpec()


            self.state = 3583
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.AFTER or _la==fugue_sqlParser.FIRST:
                self.state = 3582
                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(fugue_sqlParser.ColTypeContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ColTypeContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ColTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_colTypeList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3585
            self.colType()
            self.state = 3590
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,479,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3586
                    self.match(fugue_sqlParser.T__0)
                    self.state = 3587
                    self.colType() 
                self.state = 3592
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,479,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(fugue_sqlParser.DataTypeContext,0)


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


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

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ColTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 382, self.RULE_colType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3593
            localctx.colName = self.errorCapturingIdentifier()
            self.state = 3594
            self.dataType()
            self.state = 3597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,480,self._ctx)
            if la_ == 1:
                self.state = 3595
                self.match(fugue_sqlParser.NOT)
                self.state = 3596
                self.match(fugue_sqlParser.NULL)


            self.state = 3600
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,481,self._ctx)
            if la_ == 1:
                self.state = 3599
                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(fugue_sqlParser.ComplexColTypeContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ComplexColTypeContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ComplexColTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 384, self.RULE_complexColTypeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3602
            self.complexColType()
            self.state = 3607
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 3603
                self.match(fugue_sqlParser.T__0)
                self.state = 3604
                self.complexColType()
                self.state = 3609
                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(fugue_sqlParser.IdentifierContext,0)


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


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

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ComplexColTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 386, self.RULE_complexColType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3610
            self.identifier()
            self.state = 3611
            self.match(fugue_sqlParser.T__1)
            self.state = 3612
            self.dataType()
            self.state = 3615
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.NOT:
                self.state = 3613
                self.match(fugue_sqlParser.NOT)
                self.state = 3614
                self.match(fugue_sqlParser.NULL)


            self.state = 3618
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==fugue_sqlParser.COMMENT:
                self.state = 3617
                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(fugue_sqlParser.WHEN, 0)

        def THEN(self):
            return self.getToken(fugue_sqlParser.THEN, 0)

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.WhenClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 388, self.RULE_whenClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3620
            self.match(fugue_sqlParser.WHEN)
            self.state = 3621
            localctx.condition = self.expression()
            self.state = 3622
            self.match(fugue_sqlParser.THEN)
            self.state = 3623
            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(fugue_sqlParser.WINDOW, 0)

        def namedWindow(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NamedWindowContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.NamedWindowContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.WindowClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 390, self.RULE_windowClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3625
            self.match(fugue_sqlParser.WINDOW)
            self.state = 3626
            self.namedWindow()
            self.state = 3631
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,485,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3627
                    self.match(fugue_sqlParser.T__0)
                    self.state = 3628
                    self.namedWindow() 
                self.state = 3633
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,485,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(fugue_sqlParser.AS, 0)

        def windowSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowSpecContext,0)


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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NamedWindowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 392, self.RULE_namedWindow)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3634
            localctx.name = self.errorCapturingIdentifier()
            self.state = 3635
            self.match(fugue_sqlParser.AS)
            self.state = 3636
            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 fugue_sqlParser.RULE_windowSpec

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



    class WindowRefContext(WindowSpecContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.WindowSpecContext
            super().__init__(parser)
            self.name = None # ErrorCapturingIdentifierContext
            self.copyFrom(ctx)

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.WindowSpecContext
            super().__init__(parser)
            self._expression = None # ExpressionContext
            self.partition = list() # of ExpressionContexts
            self.copyFrom(ctx)

        def CLUSTER(self):
            return self.getToken(fugue_sqlParser.CLUSTER, 0)
        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.BY)
            else:
                return self.getToken(fugue_sqlParser.BY, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)

        def windowFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowFrameContext,0)

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.SortItemContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.SortItemContext,i)

        def PARTITION(self):
            return self.getToken(fugue_sqlParser.PARTITION, 0)
        def DISTRIBUTE(self):
            return self.getToken(fugue_sqlParser.DISTRIBUTE, 0)
        def ORDER(self):
            return self.getToken(fugue_sqlParser.ORDER, 0)
        def SORT(self):
            return self.getToken(fugue_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 = fugue_sqlParser.WindowSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 394, self.RULE_windowSpec)
        self._la = 0 # Token type
        try:
            self.state = 3684
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,493,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.WindowRefContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3638
                localctx.name = self.errorCapturingIdentifier()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.WindowRefContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3639
                self.match(fugue_sqlParser.T__2)
                self.state = 3640
                localctx.name = self.errorCapturingIdentifier()
                self.state = 3641
                self.match(fugue_sqlParser.T__3)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.WindowDefContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3643
                self.match(fugue_sqlParser.T__2)
                self.state = 3678
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [fugue_sqlParser.CLUSTER]:
                    self.state = 3644
                    self.match(fugue_sqlParser.CLUSTER)
                    self.state = 3645
                    self.match(fugue_sqlParser.BY)
                    self.state = 3646
                    localctx._expression = self.expression()
                    localctx.partition.append(localctx._expression)
                    self.state = 3651
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==fugue_sqlParser.T__0:
                        self.state = 3647
                        self.match(fugue_sqlParser.T__0)
                        self.state = 3648
                        localctx._expression = self.expression()
                        localctx.partition.append(localctx._expression)
                        self.state = 3653
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [fugue_sqlParser.T__3, fugue_sqlParser.DISTRIBUTE, fugue_sqlParser.ORDER, fugue_sqlParser.PARTITION, fugue_sqlParser.RANGE, fugue_sqlParser.ROWS, fugue_sqlParser.SORT]:
                    self.state = 3664
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.DISTRIBUTE or _la==fugue_sqlParser.PARTITION:
                        self.state = 3654
                        _la = self._input.LA(1)
                        if not(_la==fugue_sqlParser.DISTRIBUTE or _la==fugue_sqlParser.PARTITION):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 3655
                        self.match(fugue_sqlParser.BY)
                        self.state = 3656
                        localctx._expression = self.expression()
                        localctx.partition.append(localctx._expression)
                        self.state = 3661
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==fugue_sqlParser.T__0:
                            self.state = 3657
                            self.match(fugue_sqlParser.T__0)
                            self.state = 3658
                            localctx._expression = self.expression()
                            localctx.partition.append(localctx._expression)
                            self.state = 3663
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    self.state = 3676
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==fugue_sqlParser.ORDER or _la==fugue_sqlParser.SORT:
                        self.state = 3666
                        _la = self._input.LA(1)
                        if not(_la==fugue_sqlParser.ORDER or _la==fugue_sqlParser.SORT):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 3667
                        self.match(fugue_sqlParser.BY)
                        self.state = 3668
                        self.sortItem()
                        self.state = 3673
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==fugue_sqlParser.T__0:
                            self.state = 3669
                            self.match(fugue_sqlParser.T__0)
                            self.state = 3670
                            self.sortItem()
                            self.state = 3675
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 3681
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.RANGE or _la==fugue_sqlParser.ROWS:
                    self.state = 3680
                    self.windowFrame()


                self.state = 3683
                self.match(fugue_sqlParser.T__3)
                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(fugue_sqlParser.RANGE, 0)

        def frameBound(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FrameBoundContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FrameBoundContext,i)


        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

        def BETWEEN(self):
            return self.getToken(fugue_sqlParser.BETWEEN, 0)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.WindowFrameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 396, self.RULE_windowFrame)
        try:
            self.state = 3702
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,494,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3686
                localctx.frameType = self.match(fugue_sqlParser.RANGE)
                self.state = 3687
                localctx.start = self.frameBound()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3688
                localctx.frameType = self.match(fugue_sqlParser.ROWS)
                self.state = 3689
                localctx.start = self.frameBound()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3690
                localctx.frameType = self.match(fugue_sqlParser.RANGE)
                self.state = 3691
                self.match(fugue_sqlParser.BETWEEN)
                self.state = 3692
                localctx.start = self.frameBound()
                self.state = 3693
                self.match(fugue_sqlParser.AND)
                self.state = 3694
                localctx.end = self.frameBound()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3696
                localctx.frameType = self.match(fugue_sqlParser.ROWS)
                self.state = 3697
                self.match(fugue_sqlParser.BETWEEN)
                self.state = 3698
                localctx.start = self.frameBound()
                self.state = 3699
                self.match(fugue_sqlParser.AND)
                self.state = 3700
                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(fugue_sqlParser.UNBOUNDED, 0)

        def PRECEDING(self):
            return self.getToken(fugue_sqlParser.PRECEDING, 0)

        def FOLLOWING(self):
            return self.getToken(fugue_sqlParser.FOLLOWING, 0)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)

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

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


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.FrameBoundContext(self, self._ctx, self.state)
        self.enterRule(localctx, 398, self.RULE_frameBound)
        self._la = 0 # Token type
        try:
            self.state = 3711
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,495,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3704
                self.match(fugue_sqlParser.UNBOUNDED)
                self.state = 3705
                localctx.boundType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.FOLLOWING or _la==fugue_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 = 3706
                localctx.boundType = self.match(fugue_sqlParser.CURRENT)
                self.state = 3707
                self.match(fugue_sqlParser.ROW)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3708
                self.expression()
                self.state = 3709
                localctx.boundType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.FOLLOWING or _la==fugue_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(fugue_sqlParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.QualifiedNameListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 400, self.RULE_qualifiedNameList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3713
            self.qualifiedName()
            self.state = 3718
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==fugue_sqlParser.T__0:
                self.state = 3714
                self.match(fugue_sqlParser.T__0)
                self.state = 3715
                self.qualifiedName()
                self.state = 3720
                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(fugue_sqlParser.QualifiedNameContext,0)


        def FILTER(self):
            return self.getToken(fugue_sqlParser.FILTER, 0)

        def LEFT(self):
            return self.getToken(fugue_sqlParser.LEFT, 0)

        def RIGHT(self):
            return self.getToken(fugue_sqlParser.RIGHT, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.FunctionNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 402, self.RULE_functionName)
        try:
            self.state = 3725
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,497,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3721
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3722
                self.match(fugue_sqlParser.FILTER)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3723
                self.match(fugue_sqlParser.LEFT)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3724
                self.match(fugue_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(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.QualifiedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 404, self.RULE_qualifiedName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3727
            self.identifier()
            self.state = 3732
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,498,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3728
                    self.match(fugue_sqlParser.T__6)
                    self.state = 3729
                    self.identifier() 
                self.state = 3734
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,498,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(fugue_sqlParser.IdentifierContext,0)


        def errorCapturingIdentifierExtra(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierExtraContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.ErrorCapturingIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 406, self.RULE_errorCapturingIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3735
            self.identifier()
            self.state = 3736
            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 fugue_sqlParser.RULE_errorCapturingIdentifierExtra

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



    class ErrorIdentContext(ErrorCapturingIdentifierExtraContext):

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

        def MINUS(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.MINUS)
            else:
                return self.getToken(fugue_sqlParser.MINUS, i)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_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 fugue_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 = fugue_sqlParser.ErrorCapturingIdentifierExtraContext(self, self._ctx, self.state)
        self.enterRule(localctx, 408, self.RULE_errorCapturingIdentifierExtra)
        try:
            self.state = 3745
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,500,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.ErrorIdentContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3740 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 3738
                        self.match(fugue_sqlParser.MINUS)
                        self.state = 3739
                        self.identifier()

                    else:
                        raise NoViableAltException(self)
                    self.state = 3742 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,499,self._ctx)

                pass

            elif la_ == 2:
                localctx = fugue_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(fugue_sqlParser.StrictIdentifierContext,0)


        def strictNonReserved(self):
            return self.getTypedRuleContext(fugue_sqlParser.StrictNonReservedContext,0)


        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 410, self.RULE_identifier)
        try:
            self.state = 3750
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,501,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3747
                self.strictIdentifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3748
                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 = 3749
                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 fugue_sqlParser.RULE_strictIdentifier

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



    class QuotedIdentifierAlternativeContext(StrictIdentifierContext):

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

        def quotedIdentifier(self):
            return self.getTypedRuleContext(fugue_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 fugue_sqlParser.StrictIdentifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IDENTIFIER(self):
            return self.getToken(fugue_sqlParser.IDENTIFIER, 0)
        def ansiNonReserved(self):
            return self.getTypedRuleContext(fugue_sqlParser.AnsiNonReservedContext,0)

        def nonReserved(self):
            return self.getTypedRuleContext(fugue_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 = fugue_sqlParser.StrictIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 412, self.RULE_strictIdentifier)
        try:
            self.state = 3758
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,502,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3752
                self.match(fugue_sqlParser.IDENTIFIER)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.QuotedIdentifierAlternativeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3753
                self.quotedIdentifier()
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3754
                if not self.SQL_standard_keyword_behavior:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.SQL_standard_keyword_behavior")
                self.state = 3755
                self.ansiNonReserved()
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 3756
                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 = 3757
                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(fugue_sqlParser.BACKQUOTED_IDENTIFIER, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.QuotedIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 414, self.RULE_quotedIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3760
            self.match(fugue_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 fugue_sqlParser.RULE_number

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



    class DecimalLiteralContext(NumberContext):

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

        def DECIMAL_VALUE(self):
            return self.getToken(fugue_sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def BIGINT_LITERAL(self):
            return self.getToken(fugue_sqlParser.BIGINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TINYINT_LITERAL(self):
            return self.getToken(fugue_sqlParser.TINYINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXPONENT_VALUE(self):
            return self.getToken(fugue_sqlParser.EXPONENT_VALUE, 0)
        def DECIMAL_VALUE(self):
            return self.getToken(fugue_sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def BIGDECIMAL_LITERAL(self):
            return self.getToken(fugue_sqlParser.BIGDECIMAL_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXPONENT_VALUE(self):
            return self.getToken(fugue_sqlParser.EXPONENT_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DOUBLE_LITERAL(self):
            return self.getToken(fugue_sqlParser.DOUBLE_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def INTEGER_VALUE(self):
            return self.getToken(fugue_sqlParser.INTEGER_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_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 fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SMALLINT_LITERAL(self):
            return self.getToken(fugue_sqlParser.SMALLINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_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 = fugue_sqlParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 416, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.state = 3801
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,512,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.ExponentLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3762
                if not not fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "not fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled")
                self.state = 3764
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3763
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3766
                self.match(fugue_sqlParser.EXPONENT_VALUE)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.DecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3767
                if not not fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "not fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled")
                self.state = 3769
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3768
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3771
                self.match(fugue_sqlParser.DECIMAL_VALUE)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.LegacyDecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3772
                if not fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled")
                self.state = 3774
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3773
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3776
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.EXPONENT_VALUE or _la==fugue_sqlParser.DECIMAL_VALUE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.IntegerLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 3778
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3777
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3780
                self.match(fugue_sqlParser.INTEGER_VALUE)
                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.BigIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 3782
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3781
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3784
                self.match(fugue_sqlParser.BIGINT_LITERAL)
                pass

            elif la_ == 6:
                localctx = fugue_sqlParser.SmallIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 3786
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3785
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3788
                self.match(fugue_sqlParser.SMALLINT_LITERAL)
                pass

            elif la_ == 7:
                localctx = fugue_sqlParser.TinyIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 3790
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3789
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3792
                self.match(fugue_sqlParser.TINYINT_LITERAL)
                pass

            elif la_ == 8:
                localctx = fugue_sqlParser.DoubleLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 3794
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3793
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3796
                self.match(fugue_sqlParser.DOUBLE_LITERAL)
                pass

            elif la_ == 9:
                localctx = fugue_sqlParser.BigDecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 3798
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==fugue_sqlParser.MINUS:
                    self.state = 3797
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3800
                self.match(fugue_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(fugue_sqlParser.TYPE, 0)

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


        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def colPosition(self):
            return self.getTypedRuleContext(fugue_sqlParser.ColPositionContext,0)


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

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

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

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.AlterColumnActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 418, self.RULE_alterColumnAction)
        self._la = 0 # Token type
        try:
            self.state = 3810
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [fugue_sqlParser.TYPE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3803
                self.match(fugue_sqlParser.TYPE)
                self.state = 3804
                self.dataType()
                pass
            elif token in [fugue_sqlParser.COMMENT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3805
                self.commentSpec()
                pass
            elif token in [fugue_sqlParser.AFTER, fugue_sqlParser.FIRST]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3806
                self.colPosition()
                pass
            elif token in [fugue_sqlParser.DROP, fugue_sqlParser.SET]:
                self.enterOuterAlt(localctx, 4)
                self.state = 3807
                localctx.setOrDrop = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==fugue_sqlParser.DROP or _la==fugue_sqlParser.SET):
                    localctx.setOrDrop = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3808
                self.match(fugue_sqlParser.NOT)
                self.state = 3809
                self.match(fugue_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(fugue_sqlParser.ADD, 0)

        def AFTER(self):
            return self.getToken(fugue_sqlParser.AFTER, 0)

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

        def ANALYZE(self):
            return self.getToken(fugue_sqlParser.ANALYZE, 0)

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

        def ARRAY(self):
            return self.getToken(fugue_sqlParser.ARRAY, 0)

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

        def AT(self):
            return self.getToken(fugue_sqlParser.AT, 0)

        def BETWEEN(self):
            return self.getToken(fugue_sqlParser.BETWEEN, 0)

        def BUCKET(self):
            return self.getToken(fugue_sqlParser.BUCKET, 0)

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

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

        def CACHE(self):
            return self.getToken(fugue_sqlParser.CACHE, 0)

        def CASCADE(self):
            return self.getToken(fugue_sqlParser.CASCADE, 0)

        def CHANGE(self):
            return self.getToken(fugue_sqlParser.CHANGE, 0)

        def CLEAR(self):
            return self.getToken(fugue_sqlParser.CLEAR, 0)

        def CLUSTER(self):
            return self.getToken(fugue_sqlParser.CLUSTER, 0)

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

        def CODEGEN(self):
            return self.getToken(fugue_sqlParser.CODEGEN, 0)

        def COLLECTION(self):
            return self.getToken(fugue_sqlParser.COLLECTION, 0)

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

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

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

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

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

        def COMPUTE(self):
            return self.getToken(fugue_sqlParser.COMPUTE, 0)

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

        def COST(self):
            return self.getToken(fugue_sqlParser.COST, 0)

        def CUBE(self):
            return self.getToken(fugue_sqlParser.CUBE, 0)

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

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

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

        def DATABASES(self):
            return self.getToken(fugue_sqlParser.DATABASES, 0)

        def DBPROPERTIES(self):
            return self.getToken(fugue_sqlParser.DBPROPERTIES, 0)

        def DEFINED(self):
            return self.getToken(fugue_sqlParser.DEFINED, 0)

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

        def DELIMITED(self):
            return self.getToken(fugue_sqlParser.DELIMITED, 0)

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

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

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

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

        def DIRECTORY(self):
            return self.getToken(fugue_sqlParser.DIRECTORY, 0)

        def DISTRIBUTE(self):
            return self.getToken(fugue_sqlParser.DISTRIBUTE, 0)

        def DIV(self):
            return self.getToken(fugue_sqlParser.DIV, 0)

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

        def ESCAPED(self):
            return self.getToken(fugue_sqlParser.ESCAPED, 0)

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

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

        def EXPLAIN(self):
            return self.getToken(fugue_sqlParser.EXPLAIN, 0)

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

        def EXTENDED(self):
            return self.getToken(fugue_sqlParser.EXTENDED, 0)

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

        def EXTRACT(self):
            return self.getToken(fugue_sqlParser.EXTRACT, 0)

        def FIELDS(self):
            return self.getToken(fugue_sqlParser.FIELDS, 0)

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

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)

        def FOLLOWING(self):
            return self.getToken(fugue_sqlParser.FOLLOWING, 0)

        def FORMAT(self):
            return self.getToken(fugue_sqlParser.FORMAT, 0)

        def FORMATTED(self):
            return self.getToken(fugue_sqlParser.FORMATTED, 0)

        def FUNCTION(self):
            return self.getToken(fugue_sqlParser.FUNCTION, 0)

        def FUNCTIONS(self):
            return self.getToken(fugue_sqlParser.FUNCTIONS, 0)

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

        def GROUPING(self):
            return self.getToken(fugue_sqlParser.GROUPING, 0)

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

        def IGNORE(self):
            return self.getToken(fugue_sqlParser.IGNORE, 0)

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

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

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

        def INPATH(self):
            return self.getToken(fugue_sqlParser.INPATH, 0)

        def INPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.INPUTFORMAT, 0)

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

        def INTERVAL(self):
            return self.getToken(fugue_sqlParser.INTERVAL, 0)

        def ITEMS(self):
            return self.getToken(fugue_sqlParser.ITEMS, 0)

        def KEYS(self):
            return self.getToken(fugue_sqlParser.KEYS, 0)

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)

        def LATERAL(self):
            return self.getToken(fugue_sqlParser.LATERAL, 0)

        def LAZY(self):
            return self.getToken(fugue_sqlParser.LAZY, 0)

        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)

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

        def LINES(self):
            return self.getToken(fugue_sqlParser.LINES, 0)

        def LIST(self):
            return self.getToken(fugue_sqlParser.LIST, 0)

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

        def LOCAL(self):
            return self.getToken(fugue_sqlParser.LOCAL, 0)

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

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

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

        def LOGICAL(self):
            return self.getToken(fugue_sqlParser.LOGICAL, 0)

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

        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)

        def MATCHED(self):
            return self.getToken(fugue_sqlParser.MATCHED, 0)

        def MERGE(self):
            return self.getToken(fugue_sqlParser.MERGE, 0)

        def MSCK(self):
            return self.getToken(fugue_sqlParser.MSCK, 0)

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

        def NAMESPACES(self):
            return self.getToken(fugue_sqlParser.NAMESPACES, 0)

        def NO(self):
            return self.getToken(fugue_sqlParser.NO, 0)

        def NULLS(self):
            return self.getToken(fugue_sqlParser.NULLS, 0)

        def OF(self):
            return self.getToken(fugue_sqlParser.OF, 0)

        def OPTION(self):
            return self.getToken(fugue_sqlParser.OPTION, 0)

        def OPTIONS(self):
            return self.getToken(fugue_sqlParser.OPTIONS, 0)

        def OUT(self):
            return self.getToken(fugue_sqlParser.OUT, 0)

        def OUTPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.OUTPUTFORMAT, 0)

        def OVER(self):
            return self.getToken(fugue_sqlParser.OVER, 0)

        def OVERLAY(self):
            return self.getToken(fugue_sqlParser.OVERLAY, 0)

        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)

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

        def PARTITIONED(self):
            return self.getToken(fugue_sqlParser.PARTITIONED, 0)

        def PARTITIONS(self):
            return self.getToken(fugue_sqlParser.PARTITIONS, 0)

        def PERCENTLIT(self):
            return self.getToken(fugue_sqlParser.PERCENTLIT, 0)

        def PIVOT(self):
            return self.getToken(fugue_sqlParser.PIVOT, 0)

        def PLACING(self):
            return self.getToken(fugue_sqlParser.PLACING, 0)

        def POSITION(self):
            return self.getToken(fugue_sqlParser.POSITION, 0)

        def PRECEDING(self):
            return self.getToken(fugue_sqlParser.PRECEDING, 0)

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

        def PROPERTIES(self):
            return self.getToken(fugue_sqlParser.PROPERTIES, 0)

        def PURGE(self):
            return self.getToken(fugue_sqlParser.PURGE, 0)

        def QUERY(self):
            return self.getToken(fugue_sqlParser.QUERY, 0)

        def RANGE(self):
            return self.getToken(fugue_sqlParser.RANGE, 0)

        def RECORDREADER(self):
            return self.getToken(fugue_sqlParser.RECORDREADER, 0)

        def RECORDWRITER(self):
            return self.getToken(fugue_sqlParser.RECORDWRITER, 0)

        def RECOVER(self):
            return self.getToken(fugue_sqlParser.RECOVER, 0)

        def REDUCE(self):
            return self.getToken(fugue_sqlParser.REDUCE, 0)

        def REFRESH(self):
            return self.getToken(fugue_sqlParser.REFRESH, 0)

        def RENAME(self):
            return self.getToken(fugue_sqlParser.RENAME, 0)

        def REPAIR(self):
            return self.getToken(fugue_sqlParser.REPAIR, 0)

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

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

        def RESTRICT(self):
            return self.getToken(fugue_sqlParser.RESTRICT, 0)

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

        def RLIKE(self):
            return self.getToken(fugue_sqlParser.RLIKE, 0)

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

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

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

        def ROLLUP(self):
            return self.getToken(fugue_sqlParser.ROLLUP, 0)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

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

        def SEPARATED(self):
            return self.getToken(fugue_sqlParser.SEPARATED, 0)

        def SERDE(self):
            return self.getToken(fugue_sqlParser.SERDE, 0)

        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)

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

        def SETS(self):
            return self.getToken(fugue_sqlParser.SETS, 0)

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

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

        def SORT(self):
            return self.getToken(fugue_sqlParser.SORT, 0)

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

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

        def STATISTICS(self):
            return self.getToken(fugue_sqlParser.STATISTICS, 0)

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

        def STRATIFY(self):
            return self.getToken(fugue_sqlParser.STRATIFY, 0)

        def STRUCT(self):
            return self.getToken(fugue_sqlParser.STRUCT, 0)

        def SUBSTR(self):
            return self.getToken(fugue_sqlParser.SUBSTR, 0)

        def SUBSTRING(self):
            return self.getToken(fugue_sqlParser.SUBSTRING, 0)

        def TABLES(self):
            return self.getToken(fugue_sqlParser.TABLES, 0)

        def TABLESAMPLE(self):
            return self.getToken(fugue_sqlParser.TABLESAMPLE, 0)

        def TBLPROPERTIES(self):
            return self.getToken(fugue_sqlParser.TBLPROPERTIES, 0)

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

        def TERMINATED(self):
            return self.getToken(fugue_sqlParser.TERMINATED, 0)

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

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

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

        def TRANSFORM(self):
            return self.getToken(fugue_sqlParser.TRANSFORM, 0)

        def TRIM(self):
            return self.getToken(fugue_sqlParser.TRIM, 0)

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

        def TRUNCATE(self):
            return self.getToken(fugue_sqlParser.TRUNCATE, 0)

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

        def UNBOUNDED(self):
            return self.getToken(fugue_sqlParser.UNBOUNDED, 0)

        def UNCACHE(self):
            return self.getToken(fugue_sqlParser.UNCACHE, 0)

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

        def UNSET(self):
            return self.getToken(fugue_sqlParser.UNSET, 0)

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

        def USE(self):
            return self.getToken(fugue_sqlParser.USE, 0)

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

        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)

        def VIEWS(self):
            return self.getToken(fugue_sqlParser.VIEWS, 0)

        def WINDOW(self):
            return self.getToken(fugue_sqlParser.WINDOW, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.AnsiNonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 420, self.RULE_ansiNonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3812
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << fugue_sqlParser.ADD) | (1 << fugue_sqlParser.AFTER) | (1 << fugue_sqlParser.ALTER) | (1 << fugue_sqlParser.ANALYZE) | (1 << fugue_sqlParser.ARCHIVE) | (1 << fugue_sqlParser.ARRAY))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (fugue_sqlParser.ASC - 65)) | (1 << (fugue_sqlParser.AT - 65)) | (1 << (fugue_sqlParser.BETWEEN - 65)) | (1 << (fugue_sqlParser.BUCKET - 65)) | (1 << (fugue_sqlParser.BUCKETS - 65)) | (1 << (fugue_sqlParser.BY - 65)) | (1 << (fugue_sqlParser.CACHE - 65)) | (1 << (fugue_sqlParser.CASCADE - 65)) | (1 << (fugue_sqlParser.CHANGE - 65)) | (1 << (fugue_sqlParser.CLEAR - 65)) | (1 << (fugue_sqlParser.CLUSTER - 65)) | (1 << (fugue_sqlParser.CLUSTERED - 65)) | (1 << (fugue_sqlParser.CODEGEN - 65)) | (1 << (fugue_sqlParser.COLLECTION - 65)) | (1 << (fugue_sqlParser.COLUMNS - 65)) | (1 << (fugue_sqlParser.COMMENT - 65)) | (1 << (fugue_sqlParser.COMMIT - 65)) | (1 << (fugue_sqlParser.COMPACT - 65)) | (1 << (fugue_sqlParser.COMPACTIONS - 65)) | (1 << (fugue_sqlParser.COMPUTE - 65)) | (1 << (fugue_sqlParser.CONCATENATE - 65)) | (1 << (fugue_sqlParser.COST - 65)) | (1 << (fugue_sqlParser.CUBE - 65)) | (1 << (fugue_sqlParser.CURRENT - 65)) | (1 << (fugue_sqlParser.DATA - 65)) | (1 << (fugue_sqlParser.DATABASE - 65)) | (1 << (fugue_sqlParser.DATABASES - 65)) | (1 << (fugue_sqlParser.DBPROPERTIES - 65)) | (1 << (fugue_sqlParser.DEFINED - 65)) | (1 << (fugue_sqlParser.DELETE - 65)) | (1 << (fugue_sqlParser.DELIMITED - 65)) | (1 << (fugue_sqlParser.DESC - 65)) | (1 << (fugue_sqlParser.DESCRIBE - 65)) | (1 << (fugue_sqlParser.DFS - 65)) | (1 << (fugue_sqlParser.DIRECTORIES - 65)) | (1 << (fugue_sqlParser.DIRECTORY - 65)) | (1 << (fugue_sqlParser.DISTRIBUTE - 65)) | (1 << (fugue_sqlParser.DROP - 65)) | (1 << (fugue_sqlParser.ESCAPED - 65)) | (1 << (fugue_sqlParser.EXCHANGE - 65)) | (1 << (fugue_sqlParser.EXISTS - 65)) | (1 << (fugue_sqlParser.EXPLAIN - 65)) | (1 << (fugue_sqlParser.EXPORT - 65)) | (1 << (fugue_sqlParser.EXTENDED - 65)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (fugue_sqlParser.EXTERNAL - 129)) | (1 << (fugue_sqlParser.EXTRACT - 129)) | (1 << (fugue_sqlParser.FIELDS - 129)) | (1 << (fugue_sqlParser.FILEFORMAT - 129)) | (1 << (fugue_sqlParser.FIRST - 129)) | (1 << (fugue_sqlParser.FOLLOWING - 129)) | (1 << (fugue_sqlParser.FORMAT - 129)) | (1 << (fugue_sqlParser.FORMATTED - 129)) | (1 << (fugue_sqlParser.FUNCTION - 129)) | (1 << (fugue_sqlParser.FUNCTIONS - 129)) | (1 << (fugue_sqlParser.GLOBAL - 129)) | (1 << (fugue_sqlParser.GROUPING - 129)) | (1 << (fugue_sqlParser.IF - 129)) | (1 << (fugue_sqlParser.IGNORE - 129)) | (1 << (fugue_sqlParser.IMPORT - 129)) | (1 << (fugue_sqlParser.INDEX - 129)) | (1 << (fugue_sqlParser.INDEXES - 129)) | (1 << (fugue_sqlParser.INPATH - 129)) | (1 << (fugue_sqlParser.INPUTFORMAT - 129)) | (1 << (fugue_sqlParser.INSERT - 129)) | (1 << (fugue_sqlParser.INTERVAL - 129)) | (1 << (fugue_sqlParser.ITEMS - 129)) | (1 << (fugue_sqlParser.KEYS - 129)) | (1 << (fugue_sqlParser.LAST - 129)) | (1 << (fugue_sqlParser.LATERAL - 129)) | (1 << (fugue_sqlParser.LAZY - 129)) | (1 << (fugue_sqlParser.LIKE - 129)) | (1 << (fugue_sqlParser.LIMIT - 129)) | (1 << (fugue_sqlParser.LINES - 129)) | (1 << (fugue_sqlParser.LIST - 129)) | (1 << (fugue_sqlParser.LOAD - 129)) | (1 << (fugue_sqlParser.LOCAL - 129)) | (1 << (fugue_sqlParser.LOCATION - 129)) | (1 << (fugue_sqlParser.LOCK - 129)) | (1 << (fugue_sqlParser.LOCKS - 129)) | (1 << (fugue_sqlParser.LOGICAL - 129)) | (1 << (fugue_sqlParser.MACRO - 129)) | (1 << (fugue_sqlParser.MAP - 129)) | (1 << (fugue_sqlParser.MATCHED - 129)) | (1 << (fugue_sqlParser.MERGE - 129)) | (1 << (fugue_sqlParser.MSCK - 129)) | (1 << (fugue_sqlParser.NAMESPACE - 129)) | (1 << (fugue_sqlParser.NAMESPACES - 129)))) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & ((1 << (fugue_sqlParser.NO - 194)) | (1 << (fugue_sqlParser.NULLS - 194)) | (1 << (fugue_sqlParser.OF - 194)) | (1 << (fugue_sqlParser.OPTION - 194)) | (1 << (fugue_sqlParser.OPTIONS - 194)) | (1 << (fugue_sqlParser.OUT - 194)) | (1 << (fugue_sqlParser.OUTPUTFORMAT - 194)) | (1 << (fugue_sqlParser.OVER - 194)) | (1 << (fugue_sqlParser.OVERLAY - 194)) | (1 << (fugue_sqlParser.OVERWRITE - 194)) | (1 << (fugue_sqlParser.PARTITION - 194)) | (1 << (fugue_sqlParser.PARTITIONED - 194)) | (1 << (fugue_sqlParser.PARTITIONS - 194)) | (1 << (fugue_sqlParser.PERCENTLIT - 194)) | (1 << (fugue_sqlParser.PIVOT - 194)) | (1 << (fugue_sqlParser.PLACING - 194)) | (1 << (fugue_sqlParser.POSITION - 194)) | (1 << (fugue_sqlParser.PRECEDING - 194)) | (1 << (fugue_sqlParser.PRINCIPALS - 194)) | (1 << (fugue_sqlParser.PROPERTIES - 194)) | (1 << (fugue_sqlParser.PURGE - 194)) | (1 << (fugue_sqlParser.QUERY - 194)) | (1 << (fugue_sqlParser.RANGE - 194)) | (1 << (fugue_sqlParser.RECORDREADER - 194)) | (1 << (fugue_sqlParser.RECORDWRITER - 194)) | (1 << (fugue_sqlParser.RECOVER - 194)) | (1 << (fugue_sqlParser.REDUCE - 194)) | (1 << (fugue_sqlParser.REFRESH - 194)) | (1 << (fugue_sqlParser.RENAME - 194)) | (1 << (fugue_sqlParser.REPAIR - 194)) | (1 << (fugue_sqlParser.REPLACE - 194)) | (1 << (fugue_sqlParser.RESET - 194)) | (1 << (fugue_sqlParser.RESTRICT - 194)) | (1 << (fugue_sqlParser.REVOKE - 194)) | (1 << (fugue_sqlParser.RLIKE - 194)) | (1 << (fugue_sqlParser.ROLE - 194)) | (1 << (fugue_sqlParser.ROLES - 194)) | (1 << (fugue_sqlParser.ROLLBACK - 194)) | (1 << (fugue_sqlParser.ROLLUP - 194)) | (1 << (fugue_sqlParser.ROW - 194)) | (1 << (fugue_sqlParser.ROWS - 194)) | (1 << (fugue_sqlParser.SCHEMA - 194)) | (1 << (fugue_sqlParser.SEPARATED - 194)) | (1 << (fugue_sqlParser.SERDE - 194)) | (1 << (fugue_sqlParser.SERDEPROPERTIES - 194)) | (1 << (fugue_sqlParser.SET - 194)) | (1 << (fugue_sqlParser.SETS - 194)) | (1 << (fugue_sqlParser.SHOW - 194)))) != 0) or ((((_la - 258)) & ~0x3f) == 0 and ((1 << (_la - 258)) & ((1 << (fugue_sqlParser.SKEWED - 258)) | (1 << (fugue_sqlParser.SORT - 258)) | (1 << (fugue_sqlParser.SORTED - 258)) | (1 << (fugue_sqlParser.START - 258)) | (1 << (fugue_sqlParser.STATISTICS - 258)) | (1 << (fugue_sqlParser.STORED - 258)) | (1 << (fugue_sqlParser.STRATIFY - 258)) | (1 << (fugue_sqlParser.STRUCT - 258)) | (1 << (fugue_sqlParser.SUBSTR - 258)) | (1 << (fugue_sqlParser.SUBSTRING - 258)) | (1 << (fugue_sqlParser.TABLES - 258)) | (1 << (fugue_sqlParser.TABLESAMPLE - 258)) | (1 << (fugue_sqlParser.TBLPROPERTIES - 258)) | (1 << (fugue_sqlParser.TEMPORARY - 258)) | (1 << (fugue_sqlParser.TERMINATED - 258)) | (1 << (fugue_sqlParser.TOUCH - 258)) | (1 << (fugue_sqlParser.TRANSACTION - 258)) | (1 << (fugue_sqlParser.TRANSACTIONS - 258)) | (1 << (fugue_sqlParser.TRANSFORM - 258)) | (1 << (fugue_sqlParser.TRIM - 258)) | (1 << (fugue_sqlParser.TRUE - 258)) | (1 << (fugue_sqlParser.TRUNCATE - 258)) | (1 << (fugue_sqlParser.UNARCHIVE - 258)) | (1 << (fugue_sqlParser.UNBOUNDED - 258)) | (1 << (fugue_sqlParser.UNCACHE - 258)) | (1 << (fugue_sqlParser.UNLOCK - 258)) | (1 << (fugue_sqlParser.UNSET - 258)) | (1 << (fugue_sqlParser.UPDATE - 258)) | (1 << (fugue_sqlParser.USE - 258)) | (1 << (fugue_sqlParser.VALUES - 258)) | (1 << (fugue_sqlParser.VIEW - 258)) | (1 << (fugue_sqlParser.VIEWS - 258)) | (1 << (fugue_sqlParser.WINDOW - 258)) | (1 << (fugue_sqlParser.DIV - 258)))) != 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(fugue_sqlParser.ANTI, 0)

        def CROSS(self):
            return self.getToken(fugue_sqlParser.CROSS, 0)

        def EXCEPT(self):
            return self.getToken(fugue_sqlParser.EXCEPT, 0)

        def FULL(self):
            return self.getToken(fugue_sqlParser.FULL, 0)

        def INNER(self):
            return self.getToken(fugue_sqlParser.INNER, 0)

        def INTERSECT(self):
            return self.getToken(fugue_sqlParser.INTERSECT, 0)

        def JOIN(self):
            return self.getToken(fugue_sqlParser.JOIN, 0)

        def LEFT(self):
            return self.getToken(fugue_sqlParser.LEFT, 0)

        def NATURAL(self):
            return self.getToken(fugue_sqlParser.NATURAL, 0)

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

        def RIGHT(self):
            return self.getToken(fugue_sqlParser.RIGHT, 0)

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

        def SETMINUS(self):
            return self.getToken(fugue_sqlParser.SETMINUS, 0)

        def UNION(self):
            return self.getToken(fugue_sqlParser.UNION, 0)

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

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.StrictNonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 422, self.RULE_strictNonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3814
            _la = self._input.LA(1)
            if not(((((_la - 60)) & ~0x3f) == 0 and ((1 << (_la - 60)) & ((1 << (fugue_sqlParser.ANTI - 60)) | (1 << (fugue_sqlParser.CROSS - 60)) | (1 << (fugue_sqlParser.EXCEPT - 60)))) != 0) or ((((_la - 143)) & ~0x3f) == 0 and ((1 << (_la - 143)) & ((1 << (fugue_sqlParser.FULL - 143)) | (1 << (fugue_sqlParser.INNER - 143)) | (1 << (fugue_sqlParser.INTERSECT - 143)) | (1 << (fugue_sqlParser.JOIN - 143)) | (1 << (fugue_sqlParser.LEFT - 143)) | (1 << (fugue_sqlParser.NATURAL - 143)) | (1 << (fugue_sqlParser.ON - 143)))) != 0) or ((((_la - 238)) & ~0x3f) == 0 and ((1 << (_la - 238)) & ((1 << (fugue_sqlParser.RIGHT - 238)) | (1 << (fugue_sqlParser.SEMI - 238)) | (1 << (fugue_sqlParser.SETMINUS - 238)) | (1 << (fugue_sqlParser.UNION - 238)) | (1 << (fugue_sqlParser.USING - 238)))) != 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(fugue_sqlParser.ADD, 0)

        def AFTER(self):
            return self.getToken(fugue_sqlParser.AFTER, 0)

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

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

        def ANALYZE(self):
            return self.getToken(fugue_sqlParser.ANALYZE, 0)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def ANY(self):
            return self.getToken(fugue_sqlParser.ANY, 0)

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

        def ARRAY(self):
            return self.getToken(fugue_sqlParser.ARRAY, 0)

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

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

        def AT(self):
            return self.getToken(fugue_sqlParser.AT, 0)

        def AUTHORIZATION(self):
            return self.getToken(fugue_sqlParser.AUTHORIZATION, 0)

        def BETWEEN(self):
            return self.getToken(fugue_sqlParser.BETWEEN, 0)

        def BOTH(self):
            return self.getToken(fugue_sqlParser.BOTH, 0)

        def BUCKET(self):
            return self.getToken(fugue_sqlParser.BUCKET, 0)

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

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

        def CACHE(self):
            return self.getToken(fugue_sqlParser.CACHE, 0)

        def CASCADE(self):
            return self.getToken(fugue_sqlParser.CASCADE, 0)

        def CASE(self):
            return self.getToken(fugue_sqlParser.CASE, 0)

        def CAST(self):
            return self.getToken(fugue_sqlParser.CAST, 0)

        def CHANGE(self):
            return self.getToken(fugue_sqlParser.CHANGE, 0)

        def CHECK(self):
            return self.getToken(fugue_sqlParser.CHECK, 0)

        def CLEAR(self):
            return self.getToken(fugue_sqlParser.CLEAR, 0)

        def CLUSTER(self):
            return self.getToken(fugue_sqlParser.CLUSTER, 0)

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

        def CODEGEN(self):
            return self.getToken(fugue_sqlParser.CODEGEN, 0)

        def COLLATE(self):
            return self.getToken(fugue_sqlParser.COLLATE, 0)

        def COLLECTION(self):
            return self.getToken(fugue_sqlParser.COLLECTION, 0)

        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)

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

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

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

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

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

        def COMPUTE(self):
            return self.getToken(fugue_sqlParser.COMPUTE, 0)

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

        def CONSTRAINT(self):
            return self.getToken(fugue_sqlParser.CONSTRAINT, 0)

        def COST(self):
            return self.getToken(fugue_sqlParser.COST, 0)

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

        def CUBE(self):
            return self.getToken(fugue_sqlParser.CUBE, 0)

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

        def CURRENT_DATE(self):
            return self.getToken(fugue_sqlParser.CURRENT_DATE, 0)

        def CURRENT_TIME(self):
            return self.getToken(fugue_sqlParser.CURRENT_TIME, 0)

        def CURRENT_TIMESTAMP(self):
            return self.getToken(fugue_sqlParser.CURRENT_TIMESTAMP, 0)

        def CURRENT_USER(self):
            return self.getToken(fugue_sqlParser.CURRENT_USER, 0)

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

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

        def DATABASES(self):
            return self.getToken(fugue_sqlParser.DATABASES, 0)

        def DAY(self):
            return self.getToken(fugue_sqlParser.DAY, 0)

        def DBPROPERTIES(self):
            return self.getToken(fugue_sqlParser.DBPROPERTIES, 0)

        def DEFINED(self):
            return self.getToken(fugue_sqlParser.DEFINED, 0)

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

        def DELIMITED(self):
            return self.getToken(fugue_sqlParser.DELIMITED, 0)

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

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

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

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

        def DIRECTORY(self):
            return self.getToken(fugue_sqlParser.DIRECTORY, 0)

        def DISTINCT(self):
            return self.getToken(fugue_sqlParser.DISTINCT, 0)

        def DISTRIBUTE(self):
            return self.getToken(fugue_sqlParser.DISTRIBUTE, 0)

        def DIV(self):
            return self.getToken(fugue_sqlParser.DIV, 0)

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

        def ELSE(self):
            return self.getToken(fugue_sqlParser.ELSE, 0)

        def END(self):
            return self.getToken(fugue_sqlParser.END, 0)

        def ESCAPE(self):
            return self.getToken(fugue_sqlParser.ESCAPE, 0)

        def ESCAPED(self):
            return self.getToken(fugue_sqlParser.ESCAPED, 0)

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

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

        def EXPLAIN(self):
            return self.getToken(fugue_sqlParser.EXPLAIN, 0)

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

        def EXTENDED(self):
            return self.getToken(fugue_sqlParser.EXTENDED, 0)

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

        def EXTRACT(self):
            return self.getToken(fugue_sqlParser.EXTRACT, 0)

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

        def FETCH(self):
            return self.getToken(fugue_sqlParser.FETCH, 0)

        def FILTER(self):
            return self.getToken(fugue_sqlParser.FILTER, 0)

        def FIELDS(self):
            return self.getToken(fugue_sqlParser.FIELDS, 0)

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

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)

        def FOLLOWING(self):
            return self.getToken(fugue_sqlParser.FOLLOWING, 0)

        def FOR(self):
            return self.getToken(fugue_sqlParser.FOR, 0)

        def FOREIGN(self):
            return self.getToken(fugue_sqlParser.FOREIGN, 0)

        def FORMAT(self):
            return self.getToken(fugue_sqlParser.FORMAT, 0)

        def FORMATTED(self):
            return self.getToken(fugue_sqlParser.FORMATTED, 0)

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

        def FUNCTION(self):
            return self.getToken(fugue_sqlParser.FUNCTION, 0)

        def FUNCTIONS(self):
            return self.getToken(fugue_sqlParser.FUNCTIONS, 0)

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

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

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

        def GROUPING(self):
            return self.getToken(fugue_sqlParser.GROUPING, 0)

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

        def HOUR(self):
            return self.getToken(fugue_sqlParser.HOUR, 0)

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

        def IGNORE(self):
            return self.getToken(fugue_sqlParser.IGNORE, 0)

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

        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)

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

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

        def INPATH(self):
            return self.getToken(fugue_sqlParser.INPATH, 0)

        def INPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.INPUTFORMAT, 0)

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

        def INTERVAL(self):
            return self.getToken(fugue_sqlParser.INTERVAL, 0)

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

        def IS(self):
            return self.getToken(fugue_sqlParser.IS, 0)

        def ITEMS(self):
            return self.getToken(fugue_sqlParser.ITEMS, 0)

        def KEYS(self):
            return self.getToken(fugue_sqlParser.KEYS, 0)

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)

        def LATERAL(self):
            return self.getToken(fugue_sqlParser.LATERAL, 0)

        def LAZY(self):
            return self.getToken(fugue_sqlParser.LAZY, 0)

        def LEADING(self):
            return self.getToken(fugue_sqlParser.LEADING, 0)

        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)

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

        def LINES(self):
            return self.getToken(fugue_sqlParser.LINES, 0)

        def LIST(self):
            return self.getToken(fugue_sqlParser.LIST, 0)

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

        def LOCAL(self):
            return self.getToken(fugue_sqlParser.LOCAL, 0)

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

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

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

        def LOGICAL(self):
            return self.getToken(fugue_sqlParser.LOGICAL, 0)

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

        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)

        def MATCHED(self):
            return self.getToken(fugue_sqlParser.MATCHED, 0)

        def MERGE(self):
            return self.getToken(fugue_sqlParser.MERGE, 0)

        def MINUTE(self):
            return self.getToken(fugue_sqlParser.MINUTE, 0)

        def MONTH(self):
            return self.getToken(fugue_sqlParser.MONTH, 0)

        def MSCK(self):
            return self.getToken(fugue_sqlParser.MSCK, 0)

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

        def NAMESPACES(self):
            return self.getToken(fugue_sqlParser.NAMESPACES, 0)

        def NO(self):
            return self.getToken(fugue_sqlParser.NO, 0)

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

        def NULL(self):
            return self.getToken(fugue_sqlParser.NULL, 0)

        def NULLS(self):
            return self.getToken(fugue_sqlParser.NULLS, 0)

        def OF(self):
            return self.getToken(fugue_sqlParser.OF, 0)

        def ONLY(self):
            return self.getToken(fugue_sqlParser.ONLY, 0)

        def OPTION(self):
            return self.getToken(fugue_sqlParser.OPTION, 0)

        def OPTIONS(self):
            return self.getToken(fugue_sqlParser.OPTIONS, 0)

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

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

        def OUT(self):
            return self.getToken(fugue_sqlParser.OUT, 0)

        def OUTER(self):
            return self.getToken(fugue_sqlParser.OUTER, 0)

        def OUTPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.OUTPUTFORMAT, 0)

        def OVER(self):
            return self.getToken(fugue_sqlParser.OVER, 0)

        def OVERLAPS(self):
            return self.getToken(fugue_sqlParser.OVERLAPS, 0)

        def OVERLAY(self):
            return self.getToken(fugue_sqlParser.OVERLAY, 0)

        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)

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

        def PARTITIONED(self):
            return self.getToken(fugue_sqlParser.PARTITIONED, 0)

        def PARTITIONS(self):
            return self.getToken(fugue_sqlParser.PARTITIONS, 0)

        def PERCENTLIT(self):
            return self.getToken(fugue_sqlParser.PERCENTLIT, 0)

        def PIVOT(self):
            return self.getToken(fugue_sqlParser.PIVOT, 0)

        def PLACING(self):
            return self.getToken(fugue_sqlParser.PLACING, 0)

        def POSITION(self):
            return self.getToken(fugue_sqlParser.POSITION, 0)

        def PRECEDING(self):
            return self.getToken(fugue_sqlParser.PRECEDING, 0)

        def PRIMARY(self):
            return self.getToken(fugue_sqlParser.PRIMARY, 0)

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

        def PROPERTIES(self):
            return self.getToken(fugue_sqlParser.PROPERTIES, 0)

        def PURGE(self):
            return self.getToken(fugue_sqlParser.PURGE, 0)

        def QUERY(self):
            return self.getToken(fugue_sqlParser.QUERY, 0)

        def RANGE(self):
            return self.getToken(fugue_sqlParser.RANGE, 0)

        def RECORDREADER(self):
            return self.getToken(fugue_sqlParser.RECORDREADER, 0)

        def RECORDWRITER(self):
            return self.getToken(fugue_sqlParser.RECORDWRITER, 0)

        def RECOVER(self):
            return self.getToken(fugue_sqlParser.RECOVER, 0)

        def REDUCE(self):
            return self.getToken(fugue_sqlParser.REDUCE, 0)

        def REFERENCES(self):
            return self.getToken(fugue_sqlParser.REFERENCES, 0)

        def REFRESH(self):
            return self.getToken(fugue_sqlParser.REFRESH, 0)

        def RENAME(self):
            return self.getToken(fugue_sqlParser.RENAME, 0)

        def REPAIR(self):
            return self.getToken(fugue_sqlParser.REPAIR, 0)

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

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

        def RESTRICT(self):
            return self.getToken(fugue_sqlParser.RESTRICT, 0)

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

        def RLIKE(self):
            return self.getToken(fugue_sqlParser.RLIKE, 0)

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

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

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

        def ROLLUP(self):
            return self.getToken(fugue_sqlParser.ROLLUP, 0)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

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

        def SECOND(self):
            return self.getToken(fugue_sqlParser.SECOND, 0)

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

        def SEPARATED(self):
            return self.getToken(fugue_sqlParser.SEPARATED, 0)

        def SERDE(self):
            return self.getToken(fugue_sqlParser.SERDE, 0)

        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)

        def SESSION_USER(self):
            return self.getToken(fugue_sqlParser.SESSION_USER, 0)

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

        def SETS(self):
            return self.getToken(fugue_sqlParser.SETS, 0)

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

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

        def SOME(self):
            return self.getToken(fugue_sqlParser.SOME, 0)

        def SORT(self):
            return self.getToken(fugue_sqlParser.SORT, 0)

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

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

        def STATISTICS(self):
            return self.getToken(fugue_sqlParser.STATISTICS, 0)

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

        def STRATIFY(self):
            return self.getToken(fugue_sqlParser.STRATIFY, 0)

        def STRUCT(self):
            return self.getToken(fugue_sqlParser.STRUCT, 0)

        def SUBSTR(self):
            return self.getToken(fugue_sqlParser.SUBSTR, 0)

        def SUBSTRING(self):
            return self.getToken(fugue_sqlParser.SUBSTRING, 0)

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

        def TABLES(self):
            return self.getToken(fugue_sqlParser.TABLES, 0)

        def TABLESAMPLE(self):
            return self.getToken(fugue_sqlParser.TABLESAMPLE, 0)

        def TBLPROPERTIES(self):
            return self.getToken(fugue_sqlParser.TBLPROPERTIES, 0)

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

        def TERMINATED(self):
            return self.getToken(fugue_sqlParser.TERMINATED, 0)

        def THEN(self):
            return self.getToken(fugue_sqlParser.THEN, 0)

        def TO(self):
            return self.getToken(fugue_sqlParser.TO, 0)

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

        def TRAILING(self):
            return self.getToken(fugue_sqlParser.TRAILING, 0)

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

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

        def TRANSFORM(self):
            return self.getToken(fugue_sqlParser.TRANSFORM, 0)

        def TRIM(self):
            return self.getToken(fugue_sqlParser.TRIM, 0)

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

        def TRUNCATE(self):
            return self.getToken(fugue_sqlParser.TRUNCATE, 0)

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

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

        def UNBOUNDED(self):
            return self.getToken(fugue_sqlParser.UNBOUNDED, 0)

        def UNCACHE(self):
            return self.getToken(fugue_sqlParser.UNCACHE, 0)

        def UNIQUE(self):
            return self.getToken(fugue_sqlParser.UNIQUE, 0)

        def UNKNOWN(self):
            return self.getToken(fugue_sqlParser.UNKNOWN, 0)

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

        def UNSET(self):
            return self.getToken(fugue_sqlParser.UNSET, 0)

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

        def USE(self):
            return self.getToken(fugue_sqlParser.USE, 0)

        def USER(self):
            return self.getToken(fugue_sqlParser.USER, 0)

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

        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)

        def VIEWS(self):
            return self.getToken(fugue_sqlParser.VIEWS, 0)

        def WHEN(self):
            return self.getToken(fugue_sqlParser.WHEN, 0)

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

        def WINDOW(self):
            return self.getToken(fugue_sqlParser.WINDOW, 0)

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

        def YEAR(self):
            return self.getToken(fugue_sqlParser.YEAR, 0)

        def getRuleIndex(self):
            return fugue_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 = fugue_sqlParser.NonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 424, self.RULE_nonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3816
            _la = self._input.LA(1)
            if not(((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (fugue_sqlParser.ADD - 54)) | (1 << (fugue_sqlParser.AFTER - 54)) | (1 << (fugue_sqlParser.ALL - 54)) | (1 << (fugue_sqlParser.ALTER - 54)) | (1 << (fugue_sqlParser.ANALYZE - 54)) | (1 << (fugue_sqlParser.AND - 54)) | (1 << (fugue_sqlParser.ANY - 54)) | (1 << (fugue_sqlParser.ARCHIVE - 54)) | (1 << (fugue_sqlParser.ARRAY - 54)) | (1 << (fugue_sqlParser.AS - 54)) | (1 << (fugue_sqlParser.ASC - 54)) | (1 << (fugue_sqlParser.AT - 54)) | (1 << (fugue_sqlParser.AUTHORIZATION - 54)) | (1 << (fugue_sqlParser.BETWEEN - 54)) | (1 << (fugue_sqlParser.BOTH - 54)) | (1 << (fugue_sqlParser.BUCKET - 54)) | (1 << (fugue_sqlParser.BUCKETS - 54)) | (1 << (fugue_sqlParser.BY - 54)) | (1 << (fugue_sqlParser.CACHE - 54)) | (1 << (fugue_sqlParser.CASCADE - 54)) | (1 << (fugue_sqlParser.CASE - 54)) | (1 << (fugue_sqlParser.CAST - 54)) | (1 << (fugue_sqlParser.CHANGE - 54)) | (1 << (fugue_sqlParser.CHECK - 54)) | (1 << (fugue_sqlParser.CLEAR - 54)) | (1 << (fugue_sqlParser.CLUSTER - 54)) | (1 << (fugue_sqlParser.CLUSTERED - 54)) | (1 << (fugue_sqlParser.CODEGEN - 54)) | (1 << (fugue_sqlParser.COLLATE - 54)) | (1 << (fugue_sqlParser.COLLECTION - 54)) | (1 << (fugue_sqlParser.COLUMN - 54)) | (1 << (fugue_sqlParser.COLUMNS - 54)) | (1 << (fugue_sqlParser.COMMENT - 54)) | (1 << (fugue_sqlParser.COMMIT - 54)) | (1 << (fugue_sqlParser.COMPACT - 54)) | (1 << (fugue_sqlParser.COMPACTIONS - 54)) | (1 << (fugue_sqlParser.COMPUTE - 54)) | (1 << (fugue_sqlParser.CONCATENATE - 54)) | (1 << (fugue_sqlParser.CONSTRAINT - 54)) | (1 << (fugue_sqlParser.COST - 54)) | (1 << (fugue_sqlParser.CREATE - 54)) | (1 << (fugue_sqlParser.CUBE - 54)) | (1 << (fugue_sqlParser.CURRENT - 54)) | (1 << (fugue_sqlParser.CURRENT_DATE - 54)) | (1 << (fugue_sqlParser.CURRENT_TIME - 54)) | (1 << (fugue_sqlParser.CURRENT_TIMESTAMP - 54)) | (1 << (fugue_sqlParser.CURRENT_USER - 54)) | (1 << (fugue_sqlParser.DATA - 54)) | (1 << (fugue_sqlParser.DATABASE - 54)) | (1 << (fugue_sqlParser.DATABASES - 54)) | (1 << (fugue_sqlParser.DAY - 54)) | (1 << (fugue_sqlParser.DBPROPERTIES - 54)) | (1 << (fugue_sqlParser.DEFINED - 54)) | (1 << (fugue_sqlParser.DELETE - 54)) | (1 << (fugue_sqlParser.DELIMITED - 54)) | (1 << (fugue_sqlParser.DESC - 54)) | (1 << (fugue_sqlParser.DESCRIBE - 54)) | (1 << (fugue_sqlParser.DFS - 54)) | (1 << (fugue_sqlParser.DIRECTORIES - 54)) | (1 << (fugue_sqlParser.DIRECTORY - 54)) | (1 << (fugue_sqlParser.DISTINCT - 54)) | (1 << (fugue_sqlParser.DISTRIBUTE - 54)))) != 0) or ((((_la - 118)) & ~0x3f) == 0 and ((1 << (_la - 118)) & ((1 << (fugue_sqlParser.DROP - 118)) | (1 << (fugue_sqlParser.ELSE - 118)) | (1 << (fugue_sqlParser.END - 118)) | (1 << (fugue_sqlParser.ESCAPE - 118)) | (1 << (fugue_sqlParser.ESCAPED - 118)) | (1 << (fugue_sqlParser.EXCHANGE - 118)) | (1 << (fugue_sqlParser.EXISTS - 118)) | (1 << (fugue_sqlParser.EXPLAIN - 118)) | (1 << (fugue_sqlParser.EXPORT - 118)) | (1 << (fugue_sqlParser.EXTENDED - 118)) | (1 << (fugue_sqlParser.EXTERNAL - 118)) | (1 << (fugue_sqlParser.EXTRACT - 118)) | (1 << (fugue_sqlParser.FALSE - 118)) | (1 << (fugue_sqlParser.FETCH - 118)) | (1 << (fugue_sqlParser.FIELDS - 118)) | (1 << (fugue_sqlParser.FILTER - 118)) | (1 << (fugue_sqlParser.FILEFORMAT - 118)) | (1 << (fugue_sqlParser.FIRST - 118)) | (1 << (fugue_sqlParser.FOLLOWING - 118)) | (1 << (fugue_sqlParser.FOR - 118)) | (1 << (fugue_sqlParser.FOREIGN - 118)) | (1 << (fugue_sqlParser.FORMAT - 118)) | (1 << (fugue_sqlParser.FORMATTED - 118)) | (1 << (fugue_sqlParser.FROM - 118)) | (1 << (fugue_sqlParser.FUNCTION - 118)) | (1 << (fugue_sqlParser.FUNCTIONS - 118)) | (1 << (fugue_sqlParser.GLOBAL - 118)) | (1 << (fugue_sqlParser.GRANT - 118)) | (1 << (fugue_sqlParser.GROUP - 118)) | (1 << (fugue_sqlParser.GROUPING - 118)) | (1 << (fugue_sqlParser.HAVING - 118)) | (1 << (fugue_sqlParser.HOUR - 118)) | (1 << (fugue_sqlParser.IF - 118)) | (1 << (fugue_sqlParser.IGNORE - 118)) | (1 << (fugue_sqlParser.IMPORT - 118)) | (1 << (fugue_sqlParser.IN - 118)) | (1 << (fugue_sqlParser.INDEX - 118)) | (1 << (fugue_sqlParser.INDEXES - 118)) | (1 << (fugue_sqlParser.INPATH - 118)) | (1 << (fugue_sqlParser.INPUTFORMAT - 118)) | (1 << (fugue_sqlParser.INSERT - 118)) | (1 << (fugue_sqlParser.INTERVAL - 118)) | (1 << (fugue_sqlParser.INTO - 118)) | (1 << (fugue_sqlParser.IS - 118)) | (1 << (fugue_sqlParser.ITEMS - 118)) | (1 << (fugue_sqlParser.KEYS - 118)) | (1 << (fugue_sqlParser.LAST - 118)) | (1 << (fugue_sqlParser.LATERAL - 118)) | (1 << (fugue_sqlParser.LAZY - 118)) | (1 << (fugue_sqlParser.LEADING - 118)) | (1 << (fugue_sqlParser.LIKE - 118)) | (1 << (fugue_sqlParser.LIMIT - 118)) | (1 << (fugue_sqlParser.LINES - 118)) | (1 << (fugue_sqlParser.LIST - 118)) | (1 << (fugue_sqlParser.LOAD - 118)) | (1 << (fugue_sqlParser.LOCAL - 118)) | (1 << (fugue_sqlParser.LOCATION - 118)) | (1 << (fugue_sqlParser.LOCK - 118)))) != 0) or ((((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & ((1 << (fugue_sqlParser.LOCKS - 182)) | (1 << (fugue_sqlParser.LOGICAL - 182)) | (1 << (fugue_sqlParser.MACRO - 182)) | (1 << (fugue_sqlParser.MAP - 182)) | (1 << (fugue_sqlParser.MATCHED - 182)) | (1 << (fugue_sqlParser.MERGE - 182)) | (1 << (fugue_sqlParser.MINUTE - 182)) | (1 << (fugue_sqlParser.MONTH - 182)) | (1 << (fugue_sqlParser.MSCK - 182)) | (1 << (fugue_sqlParser.NAMESPACE - 182)) | (1 << (fugue_sqlParser.NAMESPACES - 182)) | (1 << (fugue_sqlParser.NO - 182)) | (1 << (fugue_sqlParser.NOT - 182)) | (1 << (fugue_sqlParser.NULL - 182)) | (1 << (fugue_sqlParser.NULLS - 182)) | (1 << (fugue_sqlParser.OF - 182)) | (1 << (fugue_sqlParser.ONLY - 182)) | (1 << (fugue_sqlParser.OPTION - 182)) | (1 << (fugue_sqlParser.OPTIONS - 182)) | (1 << (fugue_sqlParser.OR - 182)) | (1 << (fugue_sqlParser.ORDER - 182)) | (1 << (fugue_sqlParser.OUT - 182)) | (1 << (fugue_sqlParser.OUTER - 182)) | (1 << (fugue_sqlParser.OUTPUTFORMAT - 182)) | (1 << (fugue_sqlParser.OVER - 182)) | (1 << (fugue_sqlParser.OVERLAPS - 182)) | (1 << (fugue_sqlParser.OVERLAY - 182)) | (1 << (fugue_sqlParser.OVERWRITE - 182)) | (1 << (fugue_sqlParser.PARTITION - 182)) | (1 << (fugue_sqlParser.PARTITIONED - 182)) | (1 << (fugue_sqlParser.PARTITIONS - 182)) | (1 << (fugue_sqlParser.PERCENTLIT - 182)) | (1 << (fugue_sqlParser.PIVOT - 182)) | (1 << (fugue_sqlParser.PLACING - 182)) | (1 << (fugue_sqlParser.POSITION - 182)) | (1 << (fugue_sqlParser.PRECEDING - 182)) | (1 << (fugue_sqlParser.PRIMARY - 182)) | (1 << (fugue_sqlParser.PRINCIPALS - 182)) | (1 << (fugue_sqlParser.PROPERTIES - 182)) | (1 << (fugue_sqlParser.PURGE - 182)) | (1 << (fugue_sqlParser.QUERY - 182)) | (1 << (fugue_sqlParser.RANGE - 182)) | (1 << (fugue_sqlParser.RECORDREADER - 182)) | (1 << (fugue_sqlParser.RECORDWRITER - 182)) | (1 << (fugue_sqlParser.RECOVER - 182)) | (1 << (fugue_sqlParser.REDUCE - 182)) | (1 << (fugue_sqlParser.REFERENCES - 182)) | (1 << (fugue_sqlParser.REFRESH - 182)) | (1 << (fugue_sqlParser.RENAME - 182)) | (1 << (fugue_sqlParser.REPAIR - 182)) | (1 << (fugue_sqlParser.REPLACE - 182)) | (1 << (fugue_sqlParser.RESET - 182)) | (1 << (fugue_sqlParser.RESTRICT - 182)) | (1 << (fugue_sqlParser.REVOKE - 182)) | (1 << (fugue_sqlParser.RLIKE - 182)) | (1 << (fugue_sqlParser.ROLE - 182)) | (1 << (fugue_sqlParser.ROLES - 182)) | (1 << (fugue_sqlParser.ROLLBACK - 182)) | (1 << (fugue_sqlParser.ROLLUP - 182)) | (1 << (fugue_sqlParser.ROW - 182)) | (1 << (fugue_sqlParser.ROWS - 182)))) != 0) or ((((_la - 246)) & ~0x3f) == 0 and ((1 << (_la - 246)) & ((1 << (fugue_sqlParser.SCHEMA - 246)) | (1 << (fugue_sqlParser.SECOND - 246)) | (1 << (fugue_sqlParser.SELECT - 246)) | (1 << (fugue_sqlParser.SEPARATED - 246)) | (1 << (fugue_sqlParser.SERDE - 246)) | (1 << (fugue_sqlParser.SERDEPROPERTIES - 246)) | (1 << (fugue_sqlParser.SESSION_USER - 246)) | (1 << (fugue_sqlParser.SET - 246)) | (1 << (fugue_sqlParser.SETS - 246)) | (1 << (fugue_sqlParser.SHOW - 246)) | (1 << (fugue_sqlParser.SKEWED - 246)) | (1 << (fugue_sqlParser.SOME - 246)) | (1 << (fugue_sqlParser.SORT - 246)) | (1 << (fugue_sqlParser.SORTED - 246)) | (1 << (fugue_sqlParser.START - 246)) | (1 << (fugue_sqlParser.STATISTICS - 246)) | (1 << (fugue_sqlParser.STORED - 246)) | (1 << (fugue_sqlParser.STRATIFY - 246)) | (1 << (fugue_sqlParser.STRUCT - 246)) | (1 << (fugue_sqlParser.SUBSTR - 246)) | (1 << (fugue_sqlParser.SUBSTRING - 246)) | (1 << (fugue_sqlParser.TABLE - 246)) | (1 << (fugue_sqlParser.TABLES - 246)) | (1 << (fugue_sqlParser.TABLESAMPLE - 246)) | (1 << (fugue_sqlParser.TBLPROPERTIES - 246)) | (1 << (fugue_sqlParser.TEMPORARY - 246)) | (1 << (fugue_sqlParser.TERMINATED - 246)) | (1 << (fugue_sqlParser.THEN - 246)) | (1 << (fugue_sqlParser.TO - 246)) | (1 << (fugue_sqlParser.TOUCH - 246)) | (1 << (fugue_sqlParser.TRAILING - 246)) | (1 << (fugue_sqlParser.TRANSACTION - 246)) | (1 << (fugue_sqlParser.TRANSACTIONS - 246)) | (1 << (fugue_sqlParser.TRANSFORM - 246)) | (1 << (fugue_sqlParser.TRIM - 246)) | (1 << (fugue_sqlParser.TRUE - 246)) | (1 << (fugue_sqlParser.TRUNCATE - 246)) | (1 << (fugue_sqlParser.TYPE - 246)) | (1 << (fugue_sqlParser.UNARCHIVE - 246)) | (1 << (fugue_sqlParser.UNBOUNDED - 246)) | (1 << (fugue_sqlParser.UNCACHE - 246)) | (1 << (fugue_sqlParser.UNIQUE - 246)) | (1 << (fugue_sqlParser.UNKNOWN - 246)) | (1 << (fugue_sqlParser.UNLOCK - 246)) | (1 << (fugue_sqlParser.UNSET - 246)) | (1 << (fugue_sqlParser.UPDATE - 246)) | (1 << (fugue_sqlParser.USE - 246)) | (1 << (fugue_sqlParser.USER - 246)) | (1 << (fugue_sqlParser.VALUES - 246)) | (1 << (fugue_sqlParser.VIEW - 246)) | (1 << (fugue_sqlParser.VIEWS - 246)) | (1 << (fugue_sqlParser.WHEN - 246)) | (1 << (fugue_sqlParser.WHERE - 246)) | (1 << (fugue_sqlParser.WINDOW - 246)) | (1 << (fugue_sqlParser.WITH - 246)) | (1 << (fugue_sqlParser.YEAR - 246)))) != 0) or _la==fugue_sqlParser.DIV):
                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[39] = self.fugueAssignmentSign_sempred
        self._predicates[47] = self.fuguePartitionNum_sempred
        self._predicates[114] = self.queryTerm_sempred
        self._predicates[169] = self.booleanExpression_sempred
        self._predicates[171] = self.valueExpression_sempred
        self._predicates[172] = self.primaryExpression_sempred
        self._predicates[205] = self.identifier_sempred
        self._predicates[206] = self.strictIdentifier_sempred
        self._predicates[208] = 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 fugueAssignmentSign_sempred(self, localctx:FugueAssignmentSignContext, predIndex:int):
            if predIndex == 0:
                return self.simpleAssign
         

    def fuguePartitionNum_sempred(self, localctx:FuguePartitionNumContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 1)
         

    def queryTerm_sempred(self, localctx:QueryTermContext, predIndex:int):
            if predIndex == 2:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 3:
                return fugue_sqlParser.legacy_setops_precedence_enbled
         

            if predIndex == 4:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 5:
                return not fugue_sqlParser.legacy_setops_precedence_enbled
         

            if predIndex == 6:
                return self.precpred(self._ctx, 1)
         

            if predIndex == 7:
                return not fugue_sqlParser.legacy_setops_precedence_enbled
         

    def booleanExpression_sempred(self, localctx:BooleanExpressionContext, predIndex:int):
            if predIndex == 8:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 1)
         

    def valueExpression_sempred(self, localctx:ValueExpressionContext, predIndex:int):
            if predIndex == 10:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 14:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 1)
         

    def primaryExpression_sempred(self, localctx:PrimaryExpressionContext, predIndex:int):
            if predIndex == 16:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 17:
                return self.precpred(self._ctx, 6)
         

    def identifier_sempred(self, localctx:IdentifierContext, predIndex:int):
            if predIndex == 18:
                return not self.SQL_standard_keyword_behavior
         

    def strictIdentifier_sempred(self, localctx:StrictIdentifierContext, predIndex:int):
            if predIndex == 19:
                return self.SQL_standard_keyword_behavior
         

            if predIndex == 20:
                return not self.SQL_standard_keyword_behavior
         

    def number_sempred(self, localctx:NumberContext, predIndex:int):
            if predIndex == 21:
                return not fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled
         

            if predIndex == 22:
                return not fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled
         

            if predIndex == 23:
                return fugue_sqlParser.legacy_exponent_literal_as_decimal_enabled
         




