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


class tsqlParser ( Parser ):

    grammarFileName = "tsql.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'='", "'>'", 
                     "'<'", "'!'", "'+='", "'-='", "'*='", "'/='", "'%='", 
                     "'&='", "'^='", "'|='", "'.'", "'_'", "'@'", "'#'", 
                     "'$'", "'('", "')'", "','", "';'", "':'", "'*'", "'/'", 
                     "'%'", "'+'", "'-'", "'~'", "'|'", "'&'", "'^'" ]

    symbolicNames = [ "<INVALID>", "ADD", "ALL", "ALTER", "AND", "ANY", 
                      "AS", "ASC", "AUTHORIZATION", "BACKUP", "BEGIN", "BETWEEN", 
                      "BREAK", "BROWSE", "BULK", "BY", "CALLED", "CASCADE", 
                      "CASE", "CHANGETABLE", "CHANGES", "CHECK", "CHECKPOINT", 
                      "CLOSE", "CLUSTERED", "COALESCE", "COLLATE", "COLUMN", 
                      "COMMIT", "COMPUTE", "CONSTRAINT", "CONTAINMENT", 
                      "CONTAINS", "CONTAINSTABLE", "CONTINUE", "CONVERT", 
                      "CREATE", "CROSS", "CURRENT", "CURRENT_DATE", "CURRENT_TIME", 
                      "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "DATABASE", 
                      "DBCC", "DEALLOCATE", "DECLARE", "DEFAULT", "DELETE", 
                      "DENY", "DESC", "DISK", "DISTINCT", "DISTRIBUTED", 
                      "DOUBLE", "DROP", "DUMP", "ELSE", "END", "ERRLVL", 
                      "ESCAPE", "EXCEPT", "EXECUTE", "EXISTS", "EXIT", "EXP", 
                      "EXTERNAL", "FETCH", "FILE", "FILENAME", "FILLFACTOR", 
                      "FOR", "FORCESEEK", "FOREIGN", "FREETEXT", "FREETEXTTABLE", 
                      "FROM", "FULL", "FUNCTION", "GOTO", "GRANT", "GROUP", 
                      "HAVING", "IDENTITY", "IDENTITYCOL", "IDENTITY_INSERT", 
                      "IIF", "IF", "IN", "INDEX", "INCLUDE", "INNER", "INSERT", 
                      "INTERSECT", "INTO", "IS", "JOIN", "KEY", "KILL", 
                      "LEFT", "LIKE", "LINENO", "LOAD", "LOG", "LOG10", 
                      "MERGE", "NATIONAL", "NEXT", "NOCHECK", "NONCLUSTERED", 
                      "NONE", "NOT", "NULL_", "NULLIF", "NUMERIC", "OF", 
                      "OFF", "OFFSETS", "ON", "OPEN", "OPENDATASOURCE", 
                      "OPENQUERY", "OPENROWSET", "OPENXML", "OPTION", "OR", 
                      "ORDER", "OUTER", "OVER", "PARTIAL", "PERCENT", "PIVOT", 
                      "PLAN", "PRECISION", "PRIMARY", "PRINT", "PROC", "PROCEDURE", 
                      "PUBLIC", "RAISERROR", "READ", "READTEXT", "RECONFIGURE", 
                      "REFERENCES", "REPLICATION", "RESTORE", "RESTRICT", 
                      "RETURN", "RETURNS", "REVERT", "REVOKE", "RIGHT", 
                      "ROLLBACK", "ROWCOUNT", "ROWGUIDCOL", "RULE", "SAVE", 
                      "SCHEMA", "SECURITYAUDIT", "SELECT", "SEMANTICKEYPHRASETABLE", 
                      "SEMANTICSIMILARITYDETAILSTABLE", "SEMANTICSIMILARITYTABLE", 
                      "SESSION_USER", "SET", "SETUSER", "SHUTDOWN", "SIGN", 
                      "SOME", "STATISTICS", "SYNONYM", "SYSTEM", "SYSTEM_USER", 
                      "TABLE", "TABLESAMPLE", "TEXTSIZE", "THEN", "TO", 
                      "TOP", "TRAN", "TRANSACTION", "TRIGGER", "TRUNCATE", 
                      "TRY_CAST", "TRY_CONVERT", "TRY_PARSE", "TSEQUAL", 
                      "UNION", "UNIQUE", "UNPIVOT", "UPDATE", "UPDATETEXT", 
                      "USE", "USER", "VALUES", "VALUE", "VARYING", "VIEW", 
                      "WAITFOR", "WHEN", "WHERE", "WHILE", "WITH", "WITHIN", 
                      "WRITETEXT", "ABSOLUTE", "AFTER", "ALLOWED", "ALLOW_SNAPSHOT_ISOLATION", 
                      "ANSI_NULLS", "ANSI_NULL_DEFAULT", "ANSI_PADDING", 
                      "ANSI_WARNINGS", "APPLY", "ARITHABORT", "AT", "AUTO", 
                      "AUTO_CLEANUP", "AUTO_CLOSE", "AUTO_CREATE_STATISTICS", 
                      "AUTO_SHRINK", "AUTO_UPDATE_STATISTICS", "AUTO_UPDATE_STATISTICS_ASYNC", 
                      "AVG", "BASE64", "BIGINT", "BINARY_CHECKSUM", "BULK_LOGGED", 
                      "CALLER", "CAST", "CATCH", "CEILING", "CHANGE_RETENTION", 
                      "CHANGE_TRACKING", "CHECKSUM", "CHECKSUM_AGG", "COMMITTED", 
                      "COMPATIBILITY_LEVEL", "CONCAT", "CONCAT_NULL_YIELDS_NULL", 
                      "CONTROL", "COOKIE", "COS", "COUNT", "COUNT_BIG", 
                      "CUBE", "CURSOR_CLOSE_ON_COMMIT", "CURSOR_DEFAULT", 
                      "DATE", "DATEADD", "DATEDIFF", "DATENAME", "DATEPART", 
                      "DATETIME2", "DATETIMEOFFSETFROMPARTS", "DATE_CORRELATION_OPTIMIZATION", 
                      "DAYS", "DB_CHAINING", "DEFAULT_FULLTEXT_LANGUAGE", 
                      "DEFAULT_LANGUAGE", "DELAY", "DELAYED_DURABILITY", 
                      "DELETED", "DENSE_RANK", "DIRECTORY_NAME", "DISABLE", 
                      "DISABLED", "DISABLE_BROKER", "DYNAMIC", "EMERGENCY", 
                      "ENABLE_BROKER", "ENCRYPTION", "ERROR_BROKER_CONVERSATIONS", 
                      "EXIST", "EXPAND", "FAST", "FAST_FORWARD", "FILEGROUP", 
                      "FILEGROWTH", "FILESTREAM", "FIRST", "FIRST_VALUE", 
                      "FLOOR", "FOLLOWING", "FORCE", "FORCED", "FORWARD_ONLY", 
                      "FULLSCAN", "GB", "GLOBAL", "GO", "GROUPING", "GROUPING_ID", 
                      "HADR", "HASH", "HONOR_BROKER_PRIORITY", "HOURS", 
                      "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX", "IMMEDIATE", 
                      "IMPERSONATE", "INCREMENTAL", "INPUT", "INT", "INSENSITIVE", 
                      "INSERTED", "ISOLATION", "IO", "KB", "KEEP", "KEEPFIXED", 
                      "KEYSET", "LAG", "LAST", "LAST_VALUE", "LEAD", "LEVEL", 
                      "LOCAL", "LOCK_ESCALATION", "LOGIN", "LOOP", "MARK", 
                      "MAX", "MAXDOP", "MAXRECURSION", "MAXSIZE", "MB", 
                      "MEMORY_OPTIMIZED_DATA", "MIN", "MINUTES", "MIN_ACTIVE_ROWVERSION", 
                      "MIXED_PAGE_ALLOCATION", "MODIFY", "MULTI_USER", "NAME", 
                      "NESTED_TRIGGERS", "NEW_BROKER", "NOCOUNT", "NODES", 
                      "NOEXPAND", "NON_TRANSACTED_ACCESS", "NORECOMPUTE", 
                      "NO_WAIT", "NTILE", "NUMBER", "NUMERIC_ROUNDABORT", 
                      "OFFLINE", "OFFSET", "ONLINE", "ONLY", "OPTIMISTIC", 
                      "OPTIMIZE", "OUT", "OUTPUT", "OWNER", "PAGE_VERIFY", 
                      "PARAMETERIZATION", "PARSE", "PARTITION", "PATH", 
                      "PERCENTILE_CONT", "POWER", "PRECEDING", "PRIOR", 
                      "PRIVILEGES", "QUERY", "QUOTED_IDENTIFIER", "RANGE", 
                      "RANK", "READONLY", "READ_COMMITTED_SNAPSHOT", "READ_ONLY", 
                      "READ_WRITE", "RECOMPILE", "RECOVERY", "RECURSIVE_TRIGGERS", 
                      "RELATIVE", "REMOTE", "REPEATABLE", "RESTRICTED_USER", 
                      "ROBUST", "ROLLUP", "ROOT", "ROUND", "ROW", "ROWGUID", 
                      "ROWS", "ROW_NUMBER", "SAMPLE", "SCHEMABINDING", "SCROLL", 
                      "SCROLL_LOCKS", "SECONDS", "SELF", "SERIALIZABLE", 
                      "SETS", "SHOWPLAN", "SIMPLE", "SIN", "SINGLE_USER", 
                      "SIZE", "SMALLINT", "SNAPSHOT", "SPATIAL_WINDOW_MAX_CELLS", 
                      "STATIC", "STATS_STREAM", "STDEV", "STDEVP", "STRING_AGG", 
                      "STRING_SPLIT", "SUM", "SQRT", "SQUARE", "TAKE", "TAN", 
                      "TARGET_RECOVERY_TIME", "TB", "TEXTIMAGE_ON", "THROW", 
                      "TIES", "TIME", "TINYINT", "TORN_PAGE_DETECTION", 
                      "TRANSFORM_NOISE_WORDS", "TRUSTWORTHY", "TRY", "TWO_DIGIT_YEAR_CUTOFF", 
                      "TYPE", "TYPE_WARNING", "UNBOUNDED", "UNCOMMITTED", 
                      "UNKNOWN", "UNLIMITED", "USING", "VAR", "VARP", "VIEWS", 
                      "VIEW_METADATA", "WORK", "XML", "XMLNAMESPACES", "ZONE", 
                      "DOLLAR_ACTION", "SPACE", "COMMENT", "LINE_COMMENT", 
                      "DOUBLE_QUOTE_ID", "SQUARE_BRACKET_ID", "LOCAL_ID", 
                      "DECIMAL", "ID", "STRING", "BINARY", "FLOAT", "REAL", 
                      "EQUAL", "GREATER", "LESS", "EXCLAMATION", "PLUS_ASSIGN", 
                      "MINUS_ASSIGN", "MULT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", 
                      "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "DOT", "UNDERLINE", 
                      "AT_SIGN", "SHARP", "DOLLAR", "LR_BRACKET", "RR_BRACKET", 
                      "COMMA", "SEMI", "COLON", "STAR", "DIVIDE", "MODULE", 
                      "PLUS", "MINUS", "BIT_NOT", "BIT_OR", "BIT_AND", "BIT_XOR" ]

    RULE_tsql_file = 0
    RULE_batch = 1
    RULE_sql_clauses = 2
    RULE_sql_clause = 3
    RULE_dml_clause = 4
    RULE_ddl_clause = 5
    RULE_cfl_statement = 6
    RULE_cfl_clause = 7
    RULE_block_statement = 8
    RULE_break_statement = 9
    RULE_continue_statement = 10
    RULE_goto_statement = 11
    RULE_if_statement = 12
    RULE_if_block = 13
    RULE_return_statement = 14
    RULE_throw_statement = 15
    RULE_try_catch_statement = 16
    RULE_waitfor_statement = 17
    RULE_while_statement = 18
    RULE_print_statement = 19
    RULE_raiseerror_statement = 20
    RULE_another_statement = 21
    RULE_delete_statement = 22
    RULE_delete_statement_from = 23
    RULE_insert_statement = 24
    RULE_insert_statement_value = 25
    RULE_select_statement = 26
    RULE_update_statement = 27
    RULE_where_clause_dml = 28
    RULE_output_clause = 29
    RULE_output_dml_list_elem = 30
    RULE_output_column_name = 31
    RULE_create_database = 32
    RULE_create_index = 33
    RULE_create_statistics = 34
    RULE_create_table = 35
    RULE_create_schema = 36
    RULE_create_synonym = 37
    RULE_create_view = 38
    RULE_view_attribute = 39
    RULE_alter_table = 40
    RULE_alter_database = 41
    RULE_database_optionspec = 42
    RULE_auto_option = 43
    RULE_change_tracking_option = 44
    RULE_change_tracking_option_list = 45
    RULE_containment_option = 46
    RULE_cursor_option = 47
    RULE_date_correlation_optimization_option = 48
    RULE_db_encryption_option = 49
    RULE_db_state_option = 50
    RULE_db_update_option = 51
    RULE_db_user_access_option = 52
    RULE_delayed_durability_option = 53
    RULE_external_access_option = 54
    RULE_hadr_options = 55
    RULE_mixed_page_allocation_option = 56
    RULE_parameterization_option = 57
    RULE_recovery_option = 58
    RULE_service_broker_option = 59
    RULE_snapshot_option = 60
    RULE_sql_option = 61
    RULE_target_recovery_time_option = 62
    RULE_termination = 63
    RULE_drop_index = 64
    RULE_drop_procedure = 65
    RULE_drop_statistics = 66
    RULE_drop_table = 67
    RULE_drop_database = 68
    RULE_drop_synonym = 69
    RULE_drop_view = 70
    RULE_drop_schema = 71
    RULE_drop_function = 72
    RULE_create_type = 73
    RULE_drop_type = 74
    RULE_rowset_function_limited = 75
    RULE_openquery = 76
    RULE_opendatasource = 77
    RULE_declare_statement = 78
    RULE_cursor_statement = 79
    RULE_execute_statement = 80
    RULE_execute_statement_arg = 81
    RULE_execute_var_string = 82
    RULE_security_statement = 83
    RULE_grant_permission = 84
    RULE_set_statement = 85
    RULE_transaction_statement = 86
    RULE_go_statement = 87
    RULE_use_statement = 88
    RULE_execute_clause = 89
    RULE_declare_local = 90
    RULE_table_type_definition = 91
    RULE_column_def_table_constraints = 92
    RULE_column_def_table_constraint = 93
    RULE_column_definition = 94
    RULE_column_constraint = 95
    RULE_table_constraint = 96
    RULE_index_options = 97
    RULE_index_option = 98
    RULE_declare_cursor = 99
    RULE_declare_set_cursor_common = 100
    RULE_fetch_cursor = 101
    RULE_set_special = 102
    RULE_constant_LOCAL_ID = 103
    RULE_expression = 104
    RULE_xml_method_call = 105
    RULE_simple_xml_method_name = 106
    RULE_constant_expression = 107
    RULE_subquery = 108
    RULE_with_expression = 109
    RULE_common_table_expression = 110
    RULE_update_elem = 111
    RULE_search_condition_list = 112
    RULE_search_condition = 113
    RULE_predicate = 114
    RULE_query_expression = 115
    RULE_union_op = 116
    RULE_cross_apply_expression = 117
    RULE_query_specification = 118
    RULE_group_by_grouping_sets = 119
    RULE_grouping_set = 120
    RULE_top_clause = 121
    RULE_top_clause_dm = 122
    RULE_order_by_clause = 123
    RULE_fetch_expression = 124
    RULE_for_clause = 125
    RULE_xml_common_directives = 126
    RULE_order_by_expression = 127
    RULE_group_by_item = 128
    RULE_option_clause = 129
    RULE_option = 130
    RULE_optimize_for_arg = 131
    RULE_select_list = 132
    RULE_select_list_elem = 133
    RULE_table_sources = 134
    RULE_table_source = 135
    RULE_table_source_item = 136
    RULE_tablesample_clause = 137
    RULE_sample_number = 138
    RULE_repeat_seed = 139
    RULE_table_alias = 140
    RULE_change_table = 141
    RULE_join_type = 142
    RULE_table_name_with_hint = 143
    RULE_rowset_function = 144
    RULE_bulk_option = 145
    RULE_derived_table = 146
    RULE_function_call = 147
    RULE_switch_section = 148
    RULE_switch_search_condition_section = 149
    RULE_with_table_hints = 150
    RULE_insert_with_table_hints = 151
    RULE_table_hint = 152
    RULE_index_value = 153
    RULE_column_alias_list = 154
    RULE_column_alias = 155
    RULE_a_star = 156
    RULE_table_value_constructor = 157
    RULE_expression_list = 158
    RULE_value_list = 159
    RULE_next_value_for = 160
    RULE_next_value_for_function = 161
    RULE_ranking_windowed_function = 162
    RULE_aggregate_windowed_function = 163
    RULE_all_distinct = 164
    RULE_over_clause = 165
    RULE_row_or_range_clause = 166
    RULE_window_frame_extent = 167
    RULE_window_frame_bound = 168
    RULE_window_frame_preceding = 169
    RULE_window_frame_following = 170
    RULE_create_database_option = 171
    RULE_database_filestream_option = 172
    RULE_database_file_spec = 173
    RULE_file_group = 174
    RULE_file_spec = 175
    RULE_full_table_name = 176
    RULE_simple_name = 177
    RULE_func_proc_name = 178
    RULE_ddl_object = 179
    RULE_full_column_name = 180
    RULE_column_name_list = 181
    RULE_cursor_name = 182
    RULE_on_off = 183
    RULE_clustered = 184
    RULE_null_notnull = 185
    RULE_scalar_function_name = 186
    RULE_default_value = 187
    RULE_constant = 188
    RULE_sign = 189
    RULE_r_id = 190
    RULE_simple_id = 191
    RULE_comparison_operator = 192
    RULE_assignment_operator = 193
    RULE_file_size = 194
    RULE_create_or_alter_procedure = 195
    RULE_create_or_alter_function = 196
    RULE_func_body_returns_select = 197
    RULE_func_body_returns_table = 198
    RULE_func_body_returns_scalar = 199
    RULE_procedure_param = 200
    RULE_procedure_option = 201
    RULE_function_option = 202
    RULE_percentile_cont = 203
    RULE_string_agg = 204
    RULE_data_type = 205

    ruleNames =  [ "tsql_file", "batch", "sql_clauses", "sql_clause", "dml_clause", 
                   "ddl_clause", "cfl_statement", "cfl_clause", "block_statement", 
                   "break_statement", "continue_statement", "goto_statement", 
                   "if_statement", "if_block", "return_statement", "throw_statement", 
                   "try_catch_statement", "waitfor_statement", "while_statement", 
                   "print_statement", "raiseerror_statement", "another_statement", 
                   "delete_statement", "delete_statement_from", "insert_statement", 
                   "insert_statement_value", "select_statement", "update_statement", 
                   "where_clause_dml", "output_clause", "output_dml_list_elem", 
                   "output_column_name", "create_database", "create_index", 
                   "create_statistics", "create_table", "create_schema", 
                   "create_synonym", "create_view", "view_attribute", "alter_table", 
                   "alter_database", "database_optionspec", "auto_option", 
                   "change_tracking_option", "change_tracking_option_list", 
                   "containment_option", "cursor_option", "date_correlation_optimization_option", 
                   "db_encryption_option", "db_state_option", "db_update_option", 
                   "db_user_access_option", "delayed_durability_option", 
                   "external_access_option", "hadr_options", "mixed_page_allocation_option", 
                   "parameterization_option", "recovery_option", "service_broker_option", 
                   "snapshot_option", "sql_option", "target_recovery_time_option", 
                   "termination", "drop_index", "drop_procedure", "drop_statistics", 
                   "drop_table", "drop_database", "drop_synonym", "drop_view", 
                   "drop_schema", "drop_function", "create_type", "drop_type", 
                   "rowset_function_limited", "openquery", "opendatasource", 
                   "declare_statement", "cursor_statement", "execute_statement", 
                   "execute_statement_arg", "execute_var_string", "security_statement", 
                   "grant_permission", "set_statement", "transaction_statement", 
                   "go_statement", "use_statement", "execute_clause", "declare_local", 
                   "table_type_definition", "column_def_table_constraints", 
                   "column_def_table_constraint", "column_definition", "column_constraint", 
                   "table_constraint", "index_options", "index_option", 
                   "declare_cursor", "declare_set_cursor_common", "fetch_cursor", 
                   "set_special", "constant_LOCAL_ID", "expression", "xml_method_call", 
                   "simple_xml_method_name", "constant_expression", "subquery", 
                   "with_expression", "common_table_expression", "update_elem", 
                   "search_condition_list", "search_condition", "predicate", 
                   "query_expression", "union_op", "cross_apply_expression", 
                   "query_specification", "group_by_grouping_sets", "grouping_set", 
                   "top_clause", "top_clause_dm", "order_by_clause", "fetch_expression", 
                   "for_clause", "xml_common_directives", "order_by_expression", 
                   "group_by_item", "option_clause", "option", "optimize_for_arg", 
                   "select_list", "select_list_elem", "table_sources", "table_source", 
                   "table_source_item", "tablesample_clause", "sample_number", 
                   "repeat_seed", "table_alias", "change_table", "join_type", 
                   "table_name_with_hint", "rowset_function", "bulk_option", 
                   "derived_table", "function_call", "switch_section", "switch_search_condition_section", 
                   "with_table_hints", "insert_with_table_hints", "table_hint", 
                   "index_value", "column_alias_list", "column_alias", "a_star", 
                   "table_value_constructor", "expression_list", "value_list", 
                   "next_value_for", "next_value_for_function", "ranking_windowed_function", 
                   "aggregate_windowed_function", "all_distinct", "over_clause", 
                   "row_or_range_clause", "window_frame_extent", "window_frame_bound", 
                   "window_frame_preceding", "window_frame_following", "create_database_option", 
                   "database_filestream_option", "database_file_spec", "file_group", 
                   "file_spec", "full_table_name", "simple_name", "func_proc_name", 
                   "ddl_object", "full_column_name", "column_name_list", 
                   "cursor_name", "on_off", "clustered", "null_notnull", 
                   "scalar_function_name", "default_value", "constant", 
                   "sign", "r_id", "simple_id", "comparison_operator", "assignment_operator", 
                   "file_size", "create_or_alter_procedure", "create_or_alter_function", 
                   "func_body_returns_select", "func_body_returns_table", 
                   "func_body_returns_scalar", "procedure_param", "procedure_option", 
                   "function_option", "percentile_cont", "string_agg", "data_type" ]

    EOF = Token.EOF
    ADD=1
    ALL=2
    ALTER=3
    AND=4
    ANY=5
    AS=6
    ASC=7
    AUTHORIZATION=8
    BACKUP=9
    BEGIN=10
    BETWEEN=11
    BREAK=12
    BROWSE=13
    BULK=14
    BY=15
    CALLED=16
    CASCADE=17
    CASE=18
    CHANGETABLE=19
    CHANGES=20
    CHECK=21
    CHECKPOINT=22
    CLOSE=23
    CLUSTERED=24
    COALESCE=25
    COLLATE=26
    COLUMN=27
    COMMIT=28
    COMPUTE=29
    CONSTRAINT=30
    CONTAINMENT=31
    CONTAINS=32
    CONTAINSTABLE=33
    CONTINUE=34
    CONVERT=35
    CREATE=36
    CROSS=37
    CURRENT=38
    CURRENT_DATE=39
    CURRENT_TIME=40
    CURRENT_TIMESTAMP=41
    CURRENT_USER=42
    CURSOR=43
    DATABASE=44
    DBCC=45
    DEALLOCATE=46
    DECLARE=47
    DEFAULT=48
    DELETE=49
    DENY=50
    DESC=51
    DISK=52
    DISTINCT=53
    DISTRIBUTED=54
    DOUBLE=55
    DROP=56
    DUMP=57
    ELSE=58
    END=59
    ERRLVL=60
    ESCAPE=61
    EXCEPT=62
    EXECUTE=63
    EXISTS=64
    EXIT=65
    EXP=66
    EXTERNAL=67
    FETCH=68
    FILE=69
    FILENAME=70
    FILLFACTOR=71
    FOR=72
    FORCESEEK=73
    FOREIGN=74
    FREETEXT=75
    FREETEXTTABLE=76
    FROM=77
    FULL=78
    FUNCTION=79
    GOTO=80
    GRANT=81
    GROUP=82
    HAVING=83
    IDENTITY=84
    IDENTITYCOL=85
    IDENTITY_INSERT=86
    IIF=87
    IF=88
    IN=89
    INDEX=90
    INCLUDE=91
    INNER=92
    INSERT=93
    INTERSECT=94
    INTO=95
    IS=96
    JOIN=97
    KEY=98
    KILL=99
    LEFT=100
    LIKE=101
    LINENO=102
    LOAD=103
    LOG=104
    LOG10=105
    MERGE=106
    NATIONAL=107
    NEXT=108
    NOCHECK=109
    NONCLUSTERED=110
    NONE=111
    NOT=112
    NULL_=113
    NULLIF=114
    NUMERIC=115
    OF=116
    OFF=117
    OFFSETS=118
    ON=119
    OPEN=120
    OPENDATASOURCE=121
    OPENQUERY=122
    OPENROWSET=123
    OPENXML=124
    OPTION=125
    OR=126
    ORDER=127
    OUTER=128
    OVER=129
    PARTIAL=130
    PERCENT=131
    PIVOT=132
    PLAN=133
    PRECISION=134
    PRIMARY=135
    PRINT=136
    PROC=137
    PROCEDURE=138
    PUBLIC=139
    RAISERROR=140
    READ=141
    READTEXT=142
    RECONFIGURE=143
    REFERENCES=144
    REPLICATION=145
    RESTORE=146
    RESTRICT=147
    RETURN=148
    RETURNS=149
    REVERT=150
    REVOKE=151
    RIGHT=152
    ROLLBACK=153
    ROWCOUNT=154
    ROWGUIDCOL=155
    RULE=156
    SAVE=157
    SCHEMA=158
    SECURITYAUDIT=159
    SELECT=160
    SEMANTICKEYPHRASETABLE=161
    SEMANTICSIMILARITYDETAILSTABLE=162
    SEMANTICSIMILARITYTABLE=163
    SESSION_USER=164
    SET=165
    SETUSER=166
    SHUTDOWN=167
    SIGN=168
    SOME=169
    STATISTICS=170
    SYNONYM=171
    SYSTEM=172
    SYSTEM_USER=173
    TABLE=174
    TABLESAMPLE=175
    TEXTSIZE=176
    THEN=177
    TO=178
    TOP=179
    TRAN=180
    TRANSACTION=181
    TRIGGER=182
    TRUNCATE=183
    TRY_CAST=184
    TRY_CONVERT=185
    TRY_PARSE=186
    TSEQUAL=187
    UNION=188
    UNIQUE=189
    UNPIVOT=190
    UPDATE=191
    UPDATETEXT=192
    USE=193
    USER=194
    VALUES=195
    VALUE=196
    VARYING=197
    VIEW=198
    WAITFOR=199
    WHEN=200
    WHERE=201
    WHILE=202
    WITH=203
    WITHIN=204
    WRITETEXT=205
    ABSOLUTE=206
    AFTER=207
    ALLOWED=208
    ALLOW_SNAPSHOT_ISOLATION=209
    ANSI_NULLS=210
    ANSI_NULL_DEFAULT=211
    ANSI_PADDING=212
    ANSI_WARNINGS=213
    APPLY=214
    ARITHABORT=215
    AT=216
    AUTO=217
    AUTO_CLEANUP=218
    AUTO_CLOSE=219
    AUTO_CREATE_STATISTICS=220
    AUTO_SHRINK=221
    AUTO_UPDATE_STATISTICS=222
    AUTO_UPDATE_STATISTICS_ASYNC=223
    AVG=224
    BASE64=225
    BIGINT=226
    BINARY_CHECKSUM=227
    BULK_LOGGED=228
    CALLER=229
    CAST=230
    CATCH=231
    CEILING=232
    CHANGE_RETENTION=233
    CHANGE_TRACKING=234
    CHECKSUM=235
    CHECKSUM_AGG=236
    COMMITTED=237
    COMPATIBILITY_LEVEL=238
    CONCAT=239
    CONCAT_NULL_YIELDS_NULL=240
    CONTROL=241
    COOKIE=242
    COS=243
    COUNT=244
    COUNT_BIG=245
    CUBE=246
    CURSOR_CLOSE_ON_COMMIT=247
    CURSOR_DEFAULT=248
    DATE=249
    DATEADD=250
    DATEDIFF=251
    DATENAME=252
    DATEPART=253
    DATETIME2=254
    DATETIMEOFFSETFROMPARTS=255
    DATE_CORRELATION_OPTIMIZATION=256
    DAYS=257
    DB_CHAINING=258
    DEFAULT_FULLTEXT_LANGUAGE=259
    DEFAULT_LANGUAGE=260
    DELAY=261
    DELAYED_DURABILITY=262
    DELETED=263
    DENSE_RANK=264
    DIRECTORY_NAME=265
    DISABLE=266
    DISABLED=267
    DISABLE_BROKER=268
    DYNAMIC=269
    EMERGENCY=270
    ENABLE_BROKER=271
    ENCRYPTION=272
    ERROR_BROKER_CONVERSATIONS=273
    EXIST=274
    EXPAND=275
    FAST=276
    FAST_FORWARD=277
    FILEGROUP=278
    FILEGROWTH=279
    FILESTREAM=280
    FIRST=281
    FIRST_VALUE=282
    FLOOR=283
    FOLLOWING=284
    FORCE=285
    FORCED=286
    FORWARD_ONLY=287
    FULLSCAN=288
    GB=289
    GLOBAL=290
    GO=291
    GROUPING=292
    GROUPING_ID=293
    HADR=294
    HASH=295
    HONOR_BROKER_PRIORITY=296
    HOURS=297
    IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX=298
    IMMEDIATE=299
    IMPERSONATE=300
    INCREMENTAL=301
    INPUT=302
    INT=303
    INSENSITIVE=304
    INSERTED=305
    ISOLATION=306
    IO=307
    KB=308
    KEEP=309
    KEEPFIXED=310
    KEYSET=311
    LAG=312
    LAST=313
    LAST_VALUE=314
    LEAD=315
    LEVEL=316
    LOCAL=317
    LOCK_ESCALATION=318
    LOGIN=319
    LOOP=320
    MARK=321
    MAX=322
    MAXDOP=323
    MAXRECURSION=324
    MAXSIZE=325
    MB=326
    MEMORY_OPTIMIZED_DATA=327
    MIN=328
    MINUTES=329
    MIN_ACTIVE_ROWVERSION=330
    MIXED_PAGE_ALLOCATION=331
    MODIFY=332
    MULTI_USER=333
    NAME=334
    NESTED_TRIGGERS=335
    NEW_BROKER=336
    NOCOUNT=337
    NODES=338
    NOEXPAND=339
    NON_TRANSACTED_ACCESS=340
    NORECOMPUTE=341
    NO_WAIT=342
    NTILE=343
    NUMBER=344
    NUMERIC_ROUNDABORT=345
    OFFLINE=346
    OFFSET=347
    ONLINE=348
    ONLY=349
    OPTIMISTIC=350
    OPTIMIZE=351
    OUT=352
    OUTPUT=353
    OWNER=354
    PAGE_VERIFY=355
    PARAMETERIZATION=356
    PARSE=357
    PARTITION=358
    PATH=359
    PERCENTILE_CONT=360
    POWER=361
    PRECEDING=362
    PRIOR=363
    PRIVILEGES=364
    QUERY=365
    QUOTED_IDENTIFIER=366
    RANGE=367
    RANK=368
    READONLY=369
    READ_COMMITTED_SNAPSHOT=370
    READ_ONLY=371
    READ_WRITE=372
    RECOMPILE=373
    RECOVERY=374
    RECURSIVE_TRIGGERS=375
    RELATIVE=376
    REMOTE=377
    REPEATABLE=378
    RESTRICTED_USER=379
    ROBUST=380
    ROLLUP=381
    ROOT=382
    ROUND=383
    ROW=384
    ROWGUID=385
    ROWS=386
    ROW_NUMBER=387
    SAMPLE=388
    SCHEMABINDING=389
    SCROLL=390
    SCROLL_LOCKS=391
    SECONDS=392
    SELF=393
    SERIALIZABLE=394
    SETS=395
    SHOWPLAN=396
    SIMPLE=397
    SIN=398
    SINGLE_USER=399
    SIZE=400
    SMALLINT=401
    SNAPSHOT=402
    SPATIAL_WINDOW_MAX_CELLS=403
    STATIC=404
    STATS_STREAM=405
    STDEV=406
    STDEVP=407
    STRING_AGG=408
    STRING_SPLIT=409
    SUM=410
    SQRT=411
    SQUARE=412
    TAKE=413
    TAN=414
    TARGET_RECOVERY_TIME=415
    TB=416
    TEXTIMAGE_ON=417
    THROW=418
    TIES=419
    TIME=420
    TINYINT=421
    TORN_PAGE_DETECTION=422
    TRANSFORM_NOISE_WORDS=423
    TRUSTWORTHY=424
    TRY=425
    TWO_DIGIT_YEAR_CUTOFF=426
    TYPE=427
    TYPE_WARNING=428
    UNBOUNDED=429
    UNCOMMITTED=430
    UNKNOWN=431
    UNLIMITED=432
    USING=433
    VAR=434
    VARP=435
    VIEWS=436
    VIEW_METADATA=437
    WORK=438
    XML=439
    XMLNAMESPACES=440
    ZONE=441
    DOLLAR_ACTION=442
    SPACE=443
    COMMENT=444
    LINE_COMMENT=445
    DOUBLE_QUOTE_ID=446
    SQUARE_BRACKET_ID=447
    LOCAL_ID=448
    DECIMAL=449
    ID=450
    STRING=451
    BINARY=452
    FLOAT=453
    REAL=454
    EQUAL=455
    GREATER=456
    LESS=457
    EXCLAMATION=458
    PLUS_ASSIGN=459
    MINUS_ASSIGN=460
    MULT_ASSIGN=461
    DIV_ASSIGN=462
    MOD_ASSIGN=463
    AND_ASSIGN=464
    XOR_ASSIGN=465
    OR_ASSIGN=466
    DOT=467
    UNDERLINE=468
    AT_SIGN=469
    SHARP=470
    DOLLAR=471
    LR_BRACKET=472
    RR_BRACKET=473
    COMMA=474
    SEMI=475
    COLON=476
    STAR=477
    DIVIDE=478
    MODULE=479
    PLUS=480
    MINUS=481
    BIT_NOT=482
    BIT_OR=483
    BIT_AND=484
    BIT_XOR=485

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




    class Tsql_fileContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def batch(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.BatchContext)
            else:
                return self.getTypedRuleContext(tsqlParser.BatchContext,i)


        def getRuleIndex(self):
            return tsqlParser.RULE_tsql_file




    def tsql_file(self):

        localctx = tsqlParser.Tsql_fileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_tsql_file)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 415
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << tsqlParser.ALTER) | (1 << tsqlParser.BEGIN) | (1 << tsqlParser.BREAK) | (1 << tsqlParser.CLOSE) | (1 << tsqlParser.COMMIT) | (1 << tsqlParser.CONTINUE) | (1 << tsqlParser.CREATE) | (1 << tsqlParser.DEALLOCATE) | (1 << tsqlParser.DECLARE) | (1 << tsqlParser.DELETE) | (1 << tsqlParser.DROP) | (1 << tsqlParser.EXECUTE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (tsqlParser.FETCH - 68)) | (1 << (tsqlParser.FILLFACTOR - 68)) | (1 << (tsqlParser.FORCESEEK - 68)) | (1 << (tsqlParser.GOTO - 68)) | (1 << (tsqlParser.GRANT - 68)) | (1 << (tsqlParser.IF - 68)) | (1 << (tsqlParser.INSERT - 68)) | (1 << (tsqlParser.NEXT - 68)) | (1 << (tsqlParser.NUMERIC - 68)) | (1 << (tsqlParser.OPEN - 68)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (tsqlParser.PRINT - 136)) | (1 << (tsqlParser.RAISERROR - 136)) | (1 << (tsqlParser.RETURN - 136)) | (1 << (tsqlParser.REVERT - 136)) | (1 << (tsqlParser.ROLLBACK - 136)) | (1 << (tsqlParser.SAVE - 136)) | (1 << (tsqlParser.SELECT - 136)) | (1 << (tsqlParser.SET - 136)) | (1 << (tsqlParser.UPDATE - 136)) | (1 << (tsqlParser.USE - 136)) | (1 << (tsqlParser.VALUE - 136)) | (1 << (tsqlParser.WAITFOR - 136)))) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & ((1 << (tsqlParser.WHILE - 202)) | (1 << (tsqlParser.WITH - 202)) | (1 << (tsqlParser.ABSOLUTE - 202)) | (1 << (tsqlParser.APPLY - 202)) | (1 << (tsqlParser.AUTO - 202)) | (1 << (tsqlParser.AVG - 202)) | (1 << (tsqlParser.BASE64 - 202)) | (1 << (tsqlParser.CALLER - 202)) | (1 << (tsqlParser.CAST - 202)) | (1 << (tsqlParser.CATCH - 202)) | (1 << (tsqlParser.CHECKSUM_AGG - 202)) | (1 << (tsqlParser.COMMITTED - 202)) | (1 << (tsqlParser.CONCAT - 202)) | (1 << (tsqlParser.CONTROL - 202)) | (1 << (tsqlParser.COOKIE - 202)) | (1 << (tsqlParser.COUNT - 202)) | (1 << (tsqlParser.COUNT_BIG - 202)) | (1 << (tsqlParser.DATE - 202)) | (1 << (tsqlParser.DELAY - 202)) | (1 << (tsqlParser.DELETED - 202)) | (1 << (tsqlParser.DENSE_RANK - 202)))) != 0) or ((((_la - 266)) & ~0x3f) == 0 and ((1 << (_la - 266)) & ((1 << (tsqlParser.DISABLE - 266)) | (1 << (tsqlParser.DYNAMIC - 266)) | (1 << (tsqlParser.ENCRYPTION - 266)) | (1 << (tsqlParser.EXIST - 266)) | (1 << (tsqlParser.EXPAND - 266)) | (1 << (tsqlParser.FAST - 266)) | (1 << (tsqlParser.FAST_FORWARD - 266)) | (1 << (tsqlParser.FIRST - 266)) | (1 << (tsqlParser.FIRST_VALUE - 266)) | (1 << (tsqlParser.FOLLOWING - 266)) | (1 << (tsqlParser.FORCE - 266)) | (1 << (tsqlParser.FORCED - 266)) | (1 << (tsqlParser.FORWARD_ONLY - 266)) | (1 << (tsqlParser.FULLSCAN - 266)) | (1 << (tsqlParser.GLOBAL - 266)) | (1 << (tsqlParser.GO - 266)) | (1 << (tsqlParser.GROUPING - 266)) | (1 << (tsqlParser.GROUPING_ID - 266)) | (1 << (tsqlParser.HASH - 266)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 266)) | (1 << (tsqlParser.IMPERSONATE - 266)) | (1 << (tsqlParser.INSENSITIVE - 266)) | (1 << (tsqlParser.INSERTED - 266)) | (1 << (tsqlParser.ISOLATION - 266)) | (1 << (tsqlParser.IO - 266)) | (1 << (tsqlParser.KEEP - 266)) | (1 << (tsqlParser.KEEPFIXED - 266)) | (1 << (tsqlParser.KEYSET - 266)) | (1 << (tsqlParser.LAG - 266)) | (1 << (tsqlParser.LAST - 266)) | (1 << (tsqlParser.LAST_VALUE - 266)) | (1 << (tsqlParser.LEAD - 266)) | (1 << (tsqlParser.LEVEL - 266)) | (1 << (tsqlParser.LOCAL - 266)) | (1 << (tsqlParser.LOCK_ESCALATION - 266)) | (1 << (tsqlParser.LOGIN - 266)) | (1 << (tsqlParser.LOOP - 266)) | (1 << (tsqlParser.MARK - 266)) | (1 << (tsqlParser.MAX - 266)) | (1 << (tsqlParser.MAXDOP - 266)) | (1 << (tsqlParser.MAXRECURSION - 266)) | (1 << (tsqlParser.MIN - 266)))) != 0) or ((((_la - 332)) & ~0x3f) == 0 and ((1 << (_la - 332)) & ((1 << (tsqlParser.MODIFY - 332)) | (1 << (tsqlParser.NAME - 332)) | (1 << (tsqlParser.NOCOUNT - 332)) | (1 << (tsqlParser.NODES - 332)) | (1 << (tsqlParser.NOEXPAND - 332)) | (1 << (tsqlParser.NORECOMPUTE - 332)) | (1 << (tsqlParser.NTILE - 332)) | (1 << (tsqlParser.NUMBER - 332)) | (1 << (tsqlParser.OFFSET - 332)) | (1 << (tsqlParser.ONLINE - 332)) | (1 << (tsqlParser.ONLY - 332)) | (1 << (tsqlParser.OPTIMISTIC - 332)) | (1 << (tsqlParser.OPTIMIZE - 332)) | (1 << (tsqlParser.OUT - 332)) | (1 << (tsqlParser.OUTPUT - 332)) | (1 << (tsqlParser.OWNER - 332)) | (1 << (tsqlParser.PARAMETERIZATION - 332)) | (1 << (tsqlParser.PARTITION - 332)) | (1 << (tsqlParser.PATH - 332)) | (1 << (tsqlParser.PRECEDING - 332)) | (1 << (tsqlParser.PRIOR - 332)) | (1 << (tsqlParser.PRIVILEGES - 332)) | (1 << (tsqlParser.QUERY - 332)) | (1 << (tsqlParser.RANGE - 332)) | (1 << (tsqlParser.RANK - 332)) | (1 << (tsqlParser.READONLY - 332)) | (1 << (tsqlParser.READ_ONLY - 332)) | (1 << (tsqlParser.RECOMPILE - 332)) | (1 << (tsqlParser.RELATIVE - 332)) | (1 << (tsqlParser.REMOTE - 332)) | (1 << (tsqlParser.REPEATABLE - 332)) | (1 << (tsqlParser.ROBUST - 332)) | (1 << (tsqlParser.ROOT - 332)) | (1 << (tsqlParser.ROW - 332)) | (1 << (tsqlParser.ROWGUID - 332)) | (1 << (tsqlParser.ROWS - 332)) | (1 << (tsqlParser.ROW_NUMBER - 332)) | (1 << (tsqlParser.SAMPLE - 332)) | (1 << (tsqlParser.SCHEMABINDING - 332)) | (1 << (tsqlParser.SCROLL - 332)) | (1 << (tsqlParser.SCROLL_LOCKS - 332)) | (1 << (tsqlParser.SELF - 332)) | (1 << (tsqlParser.SERIALIZABLE - 332)))) != 0) or ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (tsqlParser.SIMPLE - 397)) | (1 << (tsqlParser.SIZE - 397)) | (1 << (tsqlParser.SNAPSHOT - 397)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 397)) | (1 << (tsqlParser.STATIC - 397)) | (1 << (tsqlParser.STATS_STREAM - 397)) | (1 << (tsqlParser.STDEV - 397)) | (1 << (tsqlParser.STDEVP - 397)) | (1 << (tsqlParser.SUM - 397)) | (1 << (tsqlParser.TEXTIMAGE_ON - 397)) | (1 << (tsqlParser.THROW - 397)) | (1 << (tsqlParser.TIES - 397)) | (1 << (tsqlParser.TIME - 397)) | (1 << (tsqlParser.TRY - 397)) | (1 << (tsqlParser.TYPE - 397)) | (1 << (tsqlParser.TYPE_WARNING - 397)) | (1 << (tsqlParser.UNBOUNDED - 397)) | (1 << (tsqlParser.UNCOMMITTED - 397)) | (1 << (tsqlParser.UNKNOWN - 397)) | (1 << (tsqlParser.USING - 397)) | (1 << (tsqlParser.VAR - 397)) | (1 << (tsqlParser.VARP - 397)) | (1 << (tsqlParser.VIEWS - 397)) | (1 << (tsqlParser.VIEW_METADATA - 397)) | (1 << (tsqlParser.WORK - 397)) | (1 << (tsqlParser.XML - 397)) | (1 << (tsqlParser.XMLNAMESPACES - 397)) | (1 << (tsqlParser.ZONE - 397)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 397)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 397)) | (1 << (tsqlParser.ID - 397)))) != 0) or _la==tsqlParser.LR_BRACKET:
                self.state = 412
                self.batch()
                self.state = 417
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class BatchContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sql_clauses(self):
            return self.getTypedRuleContext(tsqlParser.Sql_clausesContext,0)


        def go_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Go_statementContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Go_statementContext,i)


        def getRuleIndex(self):
            return tsqlParser.RULE_batch




    def batch(self):

        localctx = tsqlParser.BatchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_batch)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 421
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.GO:
                self.state = 420
                self.go_statement()


            self.state = 423
            self.sql_clauses()
            self.state = 425
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 424
                self.go_statement()


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


    class Sql_clausesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sql_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Sql_clauseContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Sql_clauseContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_sql_clauses




    def sql_clauses(self):

        localctx = tsqlParser.Sql_clausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_sql_clauses)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 431 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 427
                    self.sql_clause()
                    self.state = 429
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
                    if la_ == 1:
                        self.state = 428
                        self.match(tsqlParser.SEMI)



                else:
                    raise NoViableAltException(self)
                self.state = 433 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,4,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 Sql_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def dml_clause(self):
            return self.getTypedRuleContext(tsqlParser.Dml_clauseContext,0)


        def ddl_clause(self):
            return self.getTypedRuleContext(tsqlParser.Ddl_clauseContext,0)


        def cfl_statement(self):
            return self.getTypedRuleContext(tsqlParser.Cfl_statementContext,0)


        def another_statement(self):
            return self.getTypedRuleContext(tsqlParser.Another_statementContext,0)


        def cfl_clause(self):
            return self.getTypedRuleContext(tsqlParser.Cfl_clauseContext,0)


        def declare_statement(self):
            return self.getTypedRuleContext(tsqlParser.Declare_statementContext,0)


        def print_statement(self):
            return self.getTypedRuleContext(tsqlParser.Print_statementContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_sql_clause




    def sql_clause(self):

        localctx = tsqlParser.Sql_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_sql_clause)
        try:
            self.state = 442
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 435
                self.dml_clause()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 436
                self.ddl_clause()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 437
                self.cfl_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 438
                self.another_statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 439
                self.cfl_clause()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 440
                self.declare_statement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 441
                self.print_statement()
                pass


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


    class Dml_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def delete_statement(self):
            return self.getTypedRuleContext(tsqlParser.Delete_statementContext,0)


        def insert_statement(self):
            return self.getTypedRuleContext(tsqlParser.Insert_statementContext,0)


        def select_statement(self):
            return self.getTypedRuleContext(tsqlParser.Select_statementContext,0)


        def update_statement(self):
            return self.getTypedRuleContext(tsqlParser.Update_statementContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_dml_clause




    def dml_clause(self):

        localctx = tsqlParser.Dml_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_dml_clause)
        try:
            self.state = 448
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 444
                self.delete_statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 445
                self.insert_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 446
                self.select_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 447
                self.update_statement()
                pass


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


    class Ddl_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def create_database(self):
            return self.getTypedRuleContext(tsqlParser.Create_databaseContext,0)


        def create_index(self):
            return self.getTypedRuleContext(tsqlParser.Create_indexContext,0)


        def create_or_alter_function(self):
            return self.getTypedRuleContext(tsqlParser.Create_or_alter_functionContext,0)


        def create_or_alter_procedure(self):
            return self.getTypedRuleContext(tsqlParser.Create_or_alter_procedureContext,0)


        def create_statistics(self):
            return self.getTypedRuleContext(tsqlParser.Create_statisticsContext,0)


        def create_schema(self):
            return self.getTypedRuleContext(tsqlParser.Create_schemaContext,0)


        def create_synonym(self):
            return self.getTypedRuleContext(tsqlParser.Create_synonymContext,0)


        def create_table(self):
            return self.getTypedRuleContext(tsqlParser.Create_tableContext,0)


        def create_type(self):
            return self.getTypedRuleContext(tsqlParser.Create_typeContext,0)


        def create_view(self):
            return self.getTypedRuleContext(tsqlParser.Create_viewContext,0)


        def alter_table(self):
            return self.getTypedRuleContext(tsqlParser.Alter_tableContext,0)


        def alter_database(self):
            return self.getTypedRuleContext(tsqlParser.Alter_databaseContext,0)


        def drop_index(self):
            return self.getTypedRuleContext(tsqlParser.Drop_indexContext,0)


        def drop_procedure(self):
            return self.getTypedRuleContext(tsqlParser.Drop_procedureContext,0)


        def drop_statistics(self):
            return self.getTypedRuleContext(tsqlParser.Drop_statisticsContext,0)


        def drop_synonym(self):
            return self.getTypedRuleContext(tsqlParser.Drop_synonymContext,0)


        def drop_table(self):
            return self.getTypedRuleContext(tsqlParser.Drop_tableContext,0)


        def drop_type(self):
            return self.getTypedRuleContext(tsqlParser.Drop_typeContext,0)


        def drop_view(self):
            return self.getTypedRuleContext(tsqlParser.Drop_viewContext,0)


        def drop_database(self):
            return self.getTypedRuleContext(tsqlParser.Drop_databaseContext,0)


        def drop_schema(self):
            return self.getTypedRuleContext(tsqlParser.Drop_schemaContext,0)


        def drop_function(self):
            return self.getTypedRuleContext(tsqlParser.Drop_functionContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_ddl_clause




    def ddl_clause(self):

        localctx = tsqlParser.Ddl_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_ddl_clause)
        try:
            self.state = 472
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 450
                self.create_database()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 451
                self.create_index()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 452
                self.create_or_alter_function()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 453
                self.create_or_alter_procedure()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 454
                self.create_statistics()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 455
                self.create_schema()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 456
                self.create_synonym()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 457
                self.create_table()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 458
                self.create_type()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 459
                self.create_view()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 460
                self.alter_table()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 461
                self.alter_database()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 462
                self.drop_index()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 463
                self.drop_procedure()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 464
                self.drop_statistics()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 465
                self.drop_synonym()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 466
                self.drop_table()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 467
                self.drop_type()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 468
                self.drop_view()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 469
                self.drop_database()
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 470
                self.drop_schema()
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 471
                self.drop_function()
                pass


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


    class Cfl_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def if_statement(self):
            return self.getTypedRuleContext(tsqlParser.If_statementContext,0)


        def try_catch_statement(self):
            return self.getTypedRuleContext(tsqlParser.Try_catch_statementContext,0)


        def waitfor_statement(self):
            return self.getTypedRuleContext(tsqlParser.Waitfor_statementContext,0)


        def while_statement(self):
            return self.getTypedRuleContext(tsqlParser.While_statementContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_cfl_statement




    def cfl_statement(self):

        localctx = tsqlParser.Cfl_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_cfl_statement)
        try:
            self.state = 478
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.IF]:
                self.enterOuterAlt(localctx, 1)
                self.state = 474
                self.if_statement()
                pass
            elif token in [tsqlParser.BEGIN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 475
                self.try_catch_statement()
                pass
            elif token in [tsqlParser.WAITFOR]:
                self.enterOuterAlt(localctx, 3)
                self.state = 476
                self.waitfor_statement()
                pass
            elif token in [tsqlParser.WHILE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 477
                self.while_statement()
                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 Cfl_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block_statement(self):
            return self.getTypedRuleContext(tsqlParser.Block_statementContext,0)


        def break_statement(self):
            return self.getTypedRuleContext(tsqlParser.Break_statementContext,0)


        def continue_statement(self):
            return self.getTypedRuleContext(tsqlParser.Continue_statementContext,0)


        def goto_statement(self):
            return self.getTypedRuleContext(tsqlParser.Goto_statementContext,0)


        def return_statement(self):
            return self.getTypedRuleContext(tsqlParser.Return_statementContext,0)


        def throw_statement(self):
            return self.getTypedRuleContext(tsqlParser.Throw_statementContext,0)


        def raiseerror_statement(self):
            return self.getTypedRuleContext(tsqlParser.Raiseerror_statementContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_cfl_clause




    def cfl_clause(self):

        localctx = tsqlParser.Cfl_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_cfl_clause)
        try:
            self.state = 487
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 480
                self.block_statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 481
                self.break_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 482
                self.continue_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 483
                self.goto_statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 484
                self.return_statement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 485
                self.throw_statement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 486
                self.raiseerror_statement()
                pass


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


    class Block_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BEGIN(self):
            return self.getToken(tsqlParser.BEGIN, 0)

        def END(self):
            return self.getToken(tsqlParser.END, 0)

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

        def sql_clauses(self):
            return self.getTypedRuleContext(tsqlParser.Sql_clausesContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_block_statement




    def block_statement(self):

        localctx = tsqlParser.Block_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_block_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 489
            self.match(tsqlParser.BEGIN)
            self.state = 491
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SEMI:
                self.state = 490
                self.match(tsqlParser.SEMI)


            self.state = 494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << tsqlParser.ALTER) | (1 << tsqlParser.BEGIN) | (1 << tsqlParser.BREAK) | (1 << tsqlParser.CLOSE) | (1 << tsqlParser.COMMIT) | (1 << tsqlParser.CONTINUE) | (1 << tsqlParser.CREATE) | (1 << tsqlParser.DEALLOCATE) | (1 << tsqlParser.DECLARE) | (1 << tsqlParser.DELETE) | (1 << tsqlParser.DROP) | (1 << tsqlParser.EXECUTE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (tsqlParser.FETCH - 68)) | (1 << (tsqlParser.FILLFACTOR - 68)) | (1 << (tsqlParser.FORCESEEK - 68)) | (1 << (tsqlParser.GOTO - 68)) | (1 << (tsqlParser.GRANT - 68)) | (1 << (tsqlParser.IF - 68)) | (1 << (tsqlParser.INSERT - 68)) | (1 << (tsqlParser.NEXT - 68)) | (1 << (tsqlParser.NUMERIC - 68)) | (1 << (tsqlParser.OPEN - 68)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (tsqlParser.PRINT - 136)) | (1 << (tsqlParser.RAISERROR - 136)) | (1 << (tsqlParser.RETURN - 136)) | (1 << (tsqlParser.REVERT - 136)) | (1 << (tsqlParser.ROLLBACK - 136)) | (1 << (tsqlParser.SAVE - 136)) | (1 << (tsqlParser.SELECT - 136)) | (1 << (tsqlParser.SET - 136)) | (1 << (tsqlParser.UPDATE - 136)) | (1 << (tsqlParser.USE - 136)) | (1 << (tsqlParser.VALUE - 136)) | (1 << (tsqlParser.WAITFOR - 136)))) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & ((1 << (tsqlParser.WHILE - 202)) | (1 << (tsqlParser.WITH - 202)) | (1 << (tsqlParser.ABSOLUTE - 202)) | (1 << (tsqlParser.APPLY - 202)) | (1 << (tsqlParser.AUTO - 202)) | (1 << (tsqlParser.AVG - 202)) | (1 << (tsqlParser.BASE64 - 202)) | (1 << (tsqlParser.CALLER - 202)) | (1 << (tsqlParser.CAST - 202)) | (1 << (tsqlParser.CATCH - 202)) | (1 << (tsqlParser.CHECKSUM_AGG - 202)) | (1 << (tsqlParser.COMMITTED - 202)) | (1 << (tsqlParser.CONCAT - 202)) | (1 << (tsqlParser.CONTROL - 202)) | (1 << (tsqlParser.COOKIE - 202)) | (1 << (tsqlParser.COUNT - 202)) | (1 << (tsqlParser.COUNT_BIG - 202)) | (1 << (tsqlParser.DATE - 202)) | (1 << (tsqlParser.DELAY - 202)) | (1 << (tsqlParser.DELETED - 202)) | (1 << (tsqlParser.DENSE_RANK - 202)))) != 0) or ((((_la - 266)) & ~0x3f) == 0 and ((1 << (_la - 266)) & ((1 << (tsqlParser.DISABLE - 266)) | (1 << (tsqlParser.DYNAMIC - 266)) | (1 << (tsqlParser.ENCRYPTION - 266)) | (1 << (tsqlParser.EXIST - 266)) | (1 << (tsqlParser.EXPAND - 266)) | (1 << (tsqlParser.FAST - 266)) | (1 << (tsqlParser.FAST_FORWARD - 266)) | (1 << (tsqlParser.FIRST - 266)) | (1 << (tsqlParser.FIRST_VALUE - 266)) | (1 << (tsqlParser.FOLLOWING - 266)) | (1 << (tsqlParser.FORCE - 266)) | (1 << (tsqlParser.FORCED - 266)) | (1 << (tsqlParser.FORWARD_ONLY - 266)) | (1 << (tsqlParser.FULLSCAN - 266)) | (1 << (tsqlParser.GLOBAL - 266)) | (1 << (tsqlParser.GROUPING - 266)) | (1 << (tsqlParser.GROUPING_ID - 266)) | (1 << (tsqlParser.HASH - 266)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 266)) | (1 << (tsqlParser.IMPERSONATE - 266)) | (1 << (tsqlParser.INSENSITIVE - 266)) | (1 << (tsqlParser.INSERTED - 266)) | (1 << (tsqlParser.ISOLATION - 266)) | (1 << (tsqlParser.IO - 266)) | (1 << (tsqlParser.KEEP - 266)) | (1 << (tsqlParser.KEEPFIXED - 266)) | (1 << (tsqlParser.KEYSET - 266)) | (1 << (tsqlParser.LAG - 266)) | (1 << (tsqlParser.LAST - 266)) | (1 << (tsqlParser.LAST_VALUE - 266)) | (1 << (tsqlParser.LEAD - 266)) | (1 << (tsqlParser.LEVEL - 266)) | (1 << (tsqlParser.LOCAL - 266)) | (1 << (tsqlParser.LOCK_ESCALATION - 266)) | (1 << (tsqlParser.LOGIN - 266)) | (1 << (tsqlParser.LOOP - 266)) | (1 << (tsqlParser.MARK - 266)) | (1 << (tsqlParser.MAX - 266)) | (1 << (tsqlParser.MAXDOP - 266)) | (1 << (tsqlParser.MAXRECURSION - 266)) | (1 << (tsqlParser.MIN - 266)))) != 0) or ((((_la - 332)) & ~0x3f) == 0 and ((1 << (_la - 332)) & ((1 << (tsqlParser.MODIFY - 332)) | (1 << (tsqlParser.NAME - 332)) | (1 << (tsqlParser.NOCOUNT - 332)) | (1 << (tsqlParser.NODES - 332)) | (1 << (tsqlParser.NOEXPAND - 332)) | (1 << (tsqlParser.NORECOMPUTE - 332)) | (1 << (tsqlParser.NTILE - 332)) | (1 << (tsqlParser.NUMBER - 332)) | (1 << (tsqlParser.OFFSET - 332)) | (1 << (tsqlParser.ONLINE - 332)) | (1 << (tsqlParser.ONLY - 332)) | (1 << (tsqlParser.OPTIMISTIC - 332)) | (1 << (tsqlParser.OPTIMIZE - 332)) | (1 << (tsqlParser.OUT - 332)) | (1 << (tsqlParser.OUTPUT - 332)) | (1 << (tsqlParser.OWNER - 332)) | (1 << (tsqlParser.PARAMETERIZATION - 332)) | (1 << (tsqlParser.PARTITION - 332)) | (1 << (tsqlParser.PATH - 332)) | (1 << (tsqlParser.PRECEDING - 332)) | (1 << (tsqlParser.PRIOR - 332)) | (1 << (tsqlParser.PRIVILEGES - 332)) | (1 << (tsqlParser.QUERY - 332)) | (1 << (tsqlParser.RANGE - 332)) | (1 << (tsqlParser.RANK - 332)) | (1 << (tsqlParser.READONLY - 332)) | (1 << (tsqlParser.READ_ONLY - 332)) | (1 << (tsqlParser.RECOMPILE - 332)) | (1 << (tsqlParser.RELATIVE - 332)) | (1 << (tsqlParser.REMOTE - 332)) | (1 << (tsqlParser.REPEATABLE - 332)) | (1 << (tsqlParser.ROBUST - 332)) | (1 << (tsqlParser.ROOT - 332)) | (1 << (tsqlParser.ROW - 332)) | (1 << (tsqlParser.ROWGUID - 332)) | (1 << (tsqlParser.ROWS - 332)) | (1 << (tsqlParser.ROW_NUMBER - 332)) | (1 << (tsqlParser.SAMPLE - 332)) | (1 << (tsqlParser.SCHEMABINDING - 332)) | (1 << (tsqlParser.SCROLL - 332)) | (1 << (tsqlParser.SCROLL_LOCKS - 332)) | (1 << (tsqlParser.SELF - 332)) | (1 << (tsqlParser.SERIALIZABLE - 332)))) != 0) or ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (tsqlParser.SIMPLE - 397)) | (1 << (tsqlParser.SIZE - 397)) | (1 << (tsqlParser.SNAPSHOT - 397)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 397)) | (1 << (tsqlParser.STATIC - 397)) | (1 << (tsqlParser.STATS_STREAM - 397)) | (1 << (tsqlParser.STDEV - 397)) | (1 << (tsqlParser.STDEVP - 397)) | (1 << (tsqlParser.SUM - 397)) | (1 << (tsqlParser.TEXTIMAGE_ON - 397)) | (1 << (tsqlParser.THROW - 397)) | (1 << (tsqlParser.TIES - 397)) | (1 << (tsqlParser.TIME - 397)) | (1 << (tsqlParser.TRY - 397)) | (1 << (tsqlParser.TYPE - 397)) | (1 << (tsqlParser.TYPE_WARNING - 397)) | (1 << (tsqlParser.UNBOUNDED - 397)) | (1 << (tsqlParser.UNCOMMITTED - 397)) | (1 << (tsqlParser.UNKNOWN - 397)) | (1 << (tsqlParser.USING - 397)) | (1 << (tsqlParser.VAR - 397)) | (1 << (tsqlParser.VARP - 397)) | (1 << (tsqlParser.VIEWS - 397)) | (1 << (tsqlParser.VIEW_METADATA - 397)) | (1 << (tsqlParser.WORK - 397)) | (1 << (tsqlParser.XML - 397)) | (1 << (tsqlParser.XMLNAMESPACES - 397)) | (1 << (tsqlParser.ZONE - 397)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 397)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 397)) | (1 << (tsqlParser.ID - 397)))) != 0) or _la==tsqlParser.LR_BRACKET:
                self.state = 493
                self.sql_clauses()


            self.state = 496
            self.match(tsqlParser.END)
            self.state = 498
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.state = 497
                self.match(tsqlParser.SEMI)


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


    class Break_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BREAK(self):
            return self.getToken(tsqlParser.BREAK, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_break_statement




    def break_statement(self):

        localctx = tsqlParser.Break_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_break_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 500
            self.match(tsqlParser.BREAK)
            self.state = 502
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.state = 501
                self.match(tsqlParser.SEMI)


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


    class Continue_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CONTINUE(self):
            return self.getToken(tsqlParser.CONTINUE, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_continue_statement




    def continue_statement(self):

        localctx = tsqlParser.Continue_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_continue_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 504
            self.match(tsqlParser.CONTINUE)
            self.state = 506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.state = 505
                self.match(tsqlParser.SEMI)


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


    class Goto_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GOTO(self):
            return self.getToken(tsqlParser.GOTO, 0)

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def COLON(self):
            return self.getToken(tsqlParser.COLON, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_goto_statement




    def goto_statement(self):

        localctx = tsqlParser.Goto_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_goto_statement)
        try:
            self.state = 518
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.GOTO]:
                self.enterOuterAlt(localctx, 1)
                self.state = 508
                self.match(tsqlParser.GOTO)
                self.state = 509
                self.r_id()
                self.state = 511
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
                if la_ == 1:
                    self.state = 510
                    self.match(tsqlParser.SEMI)


                pass
            elif token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 513
                self.r_id()
                self.state = 514
                self.match(tsqlParser.COLON)
                self.state = 516
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
                if la_ == 1:
                    self.state = 515
                    self.match(tsqlParser.SEMI)


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

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

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

        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)


        def if_block(self):
            return self.getTypedRuleContext(tsqlParser.If_blockContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_if_statement




    def if_statement(self):

        localctx = tsqlParser.If_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_if_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 520
            self.match(tsqlParser.IF)
            self.state = 521
            self.search_condition(0)
            self.state = 522
            self.if_block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class If_blockContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.if_expr = None # Sql_clauseContext
            self.else_expr = None # Sql_clauseContext
            self.if_block_expr = None # Block_statementContext
            self.else_block_expr = None # Block_statementContext

        def sql_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Sql_clauseContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Sql_clauseContext,i)


        def ELSE(self):
            return self.getToken(tsqlParser.ELSE, 0)

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

        def block_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Block_statementContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Block_statementContext,i)


        def getRuleIndex(self):
            return tsqlParser.RULE_if_block




    def if_block(self):

        localctx = tsqlParser.If_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_if_block)
        try:
            self.state = 540
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 524
                localctx.if_expr = self.sql_clause()
                self.state = 527
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                if la_ == 1:
                    self.state = 525
                    self.match(tsqlParser.ELSE)
                    self.state = 526
                    localctx.else_expr = self.sql_clause()


                self.state = 530
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
                if la_ == 1:
                    self.state = 529
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 532
                localctx.if_block_expr = self.block_statement()
                self.state = 535
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
                if la_ == 1:
                    self.state = 533
                    self.match(tsqlParser.ELSE)
                    self.state = 534
                    localctx.else_block_expr = self.block_statement()


                self.state = 538
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
                if la_ == 1:
                    self.state = 537
                    self.match(tsqlParser.SEMI)


                pass


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


    class Return_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RETURN(self):
            return self.getToken(tsqlParser.RETURN, 0)

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


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

        def getRuleIndex(self):
            return tsqlParser.RULE_return_statement




    def return_statement(self):

        localctx = tsqlParser.Return_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_return_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 542
            self.match(tsqlParser.RETURN)
            self.state = 544
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.state = 543
                self.expression(0)


            self.state = 547
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.state = 546
                self.match(tsqlParser.SEMI)


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


    class Throw_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def THROW(self):
            return self.getToken(tsqlParser.THROW, 0)

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

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

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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_throw_statement




    def throw_statement(self):

        localctx = tsqlParser.Throw_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_throw_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 549
            self.match(tsqlParser.THROW)
            self.state = 555
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.LOCAL_ID or _la==tsqlParser.DECIMAL:
                self.state = 550
                localctx.error_number = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.LOCAL_ID or _la==tsqlParser.DECIMAL):
                    localctx.error_number = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 551
                self.match(tsqlParser.COMMA)
                self.state = 552
                localctx.message = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.LOCAL_ID or _la==tsqlParser.STRING):
                    localctx.message = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 553
                self.match(tsqlParser.COMMA)
                self.state = 554
                localctx.state = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.LOCAL_ID or _la==tsqlParser.DECIMAL):
                    localctx.state = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 558
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.state = 557
                self.match(tsqlParser.SEMI)


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


    class Try_catch_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

        def sql_clauses(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Sql_clausesContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Sql_clausesContext,i)


        def getRuleIndex(self):
            return tsqlParser.RULE_try_catch_statement




    def try_catch_statement(self):

        localctx = tsqlParser.Try_catch_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_try_catch_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 560
            self.match(tsqlParser.BEGIN)
            self.state = 561
            self.match(tsqlParser.TRY)
            self.state = 563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SEMI:
                self.state = 562
                self.match(tsqlParser.SEMI)


            self.state = 566
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << tsqlParser.ALTER) | (1 << tsqlParser.BEGIN) | (1 << tsqlParser.BREAK) | (1 << tsqlParser.CLOSE) | (1 << tsqlParser.COMMIT) | (1 << tsqlParser.CONTINUE) | (1 << tsqlParser.CREATE) | (1 << tsqlParser.DEALLOCATE) | (1 << tsqlParser.DECLARE) | (1 << tsqlParser.DELETE) | (1 << tsqlParser.DROP) | (1 << tsqlParser.EXECUTE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (tsqlParser.FETCH - 68)) | (1 << (tsqlParser.FILLFACTOR - 68)) | (1 << (tsqlParser.FORCESEEK - 68)) | (1 << (tsqlParser.GOTO - 68)) | (1 << (tsqlParser.GRANT - 68)) | (1 << (tsqlParser.IF - 68)) | (1 << (tsqlParser.INSERT - 68)) | (1 << (tsqlParser.NEXT - 68)) | (1 << (tsqlParser.NUMERIC - 68)) | (1 << (tsqlParser.OPEN - 68)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (tsqlParser.PRINT - 136)) | (1 << (tsqlParser.RAISERROR - 136)) | (1 << (tsqlParser.RETURN - 136)) | (1 << (tsqlParser.REVERT - 136)) | (1 << (tsqlParser.ROLLBACK - 136)) | (1 << (tsqlParser.SAVE - 136)) | (1 << (tsqlParser.SELECT - 136)) | (1 << (tsqlParser.SET - 136)) | (1 << (tsqlParser.UPDATE - 136)) | (1 << (tsqlParser.USE - 136)) | (1 << (tsqlParser.VALUE - 136)) | (1 << (tsqlParser.WAITFOR - 136)))) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & ((1 << (tsqlParser.WHILE - 202)) | (1 << (tsqlParser.WITH - 202)) | (1 << (tsqlParser.ABSOLUTE - 202)) | (1 << (tsqlParser.APPLY - 202)) | (1 << (tsqlParser.AUTO - 202)) | (1 << (tsqlParser.AVG - 202)) | (1 << (tsqlParser.BASE64 - 202)) | (1 << (tsqlParser.CALLER - 202)) | (1 << (tsqlParser.CAST - 202)) | (1 << (tsqlParser.CATCH - 202)) | (1 << (tsqlParser.CHECKSUM_AGG - 202)) | (1 << (tsqlParser.COMMITTED - 202)) | (1 << (tsqlParser.CONCAT - 202)) | (1 << (tsqlParser.CONTROL - 202)) | (1 << (tsqlParser.COOKIE - 202)) | (1 << (tsqlParser.COUNT - 202)) | (1 << (tsqlParser.COUNT_BIG - 202)) | (1 << (tsqlParser.DATE - 202)) | (1 << (tsqlParser.DELAY - 202)) | (1 << (tsqlParser.DELETED - 202)) | (1 << (tsqlParser.DENSE_RANK - 202)))) != 0) or ((((_la - 266)) & ~0x3f) == 0 and ((1 << (_la - 266)) & ((1 << (tsqlParser.DISABLE - 266)) | (1 << (tsqlParser.DYNAMIC - 266)) | (1 << (tsqlParser.ENCRYPTION - 266)) | (1 << (tsqlParser.EXIST - 266)) | (1 << (tsqlParser.EXPAND - 266)) | (1 << (tsqlParser.FAST - 266)) | (1 << (tsqlParser.FAST_FORWARD - 266)) | (1 << (tsqlParser.FIRST - 266)) | (1 << (tsqlParser.FIRST_VALUE - 266)) | (1 << (tsqlParser.FOLLOWING - 266)) | (1 << (tsqlParser.FORCE - 266)) | (1 << (tsqlParser.FORCED - 266)) | (1 << (tsqlParser.FORWARD_ONLY - 266)) | (1 << (tsqlParser.FULLSCAN - 266)) | (1 << (tsqlParser.GLOBAL - 266)) | (1 << (tsqlParser.GROUPING - 266)) | (1 << (tsqlParser.GROUPING_ID - 266)) | (1 << (tsqlParser.HASH - 266)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 266)) | (1 << (tsqlParser.IMPERSONATE - 266)) | (1 << (tsqlParser.INSENSITIVE - 266)) | (1 << (tsqlParser.INSERTED - 266)) | (1 << (tsqlParser.ISOLATION - 266)) | (1 << (tsqlParser.IO - 266)) | (1 << (tsqlParser.KEEP - 266)) | (1 << (tsqlParser.KEEPFIXED - 266)) | (1 << (tsqlParser.KEYSET - 266)) | (1 << (tsqlParser.LAG - 266)) | (1 << (tsqlParser.LAST - 266)) | (1 << (tsqlParser.LAST_VALUE - 266)) | (1 << (tsqlParser.LEAD - 266)) | (1 << (tsqlParser.LEVEL - 266)) | (1 << (tsqlParser.LOCAL - 266)) | (1 << (tsqlParser.LOCK_ESCALATION - 266)) | (1 << (tsqlParser.LOGIN - 266)) | (1 << (tsqlParser.LOOP - 266)) | (1 << (tsqlParser.MARK - 266)) | (1 << (tsqlParser.MAX - 266)) | (1 << (tsqlParser.MAXDOP - 266)) | (1 << (tsqlParser.MAXRECURSION - 266)) | (1 << (tsqlParser.MIN - 266)))) != 0) or ((((_la - 332)) & ~0x3f) == 0 and ((1 << (_la - 332)) & ((1 << (tsqlParser.MODIFY - 332)) | (1 << (tsqlParser.NAME - 332)) | (1 << (tsqlParser.NOCOUNT - 332)) | (1 << (tsqlParser.NODES - 332)) | (1 << (tsqlParser.NOEXPAND - 332)) | (1 << (tsqlParser.NORECOMPUTE - 332)) | (1 << (tsqlParser.NTILE - 332)) | (1 << (tsqlParser.NUMBER - 332)) | (1 << (tsqlParser.OFFSET - 332)) | (1 << (tsqlParser.ONLINE - 332)) | (1 << (tsqlParser.ONLY - 332)) | (1 << (tsqlParser.OPTIMISTIC - 332)) | (1 << (tsqlParser.OPTIMIZE - 332)) | (1 << (tsqlParser.OUT - 332)) | (1 << (tsqlParser.OUTPUT - 332)) | (1 << (tsqlParser.OWNER - 332)) | (1 << (tsqlParser.PARAMETERIZATION - 332)) | (1 << (tsqlParser.PARTITION - 332)) | (1 << (tsqlParser.PATH - 332)) | (1 << (tsqlParser.PRECEDING - 332)) | (1 << (tsqlParser.PRIOR - 332)) | (1 << (tsqlParser.PRIVILEGES - 332)) | (1 << (tsqlParser.QUERY - 332)) | (1 << (tsqlParser.RANGE - 332)) | (1 << (tsqlParser.RANK - 332)) | (1 << (tsqlParser.READONLY - 332)) | (1 << (tsqlParser.READ_ONLY - 332)) | (1 << (tsqlParser.RECOMPILE - 332)) | (1 << (tsqlParser.RELATIVE - 332)) | (1 << (tsqlParser.REMOTE - 332)) | (1 << (tsqlParser.REPEATABLE - 332)) | (1 << (tsqlParser.ROBUST - 332)) | (1 << (tsqlParser.ROOT - 332)) | (1 << (tsqlParser.ROW - 332)) | (1 << (tsqlParser.ROWGUID - 332)) | (1 << (tsqlParser.ROWS - 332)) | (1 << (tsqlParser.ROW_NUMBER - 332)) | (1 << (tsqlParser.SAMPLE - 332)) | (1 << (tsqlParser.SCHEMABINDING - 332)) | (1 << (tsqlParser.SCROLL - 332)) | (1 << (tsqlParser.SCROLL_LOCKS - 332)) | (1 << (tsqlParser.SELF - 332)) | (1 << (tsqlParser.SERIALIZABLE - 332)))) != 0) or ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (tsqlParser.SIMPLE - 397)) | (1 << (tsqlParser.SIZE - 397)) | (1 << (tsqlParser.SNAPSHOT - 397)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 397)) | (1 << (tsqlParser.STATIC - 397)) | (1 << (tsqlParser.STATS_STREAM - 397)) | (1 << (tsqlParser.STDEV - 397)) | (1 << (tsqlParser.STDEVP - 397)) | (1 << (tsqlParser.SUM - 397)) | (1 << (tsqlParser.TEXTIMAGE_ON - 397)) | (1 << (tsqlParser.THROW - 397)) | (1 << (tsqlParser.TIES - 397)) | (1 << (tsqlParser.TIME - 397)) | (1 << (tsqlParser.TRY - 397)) | (1 << (tsqlParser.TYPE - 397)) | (1 << (tsqlParser.TYPE_WARNING - 397)) | (1 << (tsqlParser.UNBOUNDED - 397)) | (1 << (tsqlParser.UNCOMMITTED - 397)) | (1 << (tsqlParser.UNKNOWN - 397)) | (1 << (tsqlParser.USING - 397)) | (1 << (tsqlParser.VAR - 397)) | (1 << (tsqlParser.VARP - 397)) | (1 << (tsqlParser.VIEWS - 397)) | (1 << (tsqlParser.VIEW_METADATA - 397)) | (1 << (tsqlParser.WORK - 397)) | (1 << (tsqlParser.XML - 397)) | (1 << (tsqlParser.XMLNAMESPACES - 397)) | (1 << (tsqlParser.ZONE - 397)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 397)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 397)) | (1 << (tsqlParser.ID - 397)))) != 0) or _la==tsqlParser.LR_BRACKET:
                self.state = 565
                localctx.try_clauses = self.sql_clauses()


            self.state = 568
            self.match(tsqlParser.END)
            self.state = 569
            self.match(tsqlParser.TRY)
            self.state = 571
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SEMI:
                self.state = 570
                self.match(tsqlParser.SEMI)


            self.state = 573
            self.match(tsqlParser.BEGIN)
            self.state = 574
            self.match(tsqlParser.CATCH)
            self.state = 576
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SEMI:
                self.state = 575
                self.match(tsqlParser.SEMI)


            self.state = 579
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << tsqlParser.ALTER) | (1 << tsqlParser.BEGIN) | (1 << tsqlParser.BREAK) | (1 << tsqlParser.CLOSE) | (1 << tsqlParser.COMMIT) | (1 << tsqlParser.CONTINUE) | (1 << tsqlParser.CREATE) | (1 << tsqlParser.DEALLOCATE) | (1 << tsqlParser.DECLARE) | (1 << tsqlParser.DELETE) | (1 << tsqlParser.DROP) | (1 << tsqlParser.EXECUTE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (tsqlParser.FETCH - 68)) | (1 << (tsqlParser.FILLFACTOR - 68)) | (1 << (tsqlParser.FORCESEEK - 68)) | (1 << (tsqlParser.GOTO - 68)) | (1 << (tsqlParser.GRANT - 68)) | (1 << (tsqlParser.IF - 68)) | (1 << (tsqlParser.INSERT - 68)) | (1 << (tsqlParser.NEXT - 68)) | (1 << (tsqlParser.NUMERIC - 68)) | (1 << (tsqlParser.OPEN - 68)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (tsqlParser.PRINT - 136)) | (1 << (tsqlParser.RAISERROR - 136)) | (1 << (tsqlParser.RETURN - 136)) | (1 << (tsqlParser.REVERT - 136)) | (1 << (tsqlParser.ROLLBACK - 136)) | (1 << (tsqlParser.SAVE - 136)) | (1 << (tsqlParser.SELECT - 136)) | (1 << (tsqlParser.SET - 136)) | (1 << (tsqlParser.UPDATE - 136)) | (1 << (tsqlParser.USE - 136)) | (1 << (tsqlParser.VALUE - 136)) | (1 << (tsqlParser.WAITFOR - 136)))) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & ((1 << (tsqlParser.WHILE - 202)) | (1 << (tsqlParser.WITH - 202)) | (1 << (tsqlParser.ABSOLUTE - 202)) | (1 << (tsqlParser.APPLY - 202)) | (1 << (tsqlParser.AUTO - 202)) | (1 << (tsqlParser.AVG - 202)) | (1 << (tsqlParser.BASE64 - 202)) | (1 << (tsqlParser.CALLER - 202)) | (1 << (tsqlParser.CAST - 202)) | (1 << (tsqlParser.CATCH - 202)) | (1 << (tsqlParser.CHECKSUM_AGG - 202)) | (1 << (tsqlParser.COMMITTED - 202)) | (1 << (tsqlParser.CONCAT - 202)) | (1 << (tsqlParser.CONTROL - 202)) | (1 << (tsqlParser.COOKIE - 202)) | (1 << (tsqlParser.COUNT - 202)) | (1 << (tsqlParser.COUNT_BIG - 202)) | (1 << (tsqlParser.DATE - 202)) | (1 << (tsqlParser.DELAY - 202)) | (1 << (tsqlParser.DELETED - 202)) | (1 << (tsqlParser.DENSE_RANK - 202)))) != 0) or ((((_la - 266)) & ~0x3f) == 0 and ((1 << (_la - 266)) & ((1 << (tsqlParser.DISABLE - 266)) | (1 << (tsqlParser.DYNAMIC - 266)) | (1 << (tsqlParser.ENCRYPTION - 266)) | (1 << (tsqlParser.EXIST - 266)) | (1 << (tsqlParser.EXPAND - 266)) | (1 << (tsqlParser.FAST - 266)) | (1 << (tsqlParser.FAST_FORWARD - 266)) | (1 << (tsqlParser.FIRST - 266)) | (1 << (tsqlParser.FIRST_VALUE - 266)) | (1 << (tsqlParser.FOLLOWING - 266)) | (1 << (tsqlParser.FORCE - 266)) | (1 << (tsqlParser.FORCED - 266)) | (1 << (tsqlParser.FORWARD_ONLY - 266)) | (1 << (tsqlParser.FULLSCAN - 266)) | (1 << (tsqlParser.GLOBAL - 266)) | (1 << (tsqlParser.GROUPING - 266)) | (1 << (tsqlParser.GROUPING_ID - 266)) | (1 << (tsqlParser.HASH - 266)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 266)) | (1 << (tsqlParser.IMPERSONATE - 266)) | (1 << (tsqlParser.INSENSITIVE - 266)) | (1 << (tsqlParser.INSERTED - 266)) | (1 << (tsqlParser.ISOLATION - 266)) | (1 << (tsqlParser.IO - 266)) | (1 << (tsqlParser.KEEP - 266)) | (1 << (tsqlParser.KEEPFIXED - 266)) | (1 << (tsqlParser.KEYSET - 266)) | (1 << (tsqlParser.LAG - 266)) | (1 << (tsqlParser.LAST - 266)) | (1 << (tsqlParser.LAST_VALUE - 266)) | (1 << (tsqlParser.LEAD - 266)) | (1 << (tsqlParser.LEVEL - 266)) | (1 << (tsqlParser.LOCAL - 266)) | (1 << (tsqlParser.LOCK_ESCALATION - 266)) | (1 << (tsqlParser.LOGIN - 266)) | (1 << (tsqlParser.LOOP - 266)) | (1 << (tsqlParser.MARK - 266)) | (1 << (tsqlParser.MAX - 266)) | (1 << (tsqlParser.MAXDOP - 266)) | (1 << (tsqlParser.MAXRECURSION - 266)) | (1 << (tsqlParser.MIN - 266)))) != 0) or ((((_la - 332)) & ~0x3f) == 0 and ((1 << (_la - 332)) & ((1 << (tsqlParser.MODIFY - 332)) | (1 << (tsqlParser.NAME - 332)) | (1 << (tsqlParser.NOCOUNT - 332)) | (1 << (tsqlParser.NODES - 332)) | (1 << (tsqlParser.NOEXPAND - 332)) | (1 << (tsqlParser.NORECOMPUTE - 332)) | (1 << (tsqlParser.NTILE - 332)) | (1 << (tsqlParser.NUMBER - 332)) | (1 << (tsqlParser.OFFSET - 332)) | (1 << (tsqlParser.ONLINE - 332)) | (1 << (tsqlParser.ONLY - 332)) | (1 << (tsqlParser.OPTIMISTIC - 332)) | (1 << (tsqlParser.OPTIMIZE - 332)) | (1 << (tsqlParser.OUT - 332)) | (1 << (tsqlParser.OUTPUT - 332)) | (1 << (tsqlParser.OWNER - 332)) | (1 << (tsqlParser.PARAMETERIZATION - 332)) | (1 << (tsqlParser.PARTITION - 332)) | (1 << (tsqlParser.PATH - 332)) | (1 << (tsqlParser.PRECEDING - 332)) | (1 << (tsqlParser.PRIOR - 332)) | (1 << (tsqlParser.PRIVILEGES - 332)) | (1 << (tsqlParser.QUERY - 332)) | (1 << (tsqlParser.RANGE - 332)) | (1 << (tsqlParser.RANK - 332)) | (1 << (tsqlParser.READONLY - 332)) | (1 << (tsqlParser.READ_ONLY - 332)) | (1 << (tsqlParser.RECOMPILE - 332)) | (1 << (tsqlParser.RELATIVE - 332)) | (1 << (tsqlParser.REMOTE - 332)) | (1 << (tsqlParser.REPEATABLE - 332)) | (1 << (tsqlParser.ROBUST - 332)) | (1 << (tsqlParser.ROOT - 332)) | (1 << (tsqlParser.ROW - 332)) | (1 << (tsqlParser.ROWGUID - 332)) | (1 << (tsqlParser.ROWS - 332)) | (1 << (tsqlParser.ROW_NUMBER - 332)) | (1 << (tsqlParser.SAMPLE - 332)) | (1 << (tsqlParser.SCHEMABINDING - 332)) | (1 << (tsqlParser.SCROLL - 332)) | (1 << (tsqlParser.SCROLL_LOCKS - 332)) | (1 << (tsqlParser.SELF - 332)) | (1 << (tsqlParser.SERIALIZABLE - 332)))) != 0) or ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (tsqlParser.SIMPLE - 397)) | (1 << (tsqlParser.SIZE - 397)) | (1 << (tsqlParser.SNAPSHOT - 397)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 397)) | (1 << (tsqlParser.STATIC - 397)) | (1 << (tsqlParser.STATS_STREAM - 397)) | (1 << (tsqlParser.STDEV - 397)) | (1 << (tsqlParser.STDEVP - 397)) | (1 << (tsqlParser.SUM - 397)) | (1 << (tsqlParser.TEXTIMAGE_ON - 397)) | (1 << (tsqlParser.THROW - 397)) | (1 << (tsqlParser.TIES - 397)) | (1 << (tsqlParser.TIME - 397)) | (1 << (tsqlParser.TRY - 397)) | (1 << (tsqlParser.TYPE - 397)) | (1 << (tsqlParser.TYPE_WARNING - 397)) | (1 << (tsqlParser.UNBOUNDED - 397)) | (1 << (tsqlParser.UNCOMMITTED - 397)) | (1 << (tsqlParser.UNKNOWN - 397)) | (1 << (tsqlParser.USING - 397)) | (1 << (tsqlParser.VAR - 397)) | (1 << (tsqlParser.VARP - 397)) | (1 << (tsqlParser.VIEWS - 397)) | (1 << (tsqlParser.VIEW_METADATA - 397)) | (1 << (tsqlParser.WORK - 397)) | (1 << (tsqlParser.XML - 397)) | (1 << (tsqlParser.XMLNAMESPACES - 397)) | (1 << (tsqlParser.ZONE - 397)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 397)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 397)) | (1 << (tsqlParser.ID - 397)))) != 0) or _la==tsqlParser.LR_BRACKET:
                self.state = 578
                localctx.catch_clauses = self.sql_clauses()


            self.state = 581
            self.match(tsqlParser.END)
            self.state = 582
            self.match(tsqlParser.CATCH)
            self.state = 584
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
            if la_ == 1:
                self.state = 583
                self.match(tsqlParser.SEMI)


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


    class Waitfor_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WAITFOR(self):
            return self.getToken(tsqlParser.WAITFOR, 0)

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


        def DELAY(self):
            return self.getToken(tsqlParser.DELAY, 0)

        def TIME(self):
            return self.getToken(tsqlParser.TIME, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_waitfor_statement




    def waitfor_statement(self):

        localctx = tsqlParser.Waitfor_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_waitfor_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 586
            self.match(tsqlParser.WAITFOR)
            self.state = 587
            _la = self._input.LA(1)
            if not(_la==tsqlParser.DELAY or _la==tsqlParser.TIME):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 588
            self.expression(0)
            self.state = 590
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.state = 589
                self.match(tsqlParser.SEMI)


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


    class While_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHILE(self):
            return self.getToken(tsqlParser.WHILE, 0)

        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)


        def sql_clause(self):
            return self.getTypedRuleContext(tsqlParser.Sql_clauseContext,0)


        def BREAK(self):
            return self.getToken(tsqlParser.BREAK, 0)

        def CONTINUE(self):
            return self.getToken(tsqlParser.CONTINUE, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_while_statement




    def while_statement(self):

        localctx = tsqlParser.While_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_while_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 592
            self.match(tsqlParser.WHILE)
            self.state = 593
            self.search_condition(0)
            self.state = 603
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.state = 594
                self.sql_clause()
                pass

            elif la_ == 2:
                self.state = 595
                self.match(tsqlParser.BREAK)
                self.state = 597
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                if la_ == 1:
                    self.state = 596
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 3:
                self.state = 599
                self.match(tsqlParser.CONTINUE)
                self.state = 601
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                if la_ == 1:
                    self.state = 600
                    self.match(tsqlParser.SEMI)


                pass


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


    class Print_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def getRuleIndex(self):
            return tsqlParser.RULE_print_statement




    def print_statement(self):

        localctx = tsqlParser.Print_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_print_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 605
            self.match(tsqlParser.PRINT)
            self.state = 606
            self.expression(0)
            self.state = 608
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
            if la_ == 1:
                self.state = 607
                self.match(tsqlParser.SEMI)


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


    class Raiseerror_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RAISERROR(self):
            return self.getToken(tsqlParser.RAISERROR, 0)

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

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

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

        def constant_LOCAL_ID(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Constant_LOCAL_IDContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Constant_LOCAL_IDContext,i)


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

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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_raiseerror_statement




    def raiseerror_statement(self):

        localctx = tsqlParser.Raiseerror_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_raiseerror_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 610
            self.match(tsqlParser.RAISERROR)
            self.state = 611
            self.match(tsqlParser.LR_BRACKET)
            self.state = 612
            localctx.msg = self._input.LT(1)
            _la = self._input.LA(1)
            if not(((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (tsqlParser.LOCAL_ID - 448)) | (1 << (tsqlParser.DECIMAL - 448)) | (1 << (tsqlParser.STRING - 448)))) != 0)):
                localctx.msg = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 613
            self.match(tsqlParser.COMMA)
            self.state = 614
            localctx.severity = self.constant_LOCAL_ID()
            self.state = 615
            self.match(tsqlParser.COMMA)
            self.state = 616
            localctx.state = self.constant_LOCAL_ID()
            self.state = 621
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 617
                self.match(tsqlParser.COMMA)
                self.state = 618
                self.constant_LOCAL_ID()
                self.state = 623
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 624
            self.match(tsqlParser.RR_BRACKET)
            self.state = 626
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.state = 625
                self.match(tsqlParser.SEMI)


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


    class Another_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def cursor_statement(self):
            return self.getTypedRuleContext(tsqlParser.Cursor_statementContext,0)


        def execute_statement(self):
            return self.getTypedRuleContext(tsqlParser.Execute_statementContext,0)


        def security_statement(self):
            return self.getTypedRuleContext(tsqlParser.Security_statementContext,0)


        def set_statement(self):
            return self.getTypedRuleContext(tsqlParser.Set_statementContext,0)


        def transaction_statement(self):
            return self.getTypedRuleContext(tsqlParser.Transaction_statementContext,0)


        def use_statement(self):
            return self.getTypedRuleContext(tsqlParser.Use_statementContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_another_statement




    def another_statement(self):

        localctx = tsqlParser.Another_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_another_statement)
        try:
            self.state = 634
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 628
                self.cursor_statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 629
                self.execute_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 630
                self.security_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 631
                self.set_statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 632
                self.transaction_statement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 633
                self.use_statement()
                pass


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


    class Delete_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def delete_statement_from(self):
            return self.getTypedRuleContext(tsqlParser.Delete_statement_fromContext,0)


        def with_expression(self):
            return self.getTypedRuleContext(tsqlParser.With_expressionContext,0)


        def top_clause_dm(self):
            return self.getTypedRuleContext(tsqlParser.Top_clause_dmContext,0)


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

        def insert_with_table_hints(self):
            return self.getTypedRuleContext(tsqlParser.Insert_with_table_hintsContext,0)


        def output_clause(self):
            return self.getTypedRuleContext(tsqlParser.Output_clauseContext,0)


        def table_sources(self):
            return self.getTypedRuleContext(tsqlParser.Table_sourcesContext,0)


        def where_clause_dml(self):
            return self.getTypedRuleContext(tsqlParser.Where_clause_dmlContext,0)


        def for_clause(self):
            return self.getTypedRuleContext(tsqlParser.For_clauseContext,0)


        def option_clause(self):
            return self.getTypedRuleContext(tsqlParser.Option_clauseContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_delete_statement




    def delete_statement(self):

        localctx = tsqlParser.Delete_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_delete_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 637
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 636
                self.with_expression()


            self.state = 639
            self.match(tsqlParser.DELETE)
            self.state = 641
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.TOP:
                self.state = 640
                self.top_clause_dm()


            self.state = 644
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FROM:
                self.state = 643
                self.match(tsqlParser.FROM)


            self.state = 646
            self.delete_statement_from()
            self.state = 648
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
            if la_ == 1:
                self.state = 647
                self.insert_with_table_hints()


            self.state = 651
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
            if la_ == 1:
                self.state = 650
                self.output_clause()


            self.state = 655
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FROM:
                self.state = 653
                self.match(tsqlParser.FROM)
                self.state = 654
                self.table_sources()


            self.state = 658
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WHERE:
                self.state = 657
                self.where_clause_dml()


            self.state = 661
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FOR:
                self.state = 660
                self.for_clause()


            self.state = 664
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.OPTION:
                self.state = 663
                self.option_clause()


            self.state = 667
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
            if la_ == 1:
                self.state = 666
                self.match(tsqlParser.SEMI)


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


    class Delete_statement_fromContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def with_table_hints(self):
            return self.getTypedRuleContext(tsqlParser.With_table_hintsContext,0)


        def ddl_object(self):
            return self.getTypedRuleContext(tsqlParser.Ddl_objectContext,0)


        def rowset_function_limited(self):
            return self.getTypedRuleContext(tsqlParser.Rowset_function_limitedContext,0)


        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_delete_statement_from




    def delete_statement_from(self):

        localctx = tsqlParser.Delete_statement_fromContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_delete_statement_from)
        try:
            self.state = 676
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 669
                self.r_id()
                self.state = 671
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
                if la_ == 1:
                    self.state = 670
                    self.with_table_hints()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 673
                self.ddl_object()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 674
                self.rowset_function_limited()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 675
                localctx.table_var = self.match(tsqlParser.LOCAL_ID)
                pass


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


    class Insert_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def insert_statement_value(self):
            return self.getTypedRuleContext(tsqlParser.Insert_statement_valueContext,0)


        def ddl_object(self):
            return self.getTypedRuleContext(tsqlParser.Ddl_objectContext,0)


        def rowset_function_limited(self):
            return self.getTypedRuleContext(tsqlParser.Rowset_function_limitedContext,0)


        def with_expression(self):
            return self.getTypedRuleContext(tsqlParser.With_expressionContext,0)


        def top_clause_dm(self):
            return self.getTypedRuleContext(tsqlParser.Top_clause_dmContext,0)


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

        def insert_with_table_hints(self):
            return self.getTypedRuleContext(tsqlParser.Insert_with_table_hintsContext,0)


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

        def derived_table(self):
            return self.getTypedRuleContext(tsqlParser.Derived_tableContext,0)


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

        def column_name_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_name_listContext,0)


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

        def output_clause(self):
            return self.getTypedRuleContext(tsqlParser.Output_clauseContext,0)


        def for_clause(self):
            return self.getTypedRuleContext(tsqlParser.For_clauseContext,0)


        def option_clause(self):
            return self.getTypedRuleContext(tsqlParser.Option_clauseContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_insert_statement




    def insert_statement(self):

        localctx = tsqlParser.Insert_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_insert_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 678
                self.with_expression()


            self.state = 681
            self.match(tsqlParser.INSERT)
            self.state = 683
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.TOP:
                self.state = 682
                self.top_clause_dm()


            self.state = 686
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.INTO:
                self.state = 685
                self.match(tsqlParser.INTO)


            self.state = 690
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.LOCAL_ID, tsqlParser.ID]:
                self.state = 688
                self.ddl_object()
                pass
            elif token in [tsqlParser.OPENDATASOURCE, tsqlParser.OPENQUERY]:
                self.state = 689
                self.rowset_function_limited()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 693
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.state = 692
                self.insert_with_table_hints()


            self.state = 697
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FROM:
                self.state = 695
                self.match(tsqlParser.FROM)
                self.state = 696
                self.derived_table()


            self.state = 703
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                self.state = 699
                self.match(tsqlParser.LR_BRACKET)
                self.state = 700
                self.column_name_list()
                self.state = 701
                self.match(tsqlParser.RR_BRACKET)


            self.state = 706
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.OUTPUT:
                self.state = 705
                self.output_clause()


            self.state = 708
            self.insert_statement_value()
            self.state = 710
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FOR:
                self.state = 709
                self.for_clause()


            self.state = 713
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.OPTION:
                self.state = 712
                self.option_clause()


            self.state = 716
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
            if la_ == 1:
                self.state = 715
                self.match(tsqlParser.SEMI)


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


    class Insert_statement_valueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def table_value_constructor(self):
            return self.getTypedRuleContext(tsqlParser.Table_value_constructorContext,0)


        def derived_table(self):
            return self.getTypedRuleContext(tsqlParser.Derived_tableContext,0)


        def execute_statement(self):
            return self.getTypedRuleContext(tsqlParser.Execute_statementContext,0)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_insert_statement_value




    def insert_statement_value(self):

        localctx = tsqlParser.Insert_statement_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_insert_statement_value)
        try:
            self.state = 723
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.VALUES]:
                self.enterOuterAlt(localctx, 1)
                self.state = 718
                self.table_value_constructor()
                pass
            elif token in [tsqlParser.SELECT, tsqlParser.WITH, tsqlParser.LR_BRACKET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 719
                self.derived_table()
                pass
            elif token in [tsqlParser.EXECUTE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 720
                self.execute_statement()
                pass
            elif token in [tsqlParser.DEFAULT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 721
                self.match(tsqlParser.DEFAULT)
                self.state = 722
                self.match(tsqlParser.VALUES)
                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 Select_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def query_expression(self):
            return self.getTypedRuleContext(tsqlParser.Query_expressionContext,0)


        def with_expression(self):
            return self.getTypedRuleContext(tsqlParser.With_expressionContext,0)


        def order_by_clause(self):
            return self.getTypedRuleContext(tsqlParser.Order_by_clauseContext,0)


        def for_clause(self):
            return self.getTypedRuleContext(tsqlParser.For_clauseContext,0)


        def option_clause(self):
            return self.getTypedRuleContext(tsqlParser.Option_clauseContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_select_statement




    def select_statement(self):

        localctx = tsqlParser.Select_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_select_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 726
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 725
                self.with_expression()


            self.state = 728
            self.query_expression(0)
            self.state = 730
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
            if la_ == 1:
                self.state = 729
                self.order_by_clause()


            self.state = 733
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
            if la_ == 1:
                self.state = 732
                self.for_clause()


            self.state = 736
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
            if la_ == 1:
                self.state = 735
                self.option_clause()


            self.state = 739
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.state = 738
                self.match(tsqlParser.SEMI)


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


    class Update_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def update_elem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Update_elemContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Update_elemContext,i)


        def ddl_object(self):
            return self.getTypedRuleContext(tsqlParser.Ddl_objectContext,0)


        def rowset_function_limited(self):
            return self.getTypedRuleContext(tsqlParser.Rowset_function_limitedContext,0)


        def with_expression(self):
            return self.getTypedRuleContext(tsqlParser.With_expressionContext,0)


        def top_clause_dm(self):
            return self.getTypedRuleContext(tsqlParser.Top_clause_dmContext,0)


        def with_table_hints(self):
            return self.getTypedRuleContext(tsqlParser.With_table_hintsContext,0)


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

        def output_clause(self):
            return self.getTypedRuleContext(tsqlParser.Output_clauseContext,0)


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

        def table_sources(self):
            return self.getTypedRuleContext(tsqlParser.Table_sourcesContext,0)


        def where_clause_dml(self):
            return self.getTypedRuleContext(tsqlParser.Where_clause_dmlContext,0)


        def for_clause(self):
            return self.getTypedRuleContext(tsqlParser.For_clauseContext,0)


        def option_clause(self):
            return self.getTypedRuleContext(tsqlParser.Option_clauseContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_update_statement




    def update_statement(self):

        localctx = tsqlParser.Update_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_update_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 742
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 741
                self.with_expression()


            self.state = 744
            self.match(tsqlParser.UPDATE)
            self.state = 746
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.TOP:
                self.state = 745
                self.top_clause_dm()


            self.state = 750
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.LOCAL_ID, tsqlParser.ID]:
                self.state = 748
                self.ddl_object()
                pass
            elif token in [tsqlParser.OPENDATASOURCE, tsqlParser.OPENQUERY]:
                self.state = 749
                self.rowset_function_limited()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 753
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH or _la==tsqlParser.LR_BRACKET:
                self.state = 752
                self.with_table_hints()


            self.state = 755
            self.match(tsqlParser.SET)
            self.state = 756
            self.update_elem()
            self.state = 761
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 757
                self.match(tsqlParser.COMMA)
                self.state = 758
                self.update_elem()
                self.state = 763
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 765
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 764
                self.output_clause()


            self.state = 769
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FROM:
                self.state = 767
                self.match(tsqlParser.FROM)
                self.state = 768
                self.table_sources()


            self.state = 772
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WHERE:
                self.state = 771
                self.where_clause_dml()


            self.state = 775
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FOR:
                self.state = 774
                self.for_clause()


            self.state = 778
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.OPTION:
                self.state = 777
                self.option_clause()


            self.state = 781
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
            if la_ == 1:
                self.state = 780
                self.match(tsqlParser.SEMI)


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


    class Where_clause_dmlContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def search_condition_list(self):
            return self.getTypedRuleContext(tsqlParser.Search_condition_listContext,0)


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

        def OF(self):
            return self.getToken(tsqlParser.OF, 0)

        def cursor_name(self):
            return self.getTypedRuleContext(tsqlParser.Cursor_nameContext,0)


        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_where_clause_dml




    def where_clause_dml(self):

        localctx = tsqlParser.Where_clause_dmlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_where_clause_dml)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 783
            self.match(tsqlParser.WHERE)
            self.state = 794
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.CASE, tsqlParser.COALESCE, tsqlParser.CONVERT, tsqlParser.CURRENT_TIMESTAMP, tsqlParser.CURRENT_USER, tsqlParser.DEFAULT, tsqlParser.EXISTS, tsqlParser.EXP, tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.IDENTITY, tsqlParser.IIF, tsqlParser.LEFT, tsqlParser.LOG, tsqlParser.LOG10, tsqlParser.NEXT, tsqlParser.NOT, tsqlParser.NULL_, tsqlParser.NULLIF, tsqlParser.NUMERIC, tsqlParser.OVER, tsqlParser.RIGHT, tsqlParser.SESSION_USER, tsqlParser.SIGN, tsqlParser.SYSTEM_USER, tsqlParser.TRY_CAST, tsqlParser.TRY_CONVERT, tsqlParser.TRY_PARSE, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.BINARY_CHECKSUM, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CEILING, tsqlParser.CHECKSUM, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COS, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DATEADD, tsqlParser.DATEDIFF, tsqlParser.DATENAME, tsqlParser.DATEPART, tsqlParser.DATETIMEOFFSETFROMPARTS, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FLOOR, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MIN_ACTIVE_ROWVERSION, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARSE, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PERCENTILE_CONT, tsqlParser.POWER, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROUND, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIN, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.STRING_AGG, tsqlParser.STRING_SPLIT, tsqlParser.SUM, tsqlParser.SQRT, tsqlParser.SQUARE, tsqlParser.TAN, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.LOCAL_ID, tsqlParser.DECIMAL, tsqlParser.ID, tsqlParser.STRING, tsqlParser.BINARY, tsqlParser.FLOAT, tsqlParser.REAL, tsqlParser.DOLLAR, tsqlParser.LR_BRACKET, tsqlParser.PLUS, tsqlParser.MINUS, tsqlParser.BIT_NOT]:
                self.state = 784
                self.search_condition_list()
                pass
            elif token in [tsqlParser.CURRENT]:
                self.state = 785
                self.match(tsqlParser.CURRENT)
                self.state = 786
                self.match(tsqlParser.OF)
                self.state = 792
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
                if la_ == 1:
                    self.state = 788
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
                    if la_ == 1:
                        self.state = 787
                        self.match(tsqlParser.GLOBAL)


                    self.state = 790
                    self.cursor_name()
                    pass

                elif la_ == 2:
                    self.state = 791
                    localctx.cursor_var = self.match(tsqlParser.LOCAL_ID)
                    pass


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

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

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

        def output_dml_list_elem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Output_dml_list_elemContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Output_dml_list_elemContext,i)


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

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

        def ddl_object(self):
            return self.getTypedRuleContext(tsqlParser.Ddl_objectContext,0)


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

        def column_name_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_name_listContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_output_clause




    def output_clause(self):

        localctx = tsqlParser.Output_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_output_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 796
            self.match(tsqlParser.OUTPUT)
            self.state = 797
            self.output_dml_list_elem()
            self.state = 802
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 798
                self.match(tsqlParser.COMMA)
                self.state = 799
                self.output_dml_list_elem()
                self.state = 804
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 813
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.INTO:
                self.state = 805
                self.match(tsqlParser.INTO)
                self.state = 806
                self.ddl_object()
                self.state = 811
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
                if la_ == 1:
                    self.state = 807
                    self.match(tsqlParser.LR_BRACKET)
                    self.state = 808
                    self.column_name_list()
                    self.state = 809
                    self.match(tsqlParser.RR_BRACKET)




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


    class Output_dml_list_elemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def output_column_name(self):
            return self.getTypedRuleContext(tsqlParser.Output_column_nameContext,0)


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


        def column_alias(self):
            return self.getTypedRuleContext(tsqlParser.Column_aliasContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_output_dml_list_elem




    def output_dml_list_elem(self):

        localctx = tsqlParser.Output_dml_list_elemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_output_dml_list_elem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 817
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 815
                self.output_column_name()
                pass

            elif la_ == 2:
                self.state = 816
                self.expression(0)
                pass


            self.state = 823
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
            if la_ == 1:
                self.state = 820
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.AS:
                    self.state = 819
                    self.match(tsqlParser.AS)


                self.state = 822
                self.column_alias()


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


    class Output_column_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def DELETED(self):
            return self.getToken(tsqlParser.DELETED, 0)

        def INSERTED(self):
            return self.getToken(tsqlParser.INSERTED, 0)

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def DOLLAR_ACTION(self):
            return self.getToken(tsqlParser.DOLLAR_ACTION, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_output_column_name




    def output_column_name(self):

        localctx = tsqlParser.Output_column_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_output_column_name)
        try:
            self.state = 836
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 828
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
                if la_ == 1:
                    self.state = 825
                    self.match(tsqlParser.DELETED)
                    pass

                elif la_ == 2:
                    self.state = 826
                    self.match(tsqlParser.INSERTED)
                    pass

                elif la_ == 3:
                    self.state = 827
                    self.full_table_name()
                    pass


                self.state = 830
                self.match(tsqlParser.DOT)
                self.state = 833
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.STAR]:
                    self.state = 831
                    self.match(tsqlParser.STAR)
                    pass
                elif token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                    self.state = 832
                    self.r_id()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [tsqlParser.DOLLAR_ACTION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 835
                self.match(tsqlParser.DOLLAR_ACTION)
                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 Create_databaseContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def CONTAINMENT(self):
            return self.getToken(tsqlParser.CONTAINMENT, 0)

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

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

        def database_file_spec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Database_file_specContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Database_file_specContext,i)


        def LOG(self):
            return self.getToken(tsqlParser.LOG, 0)

        def COLLATE(self):
            return self.getToken(tsqlParser.COLLATE, 0)

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

        def create_database_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Create_database_optionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Create_database_optionContext,i)


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

        def PARTIAL(self):
            return self.getToken(tsqlParser.PARTIAL, 0)

        def PRIMARY(self):
            return self.getToken(tsqlParser.PRIMARY, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_create_database




    def create_database(self):

        localctx = tsqlParser.Create_databaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_create_database)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 838
            self.match(tsqlParser.CREATE)
            self.state = 839
            self.match(tsqlParser.DATABASE)

            self.state = 840
            localctx.database = self.r_id()
            self.state = 844
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.CONTAINMENT:
                self.state = 841
                self.match(tsqlParser.CONTAINMENT)
                self.state = 842
                self.match(tsqlParser.EQUAL)
                self.state = 843
                _la = self._input.LA(1)
                if not(_la==tsqlParser.NONE or _la==tsqlParser.PARTIAL):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 858
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.ON:
                self.state = 846
                self.match(tsqlParser.ON)
                self.state = 848
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.PRIMARY:
                    self.state = 847
                    self.match(tsqlParser.PRIMARY)


                self.state = 850
                self.database_file_spec()
                self.state = 855
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 851
                    self.match(tsqlParser.COMMA)
                    self.state = 852
                    self.database_file_spec()
                    self.state = 857
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 870
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.LOG:
                self.state = 860
                self.match(tsqlParser.LOG)
                self.state = 861
                self.match(tsqlParser.ON)
                self.state = 862
                self.database_file_spec()
                self.state = 867
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 863
                    self.match(tsqlParser.COMMA)
                    self.state = 864
                    self.database_file_spec()
                    self.state = 869
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 874
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.COLLATE:
                self.state = 872
                self.match(tsqlParser.COLLATE)
                self.state = 873
                localctx.collation_name = self.r_id()


            self.state = 885
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
            if la_ == 1:
                self.state = 876
                self.match(tsqlParser.WITH)
                self.state = 877
                self.create_database_option()
                self.state = 882
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 878
                    self.match(tsqlParser.COMMA)
                    self.state = 879
                    self.create_database_option()
                    self.state = 884
                    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 Create_indexContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


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

        def table_name_with_hint(self):
            return self.getTypedRuleContext(tsqlParser.Table_name_with_hintContext,0)


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

        def column_name_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Column_name_listContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Column_name_listContext,i)


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

        def UNIQUE(self):
            return self.getToken(tsqlParser.UNIQUE, 0)

        def clustered(self):
            return self.getTypedRuleContext(tsqlParser.ClusteredContext,0)


        def INCLUDE(self):
            return self.getToken(tsqlParser.INCLUDE, 0)

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

        def index_options(self):
            return self.getTypedRuleContext(tsqlParser.Index_optionsContext,0)


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

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

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

        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_create_index




    def create_index(self):

        localctx = tsqlParser.Create_indexContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_create_index)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 887
            self.match(tsqlParser.CREATE)
            self.state = 889
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.UNIQUE:
                self.state = 888
                self.match(tsqlParser.UNIQUE)


            self.state = 892
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.CLUSTERED or _la==tsqlParser.NONCLUSTERED:
                self.state = 891
                self.clustered()


            self.state = 894
            self.match(tsqlParser.INDEX)
            self.state = 895
            self.r_id()
            self.state = 896
            self.match(tsqlParser.ON)
            self.state = 897
            self.table_name_with_hint()
            self.state = 898
            self.match(tsqlParser.LR_BRACKET)
            self.state = 899
            self.column_name_list()
            self.state = 901
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.ASC or _la==tsqlParser.DESC:
                self.state = 900
                _la = self._input.LA(1)
                if not(_la==tsqlParser.ASC or _la==tsqlParser.DESC):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 903
            self.match(tsqlParser.RR_BRACKET)
            self.state = 912
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.INCLUDE:
                self.state = 904
                self.match(tsqlParser.INCLUDE)
                self.state = 905
                self.match(tsqlParser.LR_BRACKET)
                self.state = 906
                self.column_name_list()
                self.state = 908
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ASC or _la==tsqlParser.DESC:
                    self.state = 907
                    _la = self._input.LA(1)
                    if not(_la==tsqlParser.ASC or _la==tsqlParser.DESC):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 910
                self.match(tsqlParser.RR_BRACKET)


            self.state = 916
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WHERE:
                self.state = 914
                self.match(tsqlParser.WHERE)
                self.state = 915
                localctx.where = self.search_condition(0)


            self.state = 919
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
            if la_ == 1:
                self.state = 918
                self.index_options()


            self.state = 923
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.ON:
                self.state = 921
                self.match(tsqlParser.ON)
                self.state = 922
                self.r_id()


            self.state = 926
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
            if la_ == 1:
                self.state = 925
                self.match(tsqlParser.SEMI)


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


    class Create_statisticsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def STATISTICS(self):
            return self.getToken(tsqlParser.STATISTICS, 0)

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def table_name_with_hint(self):
            return self.getTypedRuleContext(tsqlParser.Table_name_with_hintContext,0)


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

        def column_name_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_name_listContext,0)


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

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

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

        def FULLSCAN(self):
            return self.getToken(tsqlParser.FULLSCAN, 0)

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

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

        def STATS_STREAM(self):
            return self.getToken(tsqlParser.STATS_STREAM, 0)

        def PERCENT(self):
            return self.getToken(tsqlParser.PERCENT, 0)

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

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

        def NORECOMPUTE(self):
            return self.getToken(tsqlParser.NORECOMPUTE, 0)

        def INCREMENTAL(self):
            return self.getToken(tsqlParser.INCREMENTAL, 0)

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

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_create_statistics




    def create_statistics(self):

        localctx = tsqlParser.Create_statisticsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_create_statistics)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 928
            self.match(tsqlParser.CREATE)
            self.state = 929
            self.match(tsqlParser.STATISTICS)
            self.state = 930
            self.r_id()
            self.state = 931
            self.match(tsqlParser.ON)
            self.state = 932
            self.table_name_with_hint()
            self.state = 933
            self.match(tsqlParser.LR_BRACKET)
            self.state = 934
            self.column_name_list()
            self.state = 935
            self.match(tsqlParser.RR_BRACKET)
            self.state = 954
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.state = 936
                self.match(tsqlParser.WITH)
                self.state = 942
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.FULLSCAN]:
                    self.state = 937
                    self.match(tsqlParser.FULLSCAN)
                    pass
                elif token in [tsqlParser.SAMPLE]:
                    self.state = 938
                    self.match(tsqlParser.SAMPLE)
                    self.state = 939
                    self.match(tsqlParser.DECIMAL)
                    self.state = 940
                    _la = self._input.LA(1)
                    if not(_la==tsqlParser.PERCENT or _la==tsqlParser.ROWS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    pass
                elif token in [tsqlParser.STATS_STREAM]:
                    self.state = 941
                    self.match(tsqlParser.STATS_STREAM)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 946
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
                if la_ == 1:
                    self.state = 944
                    self.match(tsqlParser.COMMA)
                    self.state = 945
                    self.match(tsqlParser.NORECOMPUTE)


                self.state = 952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.COMMA:
                    self.state = 948
                    self.match(tsqlParser.COMMA)
                    self.state = 949
                    self.match(tsqlParser.INCREMENTAL)
                    self.state = 950
                    self.match(tsqlParser.EQUAL)
                    self.state = 951
                    self.on_off()




            self.state = 957
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
            if la_ == 1:
                self.state = 956
                self.match(tsqlParser.SEMI)


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


    class Create_tableContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

        def column_def_table_constraints(self):
            return self.getTypedRuleContext(tsqlParser.Column_def_table_constraintsContext,0)


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

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

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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


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

        def TEXTIMAGE_ON(self):
            return self.getToken(tsqlParser.TEXTIMAGE_ON, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_create_table




    def create_table(self):

        localctx = tsqlParser.Create_tableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_create_table)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 959
            self.match(tsqlParser.CREATE)
            self.state = 960
            self.match(tsqlParser.TABLE)
            self.state = 961
            self.full_table_name()
            self.state = 962
            self.match(tsqlParser.LR_BRACKET)
            self.state = 963
            self.column_def_table_constraints()
            self.state = 965
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.COMMA:
                self.state = 964
                self.match(tsqlParser.COMMA)


            self.state = 967
            self.match(tsqlParser.RR_BRACKET)
            self.state = 971
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
            if la_ == 1:
                self.state = 968
                self.match(tsqlParser.ON)
                self.state = 969
                self.r_id()

            elif la_ == 2:
                self.state = 970
                self.match(tsqlParser.DEFAULT)


            self.state = 976
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
            if la_ == 1:
                self.state = 973
                self.match(tsqlParser.TEXTIMAGE_ON)
                self.state = 974
                self.r_id()

            elif la_ == 2:
                self.state = 975
                self.match(tsqlParser.DEFAULT)


            self.state = 979
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
            if la_ == 1:
                self.state = 978
                self.match(tsqlParser.SEMI)


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


    class Create_schemaContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def simple_name(self):
            return self.getTypedRuleContext(tsqlParser.Simple_nameContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_create_schema




    def create_schema(self):

        localctx = tsqlParser.Create_schemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_create_schema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 981
            self.match(tsqlParser.CREATE)
            self.state = 982
            self.match(tsqlParser.SCHEMA)
            self.state = 983
            self.simple_name()
            self.state = 985
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,120,self._ctx)
            if la_ == 1:
                self.state = 984
                self.match(tsqlParser.SEMI)


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


    class Create_synonymContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def SYNONYM(self):
            return self.getToken(tsqlParser.SYNONYM, 0)

        def simple_name(self):
            return self.getTypedRuleContext(tsqlParser.Simple_nameContext,0)


        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_create_synonym




    def create_synonym(self):

        localctx = tsqlParser.Create_synonymContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_create_synonym)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 987
            self.match(tsqlParser.CREATE)
            self.state = 988
            self.match(tsqlParser.SYNONYM)
            self.state = 989
            self.simple_name()
            self.state = 990
            self.match(tsqlParser.FOR)
            self.state = 991
            self.full_table_name()
            self.state = 993
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.state = 992
                self.match(tsqlParser.SEMI)


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


    class Create_viewContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def VIEW(self):
            return self.getToken(tsqlParser.VIEW, 0)

        def simple_name(self):
            return self.getTypedRuleContext(tsqlParser.Simple_nameContext,0)


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

        def select_statement(self):
            return self.getTypedRuleContext(tsqlParser.Select_statementContext,0)


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

        def column_name_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_name_listContext,0)


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

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

        def view_attribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.View_attributeContext)
            else:
                return self.getTypedRuleContext(tsqlParser.View_attributeContext,i)


        def CHECK(self):
            return self.getToken(tsqlParser.CHECK, 0)

        def OPTION(self):
            return self.getToken(tsqlParser.OPTION, 0)

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_create_view




    def create_view(self):

        localctx = tsqlParser.Create_viewContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_create_view)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 995
            self.match(tsqlParser.CREATE)
            self.state = 996
            self.match(tsqlParser.VIEW)
            self.state = 997
            self.simple_name()
            self.state = 1002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.LR_BRACKET:
                self.state = 998
                self.match(tsqlParser.LR_BRACKET)
                self.state = 999
                self.column_name_list()
                self.state = 1000
                self.match(tsqlParser.RR_BRACKET)


            self.state = 1013
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 1004
                self.match(tsqlParser.WITH)
                self.state = 1005
                self.view_attribute()
                self.state = 1010
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 1006
                    self.match(tsqlParser.COMMA)
                    self.state = 1007
                    self.view_attribute()
                    self.state = 1012
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1015
            self.match(tsqlParser.AS)
            self.state = 1016
            self.select_statement()
            self.state = 1020
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
            if la_ == 1:
                self.state = 1017
                self.match(tsqlParser.WITH)
                self.state = 1018
                self.match(tsqlParser.CHECK)
                self.state = 1019
                self.match(tsqlParser.OPTION)


            self.state = 1023
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
            if la_ == 1:
                self.state = 1022
                self.match(tsqlParser.SEMI)


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


    class View_attributeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ENCRYPTION(self):
            return self.getToken(tsqlParser.ENCRYPTION, 0)

        def SCHEMABINDING(self):
            return self.getToken(tsqlParser.SCHEMABINDING, 0)

        def VIEW_METADATA(self):
            return self.getToken(tsqlParser.VIEW_METADATA, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_view_attribute




    def view_attribute(self):

        localctx = tsqlParser.View_attributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_view_attribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1025
            _la = self._input.LA(1)
            if not(_la==tsqlParser.ENCRYPTION or _la==tsqlParser.SCHEMABINDING or _la==tsqlParser.VIEW_METADATA):
                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 Alter_tableContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.constraint = None # R_idContext
            self.fk = None # Column_name_listContext
            self.pk = None # Column_name_listContext

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

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

        def full_table_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Full_table_nameContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,i)


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

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

        def LOCK_ESCALATION(self):
            return self.getToken(tsqlParser.LOCK_ESCALATION, 0)

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

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

        def ADD(self):
            return self.getToken(tsqlParser.ADD, 0)

        def column_def_table_constraint(self):
            return self.getTypedRuleContext(tsqlParser.Column_def_table_constraintContext,0)


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

        def CONSTRAINT(self):
            return self.getToken(tsqlParser.CONSTRAINT, 0)

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

        def CHECK(self):
            return self.getToken(tsqlParser.CHECK, 0)

        def FOREIGN(self):
            return self.getToken(tsqlParser.FOREIGN, 0)

        def KEY(self):
            return self.getToken(tsqlParser.KEY, 0)

        def REFERENCES(self):
            return self.getToken(tsqlParser.REFERENCES, 0)

        def COLUMN(self):
            return self.getToken(tsqlParser.COLUMN, 0)

        def column_def_table_constraints(self):
            return self.getTypedRuleContext(tsqlParser.Column_def_table_constraintsContext,0)


        def AUTO(self):
            return self.getToken(tsqlParser.AUTO, 0)

        def DISABLE(self):
            return self.getToken(tsqlParser.DISABLE, 0)

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def column_name_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Column_name_listContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Column_name_listContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_alter_table




    def alter_table(self):

        localctx = tsqlParser.Alter_tableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_alter_table)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1027
            self.match(tsqlParser.ALTER)
            self.state = 1028
            self.match(tsqlParser.TABLE)
            self.state = 1029
            self.full_table_name()
            self.state = 1063
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.SET]:
                self.state = 1030
                self.match(tsqlParser.SET)
                self.state = 1031
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1032
                self.match(tsqlParser.LOCK_ESCALATION)
                self.state = 1033
                self.match(tsqlParser.EQUAL)
                self.state = 1034
                _la = self._input.LA(1)
                if not(_la==tsqlParser.TABLE or _la==tsqlParser.AUTO or _la==tsqlParser.DISABLE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1035
                self.match(tsqlParser.RR_BRACKET)
                pass
            elif token in [tsqlParser.ADD]:
                self.state = 1036
                self.match(tsqlParser.ADD)
                self.state = 1037
                self.column_def_table_constraint()
                pass
            elif token in [tsqlParser.DROP]:
                self.state = 1038
                self.match(tsqlParser.DROP)
                self.state = 1039
                self.match(tsqlParser.CONSTRAINT)
                self.state = 1040
                localctx.constraint = self.r_id()
                pass
            elif token in [tsqlParser.WITH]:
                self.state = 1041
                self.match(tsqlParser.WITH)
                self.state = 1042
                self.match(tsqlParser.CHECK)
                self.state = 1043
                self.match(tsqlParser.ADD)
                self.state = 1044
                self.match(tsqlParser.CONSTRAINT)
                self.state = 1045
                localctx.constraint = self.r_id()
                self.state = 1046
                self.match(tsqlParser.FOREIGN)
                self.state = 1047
                self.match(tsqlParser.KEY)
                self.state = 1048
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1049
                localctx.fk = self.column_name_list()
                self.state = 1050
                self.match(tsqlParser.RR_BRACKET)
                self.state = 1051
                self.match(tsqlParser.REFERENCES)
                self.state = 1052
                self.full_table_name()
                self.state = 1053
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1054
                localctx.pk = self.column_name_list()
                self.state = 1055
                self.match(tsqlParser.RR_BRACKET)
                pass
            elif token in [tsqlParser.CHECK]:
                self.state = 1057
                self.match(tsqlParser.CHECK)
                self.state = 1058
                self.match(tsqlParser.CONSTRAINT)
                self.state = 1059
                localctx.constraint = self.r_id()
                pass
            elif token in [tsqlParser.ALTER]:
                self.state = 1060
                self.match(tsqlParser.ALTER)
                self.state = 1061
                self.match(tsqlParser.COLUMN)
                self.state = 1062
                self.column_def_table_constraints()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1066
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
            if la_ == 1:
                self.state = 1065
                self.match(tsqlParser.SEMI)


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


    class Alter_databaseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.database = None # R_idContext
            self.new_name = None # R_idContext
            self.collation = None # R_idContext

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

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

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

        def MODIFY(self):
            return self.getToken(tsqlParser.MODIFY, 0)

        def NAME(self):
            return self.getToken(tsqlParser.NAME, 0)

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

        def COLLATE(self):
            return self.getToken(tsqlParser.COLLATE, 0)

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

        def database_optionspec(self):
            return self.getTypedRuleContext(tsqlParser.Database_optionspecContext,0)


        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


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

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

        def termination(self):
            return self.getTypedRuleContext(tsqlParser.TerminationContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_alter_database




    def alter_database(self):

        localctx = tsqlParser.Alter_databaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_alter_database)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1068
            self.match(tsqlParser.ALTER)
            self.state = 1069
            self.match(tsqlParser.DATABASE)
            self.state = 1072
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.state = 1070
                localctx.database = self.r_id()
                pass
            elif token in [tsqlParser.CURRENT]:
                self.state = 1071
                self.match(tsqlParser.CURRENT)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1086
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.MODIFY]:
                self.state = 1074
                self.match(tsqlParser.MODIFY)
                self.state = 1075
                self.match(tsqlParser.NAME)
                self.state = 1076
                self.match(tsqlParser.EQUAL)
                self.state = 1077
                localctx.new_name = self.r_id()
                pass
            elif token in [tsqlParser.COLLATE]:
                self.state = 1078
                self.match(tsqlParser.COLLATE)
                self.state = 1079
                localctx.collation = self.r_id()
                pass
            elif token in [tsqlParser.SET]:
                self.state = 1080
                self.match(tsqlParser.SET)
                self.state = 1081
                self.database_optionspec()
                self.state = 1084
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
                if la_ == 1:
                    self.state = 1082
                    self.match(tsqlParser.WITH)
                    self.state = 1083
                    self.termination()


                pass
            else:
                raise NoViableAltException(self)

            self.state = 1089
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,132,self._ctx)
            if la_ == 1:
                self.state = 1088
                self.match(tsqlParser.SEMI)


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


    class Database_optionspecContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def auto_option(self):
            return self.getTypedRuleContext(tsqlParser.Auto_optionContext,0)


        def change_tracking_option(self):
            return self.getTypedRuleContext(tsqlParser.Change_tracking_optionContext,0)


        def containment_option(self):
            return self.getTypedRuleContext(tsqlParser.Containment_optionContext,0)


        def cursor_option(self):
            return self.getTypedRuleContext(tsqlParser.Cursor_optionContext,0)


        def date_correlation_optimization_option(self):
            return self.getTypedRuleContext(tsqlParser.Date_correlation_optimization_optionContext,0)


        def db_encryption_option(self):
            return self.getTypedRuleContext(tsqlParser.Db_encryption_optionContext,0)


        def db_state_option(self):
            return self.getTypedRuleContext(tsqlParser.Db_state_optionContext,0)


        def db_update_option(self):
            return self.getTypedRuleContext(tsqlParser.Db_update_optionContext,0)


        def db_user_access_option(self):
            return self.getTypedRuleContext(tsqlParser.Db_user_access_optionContext,0)


        def delayed_durability_option(self):
            return self.getTypedRuleContext(tsqlParser.Delayed_durability_optionContext,0)


        def external_access_option(self):
            return self.getTypedRuleContext(tsqlParser.External_access_optionContext,0)


        def FILESTREAM(self):
            return self.getToken(tsqlParser.FILESTREAM, 0)

        def database_filestream_option(self):
            return self.getTypedRuleContext(tsqlParser.Database_filestream_optionContext,0)


        def hadr_options(self):
            return self.getTypedRuleContext(tsqlParser.Hadr_optionsContext,0)


        def mixed_page_allocation_option(self):
            return self.getTypedRuleContext(tsqlParser.Mixed_page_allocation_optionContext,0)


        def parameterization_option(self):
            return self.getTypedRuleContext(tsqlParser.Parameterization_optionContext,0)


        def recovery_option(self):
            return self.getTypedRuleContext(tsqlParser.Recovery_optionContext,0)


        def service_broker_option(self):
            return self.getTypedRuleContext(tsqlParser.Service_broker_optionContext,0)


        def snapshot_option(self):
            return self.getTypedRuleContext(tsqlParser.Snapshot_optionContext,0)


        def sql_option(self):
            return self.getTypedRuleContext(tsqlParser.Sql_optionContext,0)


        def target_recovery_time_option(self):
            return self.getTypedRuleContext(tsqlParser.Target_recovery_time_optionContext,0)


        def termination(self):
            return self.getTypedRuleContext(tsqlParser.TerminationContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_database_optionspec




    def database_optionspec(self):

        localctx = tsqlParser.Database_optionspecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_database_optionspec)
        try:
            self.state = 1113
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1091
                self.auto_option()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1092
                self.change_tracking_option()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1093
                self.containment_option()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1094
                self.cursor_option()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1095
                self.date_correlation_optimization_option()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1096
                self.db_encryption_option()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1097
                self.db_state_option()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1098
                self.db_update_option()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1099
                self.db_user_access_option()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1100
                self.delayed_durability_option()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1101
                self.external_access_option()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1102
                self.match(tsqlParser.FILESTREAM)
                self.state = 1103
                self.database_filestream_option()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1104
                self.hadr_options()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1105
                self.mixed_page_allocation_option()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1106
                self.parameterization_option()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1107
                self.recovery_option()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1108
                self.service_broker_option()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1109
                self.snapshot_option()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1110
                self.sql_option()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 1111
                self.target_recovery_time_option()
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 1112
                self.termination()
                pass


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


    class Auto_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AUTO_CLOSE(self):
            return self.getToken(tsqlParser.AUTO_CLOSE, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def AUTO_CREATE_STATISTICS(self):
            return self.getToken(tsqlParser.AUTO_CREATE_STATISTICS, 0)

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

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

        def INCREMENTAL(self):
            return self.getToken(tsqlParser.INCREMENTAL, 0)

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

        def AUTO_SHRINK(self):
            return self.getToken(tsqlParser.AUTO_SHRINK, 0)

        def AUTO_UPDATE_STATISTICS(self):
            return self.getToken(tsqlParser.AUTO_UPDATE_STATISTICS, 0)

        def AUTO_UPDATE_STATISTICS_ASYNC(self):
            return self.getToken(tsqlParser.AUTO_UPDATE_STATISTICS_ASYNC, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_auto_option




    def auto_option(self):

        localctx = tsqlParser.Auto_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_auto_option)
        self._la = 0 # Token type
        try:
            self.state = 1132
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.AUTO_CLOSE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1115
                self.match(tsqlParser.AUTO_CLOSE)
                self.state = 1116
                self.on_off()
                pass
            elif token in [tsqlParser.AUTO_CREATE_STATISTICS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1117
                self.match(tsqlParser.AUTO_CREATE_STATISTICS)
                self.state = 1118
                self.match(tsqlParser.OFF)
                pass
            elif token in [tsqlParser.ON]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1119
                self.match(tsqlParser.ON)
                self.state = 1124
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.INCREMENTAL]:
                    self.state = 1120
                    self.match(tsqlParser.INCREMENTAL)
                    self.state = 1121
                    self.match(tsqlParser.EQUAL)
                    self.state = 1122
                    self.match(tsqlParser.ON)
                    pass
                elif token in [tsqlParser.OFF]:
                    self.state = 1123
                    self.match(tsqlParser.OFF)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [tsqlParser.AUTO_SHRINK]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1126
                self.match(tsqlParser.AUTO_SHRINK)
                self.state = 1127
                self.on_off()
                pass
            elif token in [tsqlParser.AUTO_UPDATE_STATISTICS]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1128
                self.match(tsqlParser.AUTO_UPDATE_STATISTICS)
                self.state = 1129
                self.on_off()
                pass
            elif token in [tsqlParser.AUTO_UPDATE_STATISTICS_ASYNC]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1130
                self.match(tsqlParser.AUTO_UPDATE_STATISTICS_ASYNC)
                self.state = 1131
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                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 Change_tracking_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHANGE_TRACKING(self):
            return self.getToken(tsqlParser.CHANGE_TRACKING, 0)

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

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

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

        def change_tracking_option_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Change_tracking_option_listContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Change_tracking_option_listContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_change_tracking_option




    def change_tracking_option(self):

        localctx = tsqlParser.Change_tracking_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_change_tracking_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1134
            self.match(tsqlParser.CHANGE_TRACKING)
            self.state = 1135
            self.match(tsqlParser.EQUAL)
            self.state = 1151
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.OFF]:
                self.state = 1136
                self.match(tsqlParser.OFF)
                pass
            elif token in [tsqlParser.ON]:
                self.state = 1137
                self.match(tsqlParser.ON)
                self.state = 1148
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.AUTO_CLEANUP or _la==tsqlParser.CHANGE_RETENTION:
                    self.state = 1138
                    self.change_tracking_option_list()
                    self.state = 1143
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==tsqlParser.COMMA:
                        self.state = 1139
                        self.match(tsqlParser.COMMA)
                        self.state = 1140
                        self.change_tracking_option_list()
                        self.state = 1145
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1150
                    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 Change_tracking_option_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AUTO_CLEANUP(self):
            return self.getToken(tsqlParser.AUTO_CLEANUP, 0)

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

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def CHANGE_RETENTION(self):
            return self.getToken(tsqlParser.CHANGE_RETENTION, 0)

        def DAYS(self):
            return self.getToken(tsqlParser.DAYS, 0)

        def HOURS(self):
            return self.getToken(tsqlParser.HOURS, 0)

        def MINUTES(self):
            return self.getToken(tsqlParser.MINUTES, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_change_tracking_option_list




    def change_tracking_option_list(self):

        localctx = tsqlParser.Change_tracking_option_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_change_tracking_option_list)
        self._la = 0 # Token type
        try:
            self.state = 1159
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.AUTO_CLEANUP]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1153
                self.match(tsqlParser.AUTO_CLEANUP)
                self.state = 1154
                self.match(tsqlParser.EQUAL)
                self.state = 1155
                self.on_off()
                pass
            elif token in [tsqlParser.CHANGE_RETENTION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1156
                self.match(tsqlParser.CHANGE_RETENTION)
                self.state = 1157
                self.match(tsqlParser.EQUAL)
                self.state = 1158
                _la = self._input.LA(1)
                if not(_la==tsqlParser.DAYS or _la==tsqlParser.HOURS or _la==tsqlParser.MINUTES):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                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 Containment_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CONTAINMENT(self):
            return self.getToken(tsqlParser.CONTAINMENT, 0)

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

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

        def PARTIAL(self):
            return self.getToken(tsqlParser.PARTIAL, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_containment_option




    def containment_option(self):

        localctx = tsqlParser.Containment_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_containment_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1161
            self.match(tsqlParser.CONTAINMENT)
            self.state = 1162
            self.match(tsqlParser.EQUAL)
            self.state = 1163
            _la = self._input.LA(1)
            if not(_la==tsqlParser.NONE or _la==tsqlParser.PARTIAL):
                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 Cursor_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CURSOR_CLOSE_ON_COMMIT(self):
            return self.getToken(tsqlParser.CURSOR_CLOSE_ON_COMMIT, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def CURSOR_DEFAULT(self):
            return self.getToken(tsqlParser.CURSOR_DEFAULT, 0)

        def LOCAL(self):
            return self.getToken(tsqlParser.LOCAL, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_cursor_option




    def cursor_option(self):

        localctx = tsqlParser.Cursor_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_cursor_option)
        self._la = 0 # Token type
        try:
            self.state = 1169
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.CURSOR_CLOSE_ON_COMMIT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1165
                self.match(tsqlParser.CURSOR_CLOSE_ON_COMMIT)
                self.state = 1166
                self.on_off()
                pass
            elif token in [tsqlParser.CURSOR_DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1167
                self.match(tsqlParser.CURSOR_DEFAULT)
                self.state = 1168
                _la = self._input.LA(1)
                if not(_la==tsqlParser.GLOBAL or _la==tsqlParser.LOCAL):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                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 Date_correlation_optimization_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DATE_CORRELATION_OPTIMIZATION(self):
            return self.getToken(tsqlParser.DATE_CORRELATION_OPTIMIZATION, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_date_correlation_optimization_option




    def date_correlation_optimization_option(self):

        localctx = tsqlParser.Date_correlation_optimization_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_date_correlation_optimization_option)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1171
            self.match(tsqlParser.DATE_CORRELATION_OPTIMIZATION)
            self.state = 1172
            self.on_off()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Db_encryption_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ENCRYPTION(self):
            return self.getToken(tsqlParser.ENCRYPTION, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_db_encryption_option




    def db_encryption_option(self):

        localctx = tsqlParser.Db_encryption_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_db_encryption_option)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1174
            self.match(tsqlParser.ENCRYPTION)
            self.state = 1175
            self.on_off()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Db_state_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ONLINE(self):
            return self.getToken(tsqlParser.ONLINE, 0)

        def OFFLINE(self):
            return self.getToken(tsqlParser.OFFLINE, 0)

        def EMERGENCY(self):
            return self.getToken(tsqlParser.EMERGENCY, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_db_state_option




    def db_state_option(self):

        localctx = tsqlParser.Db_state_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_db_state_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1177
            _la = self._input.LA(1)
            if not(_la==tsqlParser.EMERGENCY or _la==tsqlParser.OFFLINE or _la==tsqlParser.ONLINE):
                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 Db_update_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def READ_ONLY(self):
            return self.getToken(tsqlParser.READ_ONLY, 0)

        def READ_WRITE(self):
            return self.getToken(tsqlParser.READ_WRITE, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_db_update_option




    def db_update_option(self):

        localctx = tsqlParser.Db_update_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_db_update_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1179
            _la = self._input.LA(1)
            if not(_la==tsqlParser.READ_ONLY or _la==tsqlParser.READ_WRITE):
                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 Db_user_access_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SINGLE_USER(self):
            return self.getToken(tsqlParser.SINGLE_USER, 0)

        def RESTRICTED_USER(self):
            return self.getToken(tsqlParser.RESTRICTED_USER, 0)

        def MULTI_USER(self):
            return self.getToken(tsqlParser.MULTI_USER, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_db_user_access_option




    def db_user_access_option(self):

        localctx = tsqlParser.Db_user_access_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_db_user_access_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1181
            _la = self._input.LA(1)
            if not(_la==tsqlParser.MULTI_USER or _la==tsqlParser.RESTRICTED_USER or _la==tsqlParser.SINGLE_USER):
                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 Delayed_durability_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DELAYED_DURABILITY(self):
            return self.getToken(tsqlParser.DELAYED_DURABILITY, 0)

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

        def DISABLED(self):
            return self.getToken(tsqlParser.DISABLED, 0)

        def ALLOWED(self):
            return self.getToken(tsqlParser.ALLOWED, 0)

        def FORCED(self):
            return self.getToken(tsqlParser.FORCED, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_delayed_durability_option




    def delayed_durability_option(self):

        localctx = tsqlParser.Delayed_durability_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_delayed_durability_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1183
            self.match(tsqlParser.DELAYED_DURABILITY)
            self.state = 1184
            self.match(tsqlParser.EQUAL)
            self.state = 1185
            _la = self._input.LA(1)
            if not(_la==tsqlParser.ALLOWED or _la==tsqlParser.DISABLED or _la==tsqlParser.FORCED):
                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 External_access_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DB_CHAINING(self):
            return self.getToken(tsqlParser.DB_CHAINING, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def TRUSTWORTHY(self):
            return self.getToken(tsqlParser.TRUSTWORTHY, 0)

        def DEFAULT_LANGUAGE(self):
            return self.getToken(tsqlParser.DEFAULT_LANGUAGE, 0)

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def DEFAULT_FULLTEXT_LANGUAGE(self):
            return self.getToken(tsqlParser.DEFAULT_FULLTEXT_LANGUAGE, 0)

        def NESTED_TRIGGERS(self):
            return self.getToken(tsqlParser.NESTED_TRIGGERS, 0)

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

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

        def TRANSFORM_NOISE_WORDS(self):
            return self.getToken(tsqlParser.TRANSFORM_NOISE_WORDS, 0)

        def TWO_DIGIT_YEAR_CUTOFF(self):
            return self.getToken(tsqlParser.TWO_DIGIT_YEAR_CUTOFF, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_external_access_option




    def external_access_option(self):

        localctx = tsqlParser.External_access_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_external_access_option)
        self._la = 0 # Token type
        try:
            self.state = 1212
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.DB_CHAINING]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1187
                self.match(tsqlParser.DB_CHAINING)
                self.state = 1188
                self.on_off()
                pass
            elif token in [tsqlParser.TRUSTWORTHY]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1189
                self.match(tsqlParser.TRUSTWORTHY)
                self.state = 1190
                self.on_off()
                pass
            elif token in [tsqlParser.DEFAULT_LANGUAGE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1191
                self.match(tsqlParser.DEFAULT_LANGUAGE)
                self.state = 1192
                self.match(tsqlParser.EQUAL)
                self.state = 1195
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                    self.state = 1193
                    self.r_id()
                    pass
                elif token in [tsqlParser.STRING]:
                    self.state = 1194
                    self.match(tsqlParser.STRING)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [tsqlParser.DEFAULT_FULLTEXT_LANGUAGE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1197
                self.match(tsqlParser.DEFAULT_FULLTEXT_LANGUAGE)
                self.state = 1198
                self.match(tsqlParser.EQUAL)
                self.state = 1201
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                    self.state = 1199
                    self.r_id()
                    pass
                elif token in [tsqlParser.STRING]:
                    self.state = 1200
                    self.match(tsqlParser.STRING)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [tsqlParser.NESTED_TRIGGERS]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1203
                self.match(tsqlParser.NESTED_TRIGGERS)
                self.state = 1204
                self.match(tsqlParser.EQUAL)
                self.state = 1205
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.TRANSFORM_NOISE_WORDS]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1206
                self.match(tsqlParser.TRANSFORM_NOISE_WORDS)
                self.state = 1207
                self.match(tsqlParser.EQUAL)
                self.state = 1208
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.TWO_DIGIT_YEAR_CUTOFF]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1209
                self.match(tsqlParser.TWO_DIGIT_YEAR_CUTOFF)
                self.state = 1210
                self.match(tsqlParser.EQUAL)
                self.state = 1211
                self.match(tsqlParser.DECIMAL)
                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 Hadr_optionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def HADR(self):
            return self.getToken(tsqlParser.HADR, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_hadr_options




    def hadr_options(self):

        localctx = tsqlParser.Hadr_optionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_hadr_options)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1214
            self.match(tsqlParser.ALTER)
            self.state = 1215
            self.match(tsqlParser.DATABASE)
            self.state = 1216
            self.match(tsqlParser.SET)
            self.state = 1217
            self.match(tsqlParser.HADR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Mixed_page_allocation_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MIXED_PAGE_ALLOCATION(self):
            return self.getToken(tsqlParser.MIXED_PAGE_ALLOCATION, 0)

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_mixed_page_allocation_option




    def mixed_page_allocation_option(self):

        localctx = tsqlParser.Mixed_page_allocation_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_mixed_page_allocation_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1219
            self.match(tsqlParser.MIXED_PAGE_ALLOCATION)
            self.state = 1220
            _la = self._input.LA(1)
            if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                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 Parameterization_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PARAMETERIZATION(self):
            return self.getToken(tsqlParser.PARAMETERIZATION, 0)

        def SIMPLE(self):
            return self.getToken(tsqlParser.SIMPLE, 0)

        def FORCED(self):
            return self.getToken(tsqlParser.FORCED, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_parameterization_option




    def parameterization_option(self):

        localctx = tsqlParser.Parameterization_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_parameterization_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1222
            self.match(tsqlParser.PARAMETERIZATION)
            self.state = 1223
            _la = self._input.LA(1)
            if not(_la==tsqlParser.FORCED or _la==tsqlParser.SIMPLE):
                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 Recovery_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RECOVERY(self):
            return self.getToken(tsqlParser.RECOVERY, 0)

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

        def BULK_LOGGED(self):
            return self.getToken(tsqlParser.BULK_LOGGED, 0)

        def SIMPLE(self):
            return self.getToken(tsqlParser.SIMPLE, 0)

        def TORN_PAGE_DETECTION(self):
            return self.getToken(tsqlParser.TORN_PAGE_DETECTION, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def PAGE_VERIFY(self):
            return self.getToken(tsqlParser.PAGE_VERIFY, 0)

        def CHECKSUM(self):
            return self.getToken(tsqlParser.CHECKSUM, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_recovery_option




    def recovery_option(self):

        localctx = tsqlParser.Recovery_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_recovery_option)
        self._la = 0 # Token type
        try:
            self.state = 1231
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.RECOVERY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1225
                self.match(tsqlParser.RECOVERY)
                self.state = 1226
                _la = self._input.LA(1)
                if not(_la==tsqlParser.FULL or _la==tsqlParser.BULK_LOGGED or _la==tsqlParser.SIMPLE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.TORN_PAGE_DETECTION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1227
                self.match(tsqlParser.TORN_PAGE_DETECTION)
                self.state = 1228
                self.on_off()
                pass
            elif token in [tsqlParser.PAGE_VERIFY]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1229
                self.match(tsqlParser.PAGE_VERIFY)
                self.state = 1230
                _la = self._input.LA(1)
                if not(_la==tsqlParser.NONE or _la==tsqlParser.CHECKSUM or _la==tsqlParser.TORN_PAGE_DETECTION):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                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 Service_broker_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ENABLE_BROKER(self):
            return self.getToken(tsqlParser.ENABLE_BROKER, 0)

        def DISABLE_BROKER(self):
            return self.getToken(tsqlParser.DISABLE_BROKER, 0)

        def NEW_BROKER(self):
            return self.getToken(tsqlParser.NEW_BROKER, 0)

        def ERROR_BROKER_CONVERSATIONS(self):
            return self.getToken(tsqlParser.ERROR_BROKER_CONVERSATIONS, 0)

        def HONOR_BROKER_PRIORITY(self):
            return self.getToken(tsqlParser.HONOR_BROKER_PRIORITY, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_service_broker_option




    def service_broker_option(self):

        localctx = tsqlParser.Service_broker_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_service_broker_option)
        try:
            self.state = 1239
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.ENABLE_BROKER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1233
                self.match(tsqlParser.ENABLE_BROKER)
                pass
            elif token in [tsqlParser.DISABLE_BROKER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1234
                self.match(tsqlParser.DISABLE_BROKER)
                pass
            elif token in [tsqlParser.NEW_BROKER]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1235
                self.match(tsqlParser.NEW_BROKER)
                pass
            elif token in [tsqlParser.ERROR_BROKER_CONVERSATIONS]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1236
                self.match(tsqlParser.ERROR_BROKER_CONVERSATIONS)
                pass
            elif token in [tsqlParser.HONOR_BROKER_PRIORITY]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1237
                self.match(tsqlParser.HONOR_BROKER_PRIORITY)
                self.state = 1238
                self.on_off()
                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 Snapshot_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALLOW_SNAPSHOT_ISOLATION(self):
            return self.getToken(tsqlParser.ALLOW_SNAPSHOT_ISOLATION, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def READ_COMMITTED_SNAPSHOT(self):
            return self.getToken(tsqlParser.READ_COMMITTED_SNAPSHOT, 0)

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

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_snapshot_option




    def snapshot_option(self):

        localctx = tsqlParser.Snapshot_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_snapshot_option)
        self._la = 0 # Token type
        try:
            self.state = 1246
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.ALLOW_SNAPSHOT_ISOLATION]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1241
                self.match(tsqlParser.ALLOW_SNAPSHOT_ISOLATION)
                self.state = 1242
                self.on_off()
                pass
            elif token in [tsqlParser.READ_COMMITTED_SNAPSHOT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1243
                self.match(tsqlParser.READ_COMMITTED_SNAPSHOT)
                self.state = 1244
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.OFF, tsqlParser.ON]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1245
                localctx.MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    localctx.MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                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 Sql_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ANSI_NULL_DEFAULT(self):
            return self.getToken(tsqlParser.ANSI_NULL_DEFAULT, 0)

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


        def ANSI_NULLS(self):
            return self.getToken(tsqlParser.ANSI_NULLS, 0)

        def ANSI_PADDING(self):
            return self.getToken(tsqlParser.ANSI_PADDING, 0)

        def ANSI_WARNINGS(self):
            return self.getToken(tsqlParser.ANSI_WARNINGS, 0)

        def ARITHABORT(self):
            return self.getToken(tsqlParser.ARITHABORT, 0)

        def COMPATIBILITY_LEVEL(self):
            return self.getToken(tsqlParser.COMPATIBILITY_LEVEL, 0)

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

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

        def CONCAT_NULL_YIELDS_NULL(self):
            return self.getToken(tsqlParser.CONCAT_NULL_YIELDS_NULL, 0)

        def NUMERIC_ROUNDABORT(self):
            return self.getToken(tsqlParser.NUMERIC_ROUNDABORT, 0)

        def QUOTED_IDENTIFIER(self):
            return self.getToken(tsqlParser.QUOTED_IDENTIFIER, 0)

        def RECURSIVE_TRIGGERS(self):
            return self.getToken(tsqlParser.RECURSIVE_TRIGGERS, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_sql_option




    def sql_option(self):

        localctx = tsqlParser.Sql_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_sql_option)
        try:
            self.state = 1269
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.ANSI_NULL_DEFAULT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1248
                self.match(tsqlParser.ANSI_NULL_DEFAULT)
                self.state = 1249
                self.on_off()
                pass
            elif token in [tsqlParser.ANSI_NULLS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1250
                self.match(tsqlParser.ANSI_NULLS)
                self.state = 1251
                self.on_off()
                pass
            elif token in [tsqlParser.ANSI_PADDING]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1252
                self.match(tsqlParser.ANSI_PADDING)
                self.state = 1253
                self.on_off()
                pass
            elif token in [tsqlParser.ANSI_WARNINGS]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1254
                self.match(tsqlParser.ANSI_WARNINGS)
                self.state = 1255
                self.on_off()
                pass
            elif token in [tsqlParser.ARITHABORT]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1256
                self.match(tsqlParser.ARITHABORT)
                self.state = 1257
                self.on_off()
                pass
            elif token in [tsqlParser.COMPATIBILITY_LEVEL]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1258
                self.match(tsqlParser.COMPATIBILITY_LEVEL)
                self.state = 1259
                self.match(tsqlParser.EQUAL)
                self.state = 1260
                self.match(tsqlParser.DECIMAL)
                pass
            elif token in [tsqlParser.CONCAT_NULL_YIELDS_NULL]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1261
                self.match(tsqlParser.CONCAT_NULL_YIELDS_NULL)
                self.state = 1262
                self.on_off()
                pass
            elif token in [tsqlParser.NUMERIC_ROUNDABORT]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1263
                self.match(tsqlParser.NUMERIC_ROUNDABORT)
                self.state = 1264
                self.on_off()
                pass
            elif token in [tsqlParser.QUOTED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1265
                self.match(tsqlParser.QUOTED_IDENTIFIER)
                self.state = 1266
                self.on_off()
                pass
            elif token in [tsqlParser.RECURSIVE_TRIGGERS]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1267
                self.match(tsqlParser.RECURSIVE_TRIGGERS)
                self.state = 1268
                self.on_off()
                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 Target_recovery_time_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TARGET_RECOVERY_TIME(self):
            return self.getToken(tsqlParser.TARGET_RECOVERY_TIME, 0)

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

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

        def SECONDS(self):
            return self.getToken(tsqlParser.SECONDS, 0)

        def MINUTES(self):
            return self.getToken(tsqlParser.MINUTES, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_target_recovery_time_option




    def target_recovery_time_option(self):

        localctx = tsqlParser.Target_recovery_time_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_target_recovery_time_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1271
            self.match(tsqlParser.TARGET_RECOVERY_TIME)
            self.state = 1272
            self.match(tsqlParser.EQUAL)
            self.state = 1273
            self.match(tsqlParser.DECIMAL)
            self.state = 1274
            _la = self._input.LA(1)
            if not(_la==tsqlParser.MINUTES or _la==tsqlParser.SECONDS):
                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 TerminationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def AFTER(self):
            return self.getToken(tsqlParser.AFTER, 0)

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

        def IMMEDIATE(self):
            return self.getToken(tsqlParser.IMMEDIATE, 0)

        def NO_WAIT(self):
            return self.getToken(tsqlParser.NO_WAIT, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_termination




    def termination(self):

        localctx = tsqlParser.TerminationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_termination)
        try:
            self.state = 1282
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1276
                self.match(tsqlParser.ROLLBACK)
                self.state = 1277
                self.match(tsqlParser.AFTER)
                self.state = 1278
                localctx.seconds = self.match(tsqlParser.DECIMAL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1279
                self.match(tsqlParser.ROLLBACK)
                self.state = 1280
                self.match(tsqlParser.IMMEDIATE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1281
                self.match(tsqlParser.NO_WAIT)
                pass


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


    class Drop_indexContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

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

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

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_index




    def drop_index(self):

        localctx = tsqlParser.Drop_indexContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_drop_index)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1284
            self.match(tsqlParser.DROP)
            self.state = 1285
            self.match(tsqlParser.INDEX)
            self.state = 1288
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1286
                self.match(tsqlParser.IF)
                self.state = 1287
                self.match(tsqlParser.EXISTS)


            self.state = 1290
            localctx.name = self.r_id()
            self.state = 1293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.ON:
                self.state = 1291
                self.match(tsqlParser.ON)
                self.state = 1292
                self.full_table_name()


            self.state = 1296
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,151,self._ctx)
            if la_ == 1:
                self.state = 1295
                self.match(tsqlParser.SEMI)


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


    class Drop_procedureContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def PROCEDURE(self):
            return self.getToken(tsqlParser.PROCEDURE, 0)

        def func_proc_name(self):
            return self.getTypedRuleContext(tsqlParser.Func_proc_nameContext,0)


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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_procedure




    def drop_procedure(self):

        localctx = tsqlParser.Drop_procedureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_drop_procedure)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1298
            self.match(tsqlParser.DROP)
            self.state = 1299
            self.match(tsqlParser.PROCEDURE)
            self.state = 1302
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1300
                self.match(tsqlParser.IF)
                self.state = 1301
                self.match(tsqlParser.EXISTS)


            self.state = 1304
            self.func_proc_name()
            self.state = 1306
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
            if la_ == 1:
                self.state = 1305
                self.match(tsqlParser.SEMI)


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


    class Drop_statisticsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def STATISTICS(self):
            return self.getToken(tsqlParser.STATISTICS, 0)

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_statistics




    def drop_statistics(self):

        localctx = tsqlParser.Drop_statisticsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_drop_statistics)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1308
            self.match(tsqlParser.DROP)
            self.state = 1309
            self.match(tsqlParser.STATISTICS)
            self.state = 1313
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,154,self._ctx)
            if la_ == 1:
                self.state = 1310
                self.full_table_name()
                self.state = 1311
                self.match(tsqlParser.DOT)


            self.state = 1315
            localctx.name = self.r_id()
            self.state = 1317
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,155,self._ctx)
            if la_ == 1:
                self.state = 1316
                self.match(tsqlParser.SEMI)


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


    class Drop_tableContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_table




    def drop_table(self):

        localctx = tsqlParser.Drop_tableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_drop_table)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1319
            self.match(tsqlParser.DROP)
            self.state = 1320
            self.match(tsqlParser.TABLE)
            self.state = 1323
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1321
                self.match(tsqlParser.IF)
                self.state = 1322
                self.match(tsqlParser.EXISTS)


            self.state = 1325
            self.full_table_name()
            self.state = 1327
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,157,self._ctx)
            if la_ == 1:
                self.state = 1326
                self.match(tsqlParser.SEMI)


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


    class Drop_databaseContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_database




    def drop_database(self):

        localctx = tsqlParser.Drop_databaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_drop_database)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1329
            self.match(tsqlParser.DROP)
            self.state = 1330
            self.match(tsqlParser.DATABASE)
            self.state = 1333
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1331
                self.match(tsqlParser.IF)
                self.state = 1332
                self.match(tsqlParser.EXISTS)


            self.state = 1337
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.state = 1335
                localctx.database = self.r_id()
                pass
            elif token in [tsqlParser.CURRENT]:
                self.state = 1336
                self.match(tsqlParser.CURRENT)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1340
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
            if la_ == 1:
                self.state = 1339
                self.match(tsqlParser.SEMI)


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


    class Drop_synonymContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def SYNONYM(self):
            return self.getToken(tsqlParser.SYNONYM, 0)

        def simple_name(self):
            return self.getTypedRuleContext(tsqlParser.Simple_nameContext,0)


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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_synonym




    def drop_synonym(self):

        localctx = tsqlParser.Drop_synonymContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_drop_synonym)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1342
            self.match(tsqlParser.DROP)
            self.state = 1343
            self.match(tsqlParser.SYNONYM)
            self.state = 1346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1344
                self.match(tsqlParser.IF)
                self.state = 1345
                self.match(tsqlParser.EXISTS)


            self.state = 1348
            self.simple_name()
            self.state = 1350
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
            if la_ == 1:
                self.state = 1349
                self.match(tsqlParser.SEMI)


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


    class Drop_viewContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def VIEW(self):
            return self.getToken(tsqlParser.VIEW, 0)

        def simple_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Simple_nameContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Simple_nameContext,i)


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

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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_view




    def drop_view(self):

        localctx = tsqlParser.Drop_viewContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_drop_view)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1352
            self.match(tsqlParser.DROP)
            self.state = 1353
            self.match(tsqlParser.VIEW)
            self.state = 1356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1354
                self.match(tsqlParser.IF)
                self.state = 1355
                self.match(tsqlParser.EXISTS)


            self.state = 1358
            self.simple_name()
            self.state = 1363
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 1359
                self.match(tsqlParser.COMMA)
                self.state = 1360
                self.simple_name()
                self.state = 1365
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1367
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
            if la_ == 1:
                self.state = 1366
                self.match(tsqlParser.SEMI)


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


    class Drop_schemaContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def simple_name(self):
            return self.getTypedRuleContext(tsqlParser.Simple_nameContext,0)


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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_schema




    def drop_schema(self):

        localctx = tsqlParser.Drop_schemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_drop_schema)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1369
            self.match(tsqlParser.DROP)
            self.state = 1370
            self.match(tsqlParser.SCHEMA)
            self.state = 1373
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1371
                self.match(tsqlParser.IF)
                self.state = 1372
                self.match(tsqlParser.EXISTS)


            self.state = 1375
            self.simple_name()
            self.state = 1377
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
            if la_ == 1:
                self.state = 1376
                self.match(tsqlParser.SEMI)


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


    class Drop_functionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def FUNCTION(self):
            return self.getToken(tsqlParser.FUNCTION, 0)

        def func_proc_name(self):
            return self.getTypedRuleContext(tsqlParser.Func_proc_nameContext,0)


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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_function




    def drop_function(self):

        localctx = tsqlParser.Drop_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_drop_function)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1379
            self.match(tsqlParser.DROP)
            self.state = 1380
            self.match(tsqlParser.FUNCTION)
            self.state = 1383
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1381
                self.match(tsqlParser.IF)
                self.state = 1382
                self.match(tsqlParser.EXISTS)


            self.state = 1385
            self.func_proc_name()
            self.state = 1387
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
            if la_ == 1:
                self.state = 1386
                self.match(tsqlParser.SEMI)


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


    class Create_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def data_type(self):
            return self.getTypedRuleContext(tsqlParser.Data_typeContext,0)


        def default_value(self):
            return self.getTypedRuleContext(tsqlParser.Default_valueContext,0)


        def simple_name(self):
            return self.getTypedRuleContext(tsqlParser.Simple_nameContext,0)


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

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

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

        def column_def_table_constraints(self):
            return self.getTypedRuleContext(tsqlParser.Column_def_table_constraintsContext,0)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_create_type




    def create_type(self):

        localctx = tsqlParser.Create_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_create_type)
        self._la = 0 # Token type
        try:
            self.state = 1408
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1389
                self.match(tsqlParser.CREATE)
                self.state = 1390
                self.match(tsqlParser.TYPE)
                self.state = 1391
                localctx.name = self.simple_name()
                self.state = 1392
                self.match(tsqlParser.FROM)
                self.state = 1393
                self.data_type()
                self.state = 1394
                self.default_value()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1396
                self.match(tsqlParser.CREATE)
                self.state = 1397
                self.match(tsqlParser.TYPE)
                self.state = 1398
                localctx.name = self.simple_name()
                self.state = 1399
                self.match(tsqlParser.AS)
                self.state = 1400
                self.match(tsqlParser.TABLE)
                self.state = 1401
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1402
                self.column_def_table_constraints()
                self.state = 1404
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.COMMA:
                    self.state = 1403
                    self.match(tsqlParser.COMMA)


                self.state = 1406
                self.match(tsqlParser.RR_BRACKET)
                pass


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


    class Drop_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def simple_name(self):
            return self.getTypedRuleContext(tsqlParser.Simple_nameContext,0)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_drop_type




    def drop_type(self):

        localctx = tsqlParser.Drop_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_drop_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1410
            self.match(tsqlParser.DROP)
            self.state = 1411
            self.match(tsqlParser.TYPE)
            self.state = 1414
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.IF:
                self.state = 1412
                self.match(tsqlParser.IF)
                self.state = 1413
                self.match(tsqlParser.EXISTS)


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


    class Rowset_function_limitedContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def openquery(self):
            return self.getTypedRuleContext(tsqlParser.OpenqueryContext,0)


        def opendatasource(self):
            return self.getTypedRuleContext(tsqlParser.OpendatasourceContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_rowset_function_limited




    def rowset_function_limited(self):

        localctx = tsqlParser.Rowset_function_limitedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_rowset_function_limited)
        try:
            self.state = 1420
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.OPENQUERY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1418
                self.openquery()
                pass
            elif token in [tsqlParser.OPENDATASOURCE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1419
                self.opendatasource()
                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 OpenqueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPENQUERY(self):
            return self.getToken(tsqlParser.OPENQUERY, 0)

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

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

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_openquery




    def openquery(self):

        localctx = tsqlParser.OpenqueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_openquery)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1422
            self.match(tsqlParser.OPENQUERY)
            self.state = 1423
            self.match(tsqlParser.LR_BRACKET)
            self.state = 1424
            localctx.linked_server = self.r_id()
            self.state = 1425
            self.match(tsqlParser.COMMA)
            self.state = 1426
            localctx.query = self.match(tsqlParser.STRING)
            self.state = 1427
            self.match(tsqlParser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OpendatasourceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.provider = None # Token
            self.init = None # Token
            self.database = None # R_idContext
            self.scheme = None # R_idContext
            self.table = None # R_idContext

        def OPENDATASOURCE(self):
            return self.getToken(tsqlParser.OPENDATASOURCE, 0)

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

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

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

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

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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def getRuleIndex(self):
            return tsqlParser.RULE_opendatasource




    def opendatasource(self):

        localctx = tsqlParser.OpendatasourceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_opendatasource)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1429
            self.match(tsqlParser.OPENDATASOURCE)
            self.state = 1430
            self.match(tsqlParser.LR_BRACKET)
            self.state = 1431
            localctx.provider = self.match(tsqlParser.STRING)
            self.state = 1432
            self.match(tsqlParser.COMMA)
            self.state = 1433
            localctx.init = self.match(tsqlParser.STRING)
            self.state = 1434
            self.match(tsqlParser.RR_BRACKET)
            self.state = 1435
            self.match(tsqlParser.DOT)
            self.state = 1437
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (tsqlParser.FILLFACTOR - 71)) | (1 << (tsqlParser.FORCESEEK - 71)) | (1 << (tsqlParser.NEXT - 71)) | (1 << (tsqlParser.NUMERIC - 71)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (tsqlParser.VALUE - 196)) | (1 << (tsqlParser.ABSOLUTE - 196)) | (1 << (tsqlParser.APPLY - 196)) | (1 << (tsqlParser.AUTO - 196)) | (1 << (tsqlParser.AVG - 196)) | (1 << (tsqlParser.BASE64 - 196)) | (1 << (tsqlParser.CALLER - 196)) | (1 << (tsqlParser.CAST - 196)) | (1 << (tsqlParser.CATCH - 196)) | (1 << (tsqlParser.CHECKSUM_AGG - 196)) | (1 << (tsqlParser.COMMITTED - 196)) | (1 << (tsqlParser.CONCAT - 196)) | (1 << (tsqlParser.CONTROL - 196)) | (1 << (tsqlParser.COOKIE - 196)) | (1 << (tsqlParser.COUNT - 196)) | (1 << (tsqlParser.COUNT_BIG - 196)) | (1 << (tsqlParser.DATE - 196)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (tsqlParser.DELAY - 261)) | (1 << (tsqlParser.DELETED - 261)) | (1 << (tsqlParser.DENSE_RANK - 261)) | (1 << (tsqlParser.DISABLE - 261)) | (1 << (tsqlParser.DYNAMIC - 261)) | (1 << (tsqlParser.ENCRYPTION - 261)) | (1 << (tsqlParser.EXIST - 261)) | (1 << (tsqlParser.EXPAND - 261)) | (1 << (tsqlParser.FAST - 261)) | (1 << (tsqlParser.FAST_FORWARD - 261)) | (1 << (tsqlParser.FIRST - 261)) | (1 << (tsqlParser.FIRST_VALUE - 261)) | (1 << (tsqlParser.FOLLOWING - 261)) | (1 << (tsqlParser.FORCE - 261)) | (1 << (tsqlParser.FORCED - 261)) | (1 << (tsqlParser.FORWARD_ONLY - 261)) | (1 << (tsqlParser.FULLSCAN - 261)) | (1 << (tsqlParser.GLOBAL - 261)) | (1 << (tsqlParser.GROUPING - 261)) | (1 << (tsqlParser.GROUPING_ID - 261)) | (1 << (tsqlParser.HASH - 261)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 261)) | (1 << (tsqlParser.IMPERSONATE - 261)) | (1 << (tsqlParser.INSENSITIVE - 261)) | (1 << (tsqlParser.INSERTED - 261)) | (1 << (tsqlParser.ISOLATION - 261)) | (1 << (tsqlParser.IO - 261)) | (1 << (tsqlParser.KEEP - 261)) | (1 << (tsqlParser.KEEPFIXED - 261)) | (1 << (tsqlParser.KEYSET - 261)) | (1 << (tsqlParser.LAG - 261)) | (1 << (tsqlParser.LAST - 261)) | (1 << (tsqlParser.LAST_VALUE - 261)) | (1 << (tsqlParser.LEAD - 261)) | (1 << (tsqlParser.LEVEL - 261)) | (1 << (tsqlParser.LOCAL - 261)) | (1 << (tsqlParser.LOCK_ESCALATION - 261)) | (1 << (tsqlParser.LOGIN - 261)) | (1 << (tsqlParser.LOOP - 261)) | (1 << (tsqlParser.MARK - 261)) | (1 << (tsqlParser.MAX - 261)) | (1 << (tsqlParser.MAXDOP - 261)) | (1 << (tsqlParser.MAXRECURSION - 261)))) != 0) or ((((_la - 328)) & ~0x3f) == 0 and ((1 << (_la - 328)) & ((1 << (tsqlParser.MIN - 328)) | (1 << (tsqlParser.MODIFY - 328)) | (1 << (tsqlParser.NAME - 328)) | (1 << (tsqlParser.NOCOUNT - 328)) | (1 << (tsqlParser.NODES - 328)) | (1 << (tsqlParser.NOEXPAND - 328)) | (1 << (tsqlParser.NORECOMPUTE - 328)) | (1 << (tsqlParser.NTILE - 328)) | (1 << (tsqlParser.NUMBER - 328)) | (1 << (tsqlParser.OFFSET - 328)) | (1 << (tsqlParser.ONLINE - 328)) | (1 << (tsqlParser.ONLY - 328)) | (1 << (tsqlParser.OPTIMISTIC - 328)) | (1 << (tsqlParser.OPTIMIZE - 328)) | (1 << (tsqlParser.OUT - 328)) | (1 << (tsqlParser.OUTPUT - 328)) | (1 << (tsqlParser.OWNER - 328)) | (1 << (tsqlParser.PARAMETERIZATION - 328)) | (1 << (tsqlParser.PARTITION - 328)) | (1 << (tsqlParser.PATH - 328)) | (1 << (tsqlParser.PRECEDING - 328)) | (1 << (tsqlParser.PRIOR - 328)) | (1 << (tsqlParser.PRIVILEGES - 328)) | (1 << (tsqlParser.QUERY - 328)) | (1 << (tsqlParser.RANGE - 328)) | (1 << (tsqlParser.RANK - 328)) | (1 << (tsqlParser.READONLY - 328)) | (1 << (tsqlParser.READ_ONLY - 328)) | (1 << (tsqlParser.RECOMPILE - 328)) | (1 << (tsqlParser.RELATIVE - 328)) | (1 << (tsqlParser.REMOTE - 328)) | (1 << (tsqlParser.REPEATABLE - 328)) | (1 << (tsqlParser.ROBUST - 328)) | (1 << (tsqlParser.ROOT - 328)) | (1 << (tsqlParser.ROW - 328)) | (1 << (tsqlParser.ROWGUID - 328)) | (1 << (tsqlParser.ROWS - 328)) | (1 << (tsqlParser.ROW_NUMBER - 328)) | (1 << (tsqlParser.SAMPLE - 328)) | (1 << (tsqlParser.SCHEMABINDING - 328)) | (1 << (tsqlParser.SCROLL - 328)) | (1 << (tsqlParser.SCROLL_LOCKS - 328)))) != 0) or ((((_la - 393)) & ~0x3f) == 0 and ((1 << (_la - 393)) & ((1 << (tsqlParser.SELF - 393)) | (1 << (tsqlParser.SERIALIZABLE - 393)) | (1 << (tsqlParser.SIMPLE - 393)) | (1 << (tsqlParser.SIZE - 393)) | (1 << (tsqlParser.SNAPSHOT - 393)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 393)) | (1 << (tsqlParser.STATIC - 393)) | (1 << (tsqlParser.STATS_STREAM - 393)) | (1 << (tsqlParser.STDEV - 393)) | (1 << (tsqlParser.STDEVP - 393)) | (1 << (tsqlParser.SUM - 393)) | (1 << (tsqlParser.TEXTIMAGE_ON - 393)) | (1 << (tsqlParser.THROW - 393)) | (1 << (tsqlParser.TIES - 393)) | (1 << (tsqlParser.TIME - 393)) | (1 << (tsqlParser.TRY - 393)) | (1 << (tsqlParser.TYPE - 393)) | (1 << (tsqlParser.TYPE_WARNING - 393)) | (1 << (tsqlParser.UNBOUNDED - 393)) | (1 << (tsqlParser.UNCOMMITTED - 393)) | (1 << (tsqlParser.UNKNOWN - 393)) | (1 << (tsqlParser.USING - 393)) | (1 << (tsqlParser.VAR - 393)) | (1 << (tsqlParser.VARP - 393)) | (1 << (tsqlParser.VIEWS - 393)) | (1 << (tsqlParser.VIEW_METADATA - 393)) | (1 << (tsqlParser.WORK - 393)) | (1 << (tsqlParser.XML - 393)) | (1 << (tsqlParser.XMLNAMESPACES - 393)) | (1 << (tsqlParser.ZONE - 393)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 393)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 393)) | (1 << (tsqlParser.ID - 393)))) != 0):
                self.state = 1436
                localctx.database = self.r_id()


            self.state = 1439
            self.match(tsqlParser.DOT)
            self.state = 1441
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (tsqlParser.FILLFACTOR - 71)) | (1 << (tsqlParser.FORCESEEK - 71)) | (1 << (tsqlParser.NEXT - 71)) | (1 << (tsqlParser.NUMERIC - 71)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (tsqlParser.VALUE - 196)) | (1 << (tsqlParser.ABSOLUTE - 196)) | (1 << (tsqlParser.APPLY - 196)) | (1 << (tsqlParser.AUTO - 196)) | (1 << (tsqlParser.AVG - 196)) | (1 << (tsqlParser.BASE64 - 196)) | (1 << (tsqlParser.CALLER - 196)) | (1 << (tsqlParser.CAST - 196)) | (1 << (tsqlParser.CATCH - 196)) | (1 << (tsqlParser.CHECKSUM_AGG - 196)) | (1 << (tsqlParser.COMMITTED - 196)) | (1 << (tsqlParser.CONCAT - 196)) | (1 << (tsqlParser.CONTROL - 196)) | (1 << (tsqlParser.COOKIE - 196)) | (1 << (tsqlParser.COUNT - 196)) | (1 << (tsqlParser.COUNT_BIG - 196)) | (1 << (tsqlParser.DATE - 196)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (tsqlParser.DELAY - 261)) | (1 << (tsqlParser.DELETED - 261)) | (1 << (tsqlParser.DENSE_RANK - 261)) | (1 << (tsqlParser.DISABLE - 261)) | (1 << (tsqlParser.DYNAMIC - 261)) | (1 << (tsqlParser.ENCRYPTION - 261)) | (1 << (tsqlParser.EXIST - 261)) | (1 << (tsqlParser.EXPAND - 261)) | (1 << (tsqlParser.FAST - 261)) | (1 << (tsqlParser.FAST_FORWARD - 261)) | (1 << (tsqlParser.FIRST - 261)) | (1 << (tsqlParser.FIRST_VALUE - 261)) | (1 << (tsqlParser.FOLLOWING - 261)) | (1 << (tsqlParser.FORCE - 261)) | (1 << (tsqlParser.FORCED - 261)) | (1 << (tsqlParser.FORWARD_ONLY - 261)) | (1 << (tsqlParser.FULLSCAN - 261)) | (1 << (tsqlParser.GLOBAL - 261)) | (1 << (tsqlParser.GROUPING - 261)) | (1 << (tsqlParser.GROUPING_ID - 261)) | (1 << (tsqlParser.HASH - 261)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 261)) | (1 << (tsqlParser.IMPERSONATE - 261)) | (1 << (tsqlParser.INSENSITIVE - 261)) | (1 << (tsqlParser.INSERTED - 261)) | (1 << (tsqlParser.ISOLATION - 261)) | (1 << (tsqlParser.IO - 261)) | (1 << (tsqlParser.KEEP - 261)) | (1 << (tsqlParser.KEEPFIXED - 261)) | (1 << (tsqlParser.KEYSET - 261)) | (1 << (tsqlParser.LAG - 261)) | (1 << (tsqlParser.LAST - 261)) | (1 << (tsqlParser.LAST_VALUE - 261)) | (1 << (tsqlParser.LEAD - 261)) | (1 << (tsqlParser.LEVEL - 261)) | (1 << (tsqlParser.LOCAL - 261)) | (1 << (tsqlParser.LOCK_ESCALATION - 261)) | (1 << (tsqlParser.LOGIN - 261)) | (1 << (tsqlParser.LOOP - 261)) | (1 << (tsqlParser.MARK - 261)) | (1 << (tsqlParser.MAX - 261)) | (1 << (tsqlParser.MAXDOP - 261)) | (1 << (tsqlParser.MAXRECURSION - 261)))) != 0) or ((((_la - 328)) & ~0x3f) == 0 and ((1 << (_la - 328)) & ((1 << (tsqlParser.MIN - 328)) | (1 << (tsqlParser.MODIFY - 328)) | (1 << (tsqlParser.NAME - 328)) | (1 << (tsqlParser.NOCOUNT - 328)) | (1 << (tsqlParser.NODES - 328)) | (1 << (tsqlParser.NOEXPAND - 328)) | (1 << (tsqlParser.NORECOMPUTE - 328)) | (1 << (tsqlParser.NTILE - 328)) | (1 << (tsqlParser.NUMBER - 328)) | (1 << (tsqlParser.OFFSET - 328)) | (1 << (tsqlParser.ONLINE - 328)) | (1 << (tsqlParser.ONLY - 328)) | (1 << (tsqlParser.OPTIMISTIC - 328)) | (1 << (tsqlParser.OPTIMIZE - 328)) | (1 << (tsqlParser.OUT - 328)) | (1 << (tsqlParser.OUTPUT - 328)) | (1 << (tsqlParser.OWNER - 328)) | (1 << (tsqlParser.PARAMETERIZATION - 328)) | (1 << (tsqlParser.PARTITION - 328)) | (1 << (tsqlParser.PATH - 328)) | (1 << (tsqlParser.PRECEDING - 328)) | (1 << (tsqlParser.PRIOR - 328)) | (1 << (tsqlParser.PRIVILEGES - 328)) | (1 << (tsqlParser.QUERY - 328)) | (1 << (tsqlParser.RANGE - 328)) | (1 << (tsqlParser.RANK - 328)) | (1 << (tsqlParser.READONLY - 328)) | (1 << (tsqlParser.READ_ONLY - 328)) | (1 << (tsqlParser.RECOMPILE - 328)) | (1 << (tsqlParser.RELATIVE - 328)) | (1 << (tsqlParser.REMOTE - 328)) | (1 << (tsqlParser.REPEATABLE - 328)) | (1 << (tsqlParser.ROBUST - 328)) | (1 << (tsqlParser.ROOT - 328)) | (1 << (tsqlParser.ROW - 328)) | (1 << (tsqlParser.ROWGUID - 328)) | (1 << (tsqlParser.ROWS - 328)) | (1 << (tsqlParser.ROW_NUMBER - 328)) | (1 << (tsqlParser.SAMPLE - 328)) | (1 << (tsqlParser.SCHEMABINDING - 328)) | (1 << (tsqlParser.SCROLL - 328)) | (1 << (tsqlParser.SCROLL_LOCKS - 328)))) != 0) or ((((_la - 393)) & ~0x3f) == 0 and ((1 << (_la - 393)) & ((1 << (tsqlParser.SELF - 393)) | (1 << (tsqlParser.SERIALIZABLE - 393)) | (1 << (tsqlParser.SIMPLE - 393)) | (1 << (tsqlParser.SIZE - 393)) | (1 << (tsqlParser.SNAPSHOT - 393)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 393)) | (1 << (tsqlParser.STATIC - 393)) | (1 << (tsqlParser.STATS_STREAM - 393)) | (1 << (tsqlParser.STDEV - 393)) | (1 << (tsqlParser.STDEVP - 393)) | (1 << (tsqlParser.SUM - 393)) | (1 << (tsqlParser.TEXTIMAGE_ON - 393)) | (1 << (tsqlParser.THROW - 393)) | (1 << (tsqlParser.TIES - 393)) | (1 << (tsqlParser.TIME - 393)) | (1 << (tsqlParser.TRY - 393)) | (1 << (tsqlParser.TYPE - 393)) | (1 << (tsqlParser.TYPE_WARNING - 393)) | (1 << (tsqlParser.UNBOUNDED - 393)) | (1 << (tsqlParser.UNCOMMITTED - 393)) | (1 << (tsqlParser.UNKNOWN - 393)) | (1 << (tsqlParser.USING - 393)) | (1 << (tsqlParser.VAR - 393)) | (1 << (tsqlParser.VARP - 393)) | (1 << (tsqlParser.VIEWS - 393)) | (1 << (tsqlParser.VIEW_METADATA - 393)) | (1 << (tsqlParser.WORK - 393)) | (1 << (tsqlParser.XML - 393)) | (1 << (tsqlParser.XMLNAMESPACES - 393)) | (1 << (tsqlParser.ZONE - 393)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 393)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 393)) | (1 << (tsqlParser.ID - 393)))) != 0):
                self.state = 1440
                localctx.scheme = self.r_id()


            self.state = 1443
            self.match(tsqlParser.DOT)

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


    class Declare_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DECLARE(self):
            return self.getToken(tsqlParser.DECLARE, 0)

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def table_type_definition(self):
            return self.getTypedRuleContext(tsqlParser.Table_type_definitionContext,0)


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

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

        def declare_local(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Declare_localContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Declare_localContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_declare_statement




    def declare_statement(self):

        localctx = tsqlParser.Declare_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_declare_statement)
        self._la = 0 # Token type
        try:
            self.state = 1467
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1446
                self.match(tsqlParser.DECLARE)
                self.state = 1447
                self.match(tsqlParser.LOCAL_ID)
                self.state = 1449
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.AS:
                    self.state = 1448
                    self.match(tsqlParser.AS)


                self.state = 1451
                self.table_type_definition()
                self.state = 1453
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,177,self._ctx)
                if la_ == 1:
                    self.state = 1452
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1455
                self.match(tsqlParser.DECLARE)
                self.state = 1456
                self.declare_local()
                self.state = 1461
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 1457
                    self.match(tsqlParser.COMMA)
                    self.state = 1458
                    self.declare_local()
                    self.state = 1463
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1465
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
                if la_ == 1:
                    self.state = 1464
                    self.match(tsqlParser.SEMI)


                pass


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


    class Cursor_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CLOSE(self):
            return self.getToken(tsqlParser.CLOSE, 0)

        def cursor_name(self):
            return self.getTypedRuleContext(tsqlParser.Cursor_nameContext,0)


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

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

        def DEALLOCATE(self):
            return self.getToken(tsqlParser.DEALLOCATE, 0)

        def declare_cursor(self):
            return self.getTypedRuleContext(tsqlParser.Declare_cursorContext,0)


        def fetch_cursor(self):
            return self.getTypedRuleContext(tsqlParser.Fetch_cursorContext,0)


        def OPEN(self):
            return self.getToken(tsqlParser.OPEN, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_cursor_statement




    def cursor_statement(self):

        localctx = tsqlParser.Cursor_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_cursor_statement)
        try:
            self.state = 1495
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.CLOSE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1469
                self.match(tsqlParser.CLOSE)
                self.state = 1471
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
                if la_ == 1:
                    self.state = 1470
                    self.match(tsqlParser.GLOBAL)


                self.state = 1473
                self.cursor_name()
                self.state = 1475
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
                if la_ == 1:
                    self.state = 1474
                    self.match(tsqlParser.SEMI)


                pass
            elif token in [tsqlParser.DEALLOCATE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1477
                self.match(tsqlParser.DEALLOCATE)
                self.state = 1479
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
                if la_ == 1:
                    self.state = 1478
                    self.match(tsqlParser.GLOBAL)


                self.state = 1481
                self.cursor_name()
                self.state = 1483
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,184,self._ctx)
                if la_ == 1:
                    self.state = 1482
                    self.match(tsqlParser.SEMI)


                pass
            elif token in [tsqlParser.DECLARE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1485
                self.declare_cursor()
                pass
            elif token in [tsqlParser.FETCH]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1486
                self.fetch_cursor()
                pass
            elif token in [tsqlParser.OPEN]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1487
                self.match(tsqlParser.OPEN)
                self.state = 1489
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
                if la_ == 1:
                    self.state = 1488
                    self.match(tsqlParser.GLOBAL)


                self.state = 1491
                self.cursor_name()
                self.state = 1493
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
                if la_ == 1:
                    self.state = 1492
                    self.match(tsqlParser.SEMI)


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

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

        def EXECUTE(self):
            return self.getToken(tsqlParser.EXECUTE, 0)

        def func_proc_name(self):
            return self.getTypedRuleContext(tsqlParser.Func_proc_nameContext,0)


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

        def execute_statement_arg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Execute_statement_argContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Execute_statement_argContext,i)


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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

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

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

        def execute_var_string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Execute_var_stringContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Execute_var_stringContext,i)


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

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

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

        def LOGIN(self):
            return self.getToken(tsqlParser.LOGIN, 0)

        def USER(self):
            return self.getToken(tsqlParser.USER, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_execute_statement




    def execute_statement(self):

        localctx = tsqlParser.Execute_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_execute_statement)
        self._la = 0 # Token type
        try:
            self.state = 1538
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1497
                self.match(tsqlParser.EXECUTE)
                self.state = 1500
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.LOCAL_ID:
                    self.state = 1498
                    localctx.return_status = self.match(tsqlParser.LOCAL_ID)
                    self.state = 1499
                    self.match(tsqlParser.EQUAL)


                self.state = 1502
                self.func_proc_name()
                self.state = 1511
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
                if la_ == 1:
                    self.state = 1503
                    self.execute_statement_arg()
                    self.state = 1508
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==tsqlParser.COMMA:
                        self.state = 1504
                        self.match(tsqlParser.COMMA)
                        self.state = 1505
                        self.execute_statement_arg()
                        self.state = 1510
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1514
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
                if la_ == 1:
                    self.state = 1513
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1516
                self.match(tsqlParser.EXECUTE)
                self.state = 1517
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1518
                self.execute_var_string()
                self.state = 1523
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.PLUS:
                    self.state = 1519
                    self.match(tsqlParser.PLUS)
                    self.state = 1520
                    self.execute_var_string()
                    self.state = 1525
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1526
                self.match(tsqlParser.RR_BRACKET)
                self.state = 1533
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
                if la_ == 1:
                    self.state = 1528
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.AS:
                        self.state = 1527
                        self.match(tsqlParser.AS)


                    self.state = 1530
                    _la = self._input.LA(1)
                    if not(_la==tsqlParser.USER or _la==tsqlParser.LOGIN):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1531
                    self.match(tsqlParser.EQUAL)
                    self.state = 1532
                    self.match(tsqlParser.STRING)


                self.state = 1536
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
                if la_ == 1:
                    self.state = 1535
                    self.match(tsqlParser.SEMI)


                pass


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


    class Execute_statement_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def NULL_(self):
            return self.getToken(tsqlParser.NULL_, 0)

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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def constant_LOCAL_ID(self):
            return self.getTypedRuleContext(tsqlParser.Constant_LOCAL_IDContext,0)


        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def OUT(self):
            return self.getToken(tsqlParser.OUT, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_execute_statement_arg




    def execute_statement_arg(self):

        localctx = tsqlParser.Execute_statement_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_execute_statement_arg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1542
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
            if la_ == 1:
                self.state = 1540
                localctx.parameter = self.match(tsqlParser.LOCAL_ID)
                self.state = 1541
                self.match(tsqlParser.EQUAL)


            self.state = 1553
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.LOCAL_ID, tsqlParser.DECIMAL, tsqlParser.ID, tsqlParser.STRING, tsqlParser.BINARY, tsqlParser.FLOAT, tsqlParser.REAL, tsqlParser.DOLLAR, tsqlParser.PLUS, tsqlParser.MINUS]:
                self.state = 1546
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.LOCAL_ID, tsqlParser.DECIMAL, tsqlParser.STRING, tsqlParser.BINARY, tsqlParser.FLOAT, tsqlParser.REAL, tsqlParser.DOLLAR, tsqlParser.PLUS, tsqlParser.MINUS]:
                    self.state = 1544
                    self.constant_LOCAL_ID()
                    pass
                elif token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                    self.state = 1545
                    self.r_id()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1549
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
                if la_ == 1:
                    self.state = 1548
                    _la = self._input.LA(1)
                    if not(_la==tsqlParser.OUT or _la==tsqlParser.OUTPUT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                pass
            elif token in [tsqlParser.DEFAULT]:
                self.state = 1551
                self.match(tsqlParser.DEFAULT)
                pass
            elif token in [tsqlParser.NULL_]:
                self.state = 1552
                self.match(tsqlParser.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 Execute_var_stringContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_execute_var_string




    def execute_var_string(self):

        localctx = tsqlParser.Execute_var_stringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_execute_var_string)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1555
            _la = self._input.LA(1)
            if not(_la==tsqlParser.LOCAL_ID or _la==tsqlParser.STRING):
                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 Security_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.on_id = None # Full_table_nameContext
            self.to_principal = None # R_idContext
            self.as_principal = None # R_idContext

        def execute_clause(self):
            return self.getTypedRuleContext(tsqlParser.Execute_clauseContext,0)


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

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

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

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

        def grant_permission(self):
            return self.getTypedRuleContext(tsqlParser.Grant_permissionContext,0)


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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


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

        def OPTION(self):
            return self.getToken(tsqlParser.OPTION, 0)

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

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


        def PRIVILEGES(self):
            return self.getToken(tsqlParser.PRIVILEGES, 0)

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

        def column_name_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_name_listContext,0)


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

        def REVERT(self):
            return self.getToken(tsqlParser.REVERT, 0)

        def COOKIE(self):
            return self.getToken(tsqlParser.COOKIE, 0)

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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_security_statement




    def security_statement(self):

        localctx = tsqlParser.Security_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_security_statement)
        self._la = 0 # Token type
        try:
            self.state = 1605
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.EXECUTE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1557
                self.execute_clause()
                self.state = 1559
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
                if la_ == 1:
                    self.state = 1558
                    self.match(tsqlParser.SEMI)


                pass
            elif token in [tsqlParser.GRANT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1561
                self.match(tsqlParser.GRANT)
                self.state = 1573
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.ALL]:
                    self.state = 1562
                    self.match(tsqlParser.ALL)
                    self.state = 1564
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.PRIVILEGES:
                        self.state = 1563
                        self.match(tsqlParser.PRIVILEGES)


                    pass
                elif token in [tsqlParser.ALTER, tsqlParser.CREATE, tsqlParser.EXECUTE, tsqlParser.INSERT, tsqlParser.REFERENCES, tsqlParser.SELECT, tsqlParser.VIEW, tsqlParser.CONTROL, tsqlParser.IMPERSONATE, tsqlParser.SHOWPLAN, tsqlParser.TAKE]:
                    self.state = 1566
                    self.grant_permission()
                    self.state = 1571
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.LR_BRACKET:
                        self.state = 1567
                        self.match(tsqlParser.LR_BRACKET)
                        self.state = 1568
                        self.column_name_list()
                        self.state = 1569
                        self.match(tsqlParser.RR_BRACKET)


                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1577
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ON:
                    self.state = 1575
                    self.match(tsqlParser.ON)
                    self.state = 1576
                    localctx.on_id = self.full_table_name()


                self.state = 1579
                self.match(tsqlParser.TO)

                self.state = 1580
                localctx.to_principal = self.r_id()
                self.state = 1584
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
                if la_ == 1:
                    self.state = 1581
                    self.match(tsqlParser.WITH)
                    self.state = 1582
                    self.match(tsqlParser.GRANT)
                    self.state = 1583
                    self.match(tsqlParser.OPTION)


                self.state = 1588
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.AS:
                    self.state = 1586
                    self.match(tsqlParser.AS)
                    self.state = 1587
                    localctx.as_principal = self.r_id()


                self.state = 1591
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
                if la_ == 1:
                    self.state = 1590
                    self.match(tsqlParser.SEMI)


                pass
            elif token in [tsqlParser.REVERT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1593
                self.match(tsqlParser.REVERT)
                self.state = 1600
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
                if la_ == 1:
                    self.state = 1594
                    self.match(tsqlParser.LR_BRACKET)
                    self.state = 1595
                    self.match(tsqlParser.WITH)
                    self.state = 1596
                    self.match(tsqlParser.COOKIE)
                    self.state = 1597
                    self.match(tsqlParser.EQUAL)
                    self.state = 1598
                    self.match(tsqlParser.LOCAL_ID)
                    self.state = 1599
                    self.match(tsqlParser.RR_BRACKET)


                self.state = 1603
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,210,self._ctx)
                if la_ == 1:
                    self.state = 1602
                    self.match(tsqlParser.SEMI)


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

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

        def EXECUTE(self):
            return self.getToken(tsqlParser.EXECUTE, 0)

        def VIEW(self):
            return self.getToken(tsqlParser.VIEW, 0)

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def CONTROL(self):
            return self.getToken(tsqlParser.CONTROL, 0)

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

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

        def SHOWPLAN(self):
            return self.getToken(tsqlParser.SHOWPLAN, 0)

        def IMPERSONATE(self):
            return self.getToken(tsqlParser.IMPERSONATE, 0)

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

        def REFERENCES(self):
            return self.getToken(tsqlParser.REFERENCES, 0)

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

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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_grant_permission




    def grant_permission(self):

        localctx = tsqlParser.Grant_permissionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_grant_permission)
        self._la = 0 # Token type
        try:
            self.state = 1633
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.EXECUTE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1607
                self.match(tsqlParser.EXECUTE)
                pass
            elif token in [tsqlParser.VIEW]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1608
                self.match(tsqlParser.VIEW)
                self.state = 1609
                self.r_id()
                pass
            elif token in [tsqlParser.TAKE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1610
                self.match(tsqlParser.TAKE)
                self.state = 1611
                self.r_id()
                pass
            elif token in [tsqlParser.CONTROL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1612
                self.match(tsqlParser.CONTROL)
                self.state = 1614
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (tsqlParser.FILLFACTOR - 71)) | (1 << (tsqlParser.FORCESEEK - 71)) | (1 << (tsqlParser.NEXT - 71)) | (1 << (tsqlParser.NUMERIC - 71)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (tsqlParser.VALUE - 196)) | (1 << (tsqlParser.ABSOLUTE - 196)) | (1 << (tsqlParser.APPLY - 196)) | (1 << (tsqlParser.AUTO - 196)) | (1 << (tsqlParser.AVG - 196)) | (1 << (tsqlParser.BASE64 - 196)) | (1 << (tsqlParser.CALLER - 196)) | (1 << (tsqlParser.CAST - 196)) | (1 << (tsqlParser.CATCH - 196)) | (1 << (tsqlParser.CHECKSUM_AGG - 196)) | (1 << (tsqlParser.COMMITTED - 196)) | (1 << (tsqlParser.CONCAT - 196)) | (1 << (tsqlParser.CONTROL - 196)) | (1 << (tsqlParser.COOKIE - 196)) | (1 << (tsqlParser.COUNT - 196)) | (1 << (tsqlParser.COUNT_BIG - 196)) | (1 << (tsqlParser.DATE - 196)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (tsqlParser.DELAY - 261)) | (1 << (tsqlParser.DELETED - 261)) | (1 << (tsqlParser.DENSE_RANK - 261)) | (1 << (tsqlParser.DISABLE - 261)) | (1 << (tsqlParser.DYNAMIC - 261)) | (1 << (tsqlParser.ENCRYPTION - 261)) | (1 << (tsqlParser.EXIST - 261)) | (1 << (tsqlParser.EXPAND - 261)) | (1 << (tsqlParser.FAST - 261)) | (1 << (tsqlParser.FAST_FORWARD - 261)) | (1 << (tsqlParser.FIRST - 261)) | (1 << (tsqlParser.FIRST_VALUE - 261)) | (1 << (tsqlParser.FOLLOWING - 261)) | (1 << (tsqlParser.FORCE - 261)) | (1 << (tsqlParser.FORCED - 261)) | (1 << (tsqlParser.FORWARD_ONLY - 261)) | (1 << (tsqlParser.FULLSCAN - 261)) | (1 << (tsqlParser.GLOBAL - 261)) | (1 << (tsqlParser.GROUPING - 261)) | (1 << (tsqlParser.GROUPING_ID - 261)) | (1 << (tsqlParser.HASH - 261)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 261)) | (1 << (tsqlParser.IMPERSONATE - 261)) | (1 << (tsqlParser.INSENSITIVE - 261)) | (1 << (tsqlParser.INSERTED - 261)) | (1 << (tsqlParser.ISOLATION - 261)) | (1 << (tsqlParser.IO - 261)) | (1 << (tsqlParser.KEEP - 261)) | (1 << (tsqlParser.KEEPFIXED - 261)) | (1 << (tsqlParser.KEYSET - 261)) | (1 << (tsqlParser.LAG - 261)) | (1 << (tsqlParser.LAST - 261)) | (1 << (tsqlParser.LAST_VALUE - 261)) | (1 << (tsqlParser.LEAD - 261)) | (1 << (tsqlParser.LEVEL - 261)) | (1 << (tsqlParser.LOCAL - 261)) | (1 << (tsqlParser.LOCK_ESCALATION - 261)) | (1 << (tsqlParser.LOGIN - 261)) | (1 << (tsqlParser.LOOP - 261)) | (1 << (tsqlParser.MARK - 261)) | (1 << (tsqlParser.MAX - 261)) | (1 << (tsqlParser.MAXDOP - 261)) | (1 << (tsqlParser.MAXRECURSION - 261)))) != 0) or ((((_la - 328)) & ~0x3f) == 0 and ((1 << (_la - 328)) & ((1 << (tsqlParser.MIN - 328)) | (1 << (tsqlParser.MODIFY - 328)) | (1 << (tsqlParser.NAME - 328)) | (1 << (tsqlParser.NOCOUNT - 328)) | (1 << (tsqlParser.NODES - 328)) | (1 << (tsqlParser.NOEXPAND - 328)) | (1 << (tsqlParser.NORECOMPUTE - 328)) | (1 << (tsqlParser.NTILE - 328)) | (1 << (tsqlParser.NUMBER - 328)) | (1 << (tsqlParser.OFFSET - 328)) | (1 << (tsqlParser.ONLINE - 328)) | (1 << (tsqlParser.ONLY - 328)) | (1 << (tsqlParser.OPTIMISTIC - 328)) | (1 << (tsqlParser.OPTIMIZE - 328)) | (1 << (tsqlParser.OUT - 328)) | (1 << (tsqlParser.OUTPUT - 328)) | (1 << (tsqlParser.OWNER - 328)) | (1 << (tsqlParser.PARAMETERIZATION - 328)) | (1 << (tsqlParser.PARTITION - 328)) | (1 << (tsqlParser.PATH - 328)) | (1 << (tsqlParser.PRECEDING - 328)) | (1 << (tsqlParser.PRIOR - 328)) | (1 << (tsqlParser.PRIVILEGES - 328)) | (1 << (tsqlParser.QUERY - 328)) | (1 << (tsqlParser.RANGE - 328)) | (1 << (tsqlParser.RANK - 328)) | (1 << (tsqlParser.READONLY - 328)) | (1 << (tsqlParser.READ_ONLY - 328)) | (1 << (tsqlParser.RECOMPILE - 328)) | (1 << (tsqlParser.RELATIVE - 328)) | (1 << (tsqlParser.REMOTE - 328)) | (1 << (tsqlParser.REPEATABLE - 328)) | (1 << (tsqlParser.ROBUST - 328)) | (1 << (tsqlParser.ROOT - 328)) | (1 << (tsqlParser.ROW - 328)) | (1 << (tsqlParser.ROWGUID - 328)) | (1 << (tsqlParser.ROWS - 328)) | (1 << (tsqlParser.ROW_NUMBER - 328)) | (1 << (tsqlParser.SAMPLE - 328)) | (1 << (tsqlParser.SCHEMABINDING - 328)) | (1 << (tsqlParser.SCROLL - 328)) | (1 << (tsqlParser.SCROLL_LOCKS - 328)))) != 0) or ((((_la - 393)) & ~0x3f) == 0 and ((1 << (_la - 393)) & ((1 << (tsqlParser.SELF - 393)) | (1 << (tsqlParser.SERIALIZABLE - 393)) | (1 << (tsqlParser.SIMPLE - 393)) | (1 << (tsqlParser.SIZE - 393)) | (1 << (tsqlParser.SNAPSHOT - 393)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 393)) | (1 << (tsqlParser.STATIC - 393)) | (1 << (tsqlParser.STATS_STREAM - 393)) | (1 << (tsqlParser.STDEV - 393)) | (1 << (tsqlParser.STDEVP - 393)) | (1 << (tsqlParser.SUM - 393)) | (1 << (tsqlParser.TEXTIMAGE_ON - 393)) | (1 << (tsqlParser.THROW - 393)) | (1 << (tsqlParser.TIES - 393)) | (1 << (tsqlParser.TIME - 393)) | (1 << (tsqlParser.TRY - 393)) | (1 << (tsqlParser.TYPE - 393)) | (1 << (tsqlParser.TYPE_WARNING - 393)) | (1 << (tsqlParser.UNBOUNDED - 393)) | (1 << (tsqlParser.UNCOMMITTED - 393)) | (1 << (tsqlParser.UNKNOWN - 393)) | (1 << (tsqlParser.USING - 393)) | (1 << (tsqlParser.VAR - 393)) | (1 << (tsqlParser.VARP - 393)) | (1 << (tsqlParser.VIEWS - 393)) | (1 << (tsqlParser.VIEW_METADATA - 393)) | (1 << (tsqlParser.WORK - 393)) | (1 << (tsqlParser.XML - 393)) | (1 << (tsqlParser.XMLNAMESPACES - 393)) | (1 << (tsqlParser.ZONE - 393)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 393)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 393)) | (1 << (tsqlParser.ID - 393)))) != 0):
                    self.state = 1613
                    self.r_id()


                pass
            elif token in [tsqlParser.CREATE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1616
                self.match(tsqlParser.CREATE)
                self.state = 1617
                _la = self._input.LA(1)
                if not(_la==tsqlParser.TABLE or _la==tsqlParser.VIEW):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.SHOWPLAN]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1618
                self.match(tsqlParser.SHOWPLAN)
                pass
            elif token in [tsqlParser.IMPERSONATE]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1619
                self.match(tsqlParser.IMPERSONATE)
                pass
            elif token in [tsqlParser.SELECT]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1620
                self.match(tsqlParser.SELECT)
                pass
            elif token in [tsqlParser.REFERENCES]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1621
                self.match(tsqlParser.REFERENCES)
                pass
            elif token in [tsqlParser.INSERT]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1622
                self.match(tsqlParser.INSERT)
                pass
            elif token in [tsqlParser.ALTER]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1623
                self.match(tsqlParser.ALTER)
                self.state = 1631
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ANY or _la==tsqlParser.DATABASE or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (tsqlParser.FILLFACTOR - 71)) | (1 << (tsqlParser.FORCESEEK - 71)) | (1 << (tsqlParser.NEXT - 71)) | (1 << (tsqlParser.NUMERIC - 71)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (tsqlParser.VALUE - 196)) | (1 << (tsqlParser.ABSOLUTE - 196)) | (1 << (tsqlParser.APPLY - 196)) | (1 << (tsqlParser.AUTO - 196)) | (1 << (tsqlParser.AVG - 196)) | (1 << (tsqlParser.BASE64 - 196)) | (1 << (tsqlParser.CALLER - 196)) | (1 << (tsqlParser.CAST - 196)) | (1 << (tsqlParser.CATCH - 196)) | (1 << (tsqlParser.CHECKSUM_AGG - 196)) | (1 << (tsqlParser.COMMITTED - 196)) | (1 << (tsqlParser.CONCAT - 196)) | (1 << (tsqlParser.CONTROL - 196)) | (1 << (tsqlParser.COOKIE - 196)) | (1 << (tsqlParser.COUNT - 196)) | (1 << (tsqlParser.COUNT_BIG - 196)) | (1 << (tsqlParser.DATE - 196)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (tsqlParser.DELAY - 261)) | (1 << (tsqlParser.DELETED - 261)) | (1 << (tsqlParser.DENSE_RANK - 261)) | (1 << (tsqlParser.DISABLE - 261)) | (1 << (tsqlParser.DYNAMIC - 261)) | (1 << (tsqlParser.ENCRYPTION - 261)) | (1 << (tsqlParser.EXIST - 261)) | (1 << (tsqlParser.EXPAND - 261)) | (1 << (tsqlParser.FAST - 261)) | (1 << (tsqlParser.FAST_FORWARD - 261)) | (1 << (tsqlParser.FIRST - 261)) | (1 << (tsqlParser.FIRST_VALUE - 261)) | (1 << (tsqlParser.FOLLOWING - 261)) | (1 << (tsqlParser.FORCE - 261)) | (1 << (tsqlParser.FORCED - 261)) | (1 << (tsqlParser.FORWARD_ONLY - 261)) | (1 << (tsqlParser.FULLSCAN - 261)) | (1 << (tsqlParser.GLOBAL - 261)) | (1 << (tsqlParser.GROUPING - 261)) | (1 << (tsqlParser.GROUPING_ID - 261)) | (1 << (tsqlParser.HASH - 261)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 261)) | (1 << (tsqlParser.IMPERSONATE - 261)) | (1 << (tsqlParser.INSENSITIVE - 261)) | (1 << (tsqlParser.INSERTED - 261)) | (1 << (tsqlParser.ISOLATION - 261)) | (1 << (tsqlParser.IO - 261)) | (1 << (tsqlParser.KEEP - 261)) | (1 << (tsqlParser.KEEPFIXED - 261)) | (1 << (tsqlParser.KEYSET - 261)) | (1 << (tsqlParser.LAG - 261)) | (1 << (tsqlParser.LAST - 261)) | (1 << (tsqlParser.LAST_VALUE - 261)) | (1 << (tsqlParser.LEAD - 261)) | (1 << (tsqlParser.LEVEL - 261)) | (1 << (tsqlParser.LOCAL - 261)) | (1 << (tsqlParser.LOCK_ESCALATION - 261)) | (1 << (tsqlParser.LOGIN - 261)) | (1 << (tsqlParser.LOOP - 261)) | (1 << (tsqlParser.MARK - 261)) | (1 << (tsqlParser.MAX - 261)) | (1 << (tsqlParser.MAXDOP - 261)) | (1 << (tsqlParser.MAXRECURSION - 261)))) != 0) or ((((_la - 328)) & ~0x3f) == 0 and ((1 << (_la - 328)) & ((1 << (tsqlParser.MIN - 328)) | (1 << (tsqlParser.MODIFY - 328)) | (1 << (tsqlParser.NAME - 328)) | (1 << (tsqlParser.NOCOUNT - 328)) | (1 << (tsqlParser.NODES - 328)) | (1 << (tsqlParser.NOEXPAND - 328)) | (1 << (tsqlParser.NORECOMPUTE - 328)) | (1 << (tsqlParser.NTILE - 328)) | (1 << (tsqlParser.NUMBER - 328)) | (1 << (tsqlParser.OFFSET - 328)) | (1 << (tsqlParser.ONLINE - 328)) | (1 << (tsqlParser.ONLY - 328)) | (1 << (tsqlParser.OPTIMISTIC - 328)) | (1 << (tsqlParser.OPTIMIZE - 328)) | (1 << (tsqlParser.OUT - 328)) | (1 << (tsqlParser.OUTPUT - 328)) | (1 << (tsqlParser.OWNER - 328)) | (1 << (tsqlParser.PARAMETERIZATION - 328)) | (1 << (tsqlParser.PARTITION - 328)) | (1 << (tsqlParser.PATH - 328)) | (1 << (tsqlParser.PRECEDING - 328)) | (1 << (tsqlParser.PRIOR - 328)) | (1 << (tsqlParser.PRIVILEGES - 328)) | (1 << (tsqlParser.QUERY - 328)) | (1 << (tsqlParser.RANGE - 328)) | (1 << (tsqlParser.RANK - 328)) | (1 << (tsqlParser.READONLY - 328)) | (1 << (tsqlParser.READ_ONLY - 328)) | (1 << (tsqlParser.RECOMPILE - 328)) | (1 << (tsqlParser.RELATIVE - 328)) | (1 << (tsqlParser.REMOTE - 328)) | (1 << (tsqlParser.REPEATABLE - 328)) | (1 << (tsqlParser.ROBUST - 328)) | (1 << (tsqlParser.ROOT - 328)) | (1 << (tsqlParser.ROW - 328)) | (1 << (tsqlParser.ROWGUID - 328)) | (1 << (tsqlParser.ROWS - 328)) | (1 << (tsqlParser.ROW_NUMBER - 328)) | (1 << (tsqlParser.SAMPLE - 328)) | (1 << (tsqlParser.SCHEMABINDING - 328)) | (1 << (tsqlParser.SCROLL - 328)) | (1 << (tsqlParser.SCROLL_LOCKS - 328)))) != 0) or ((((_la - 393)) & ~0x3f) == 0 and ((1 << (_la - 393)) & ((1 << (tsqlParser.SELF - 393)) | (1 << (tsqlParser.SERIALIZABLE - 393)) | (1 << (tsqlParser.SIMPLE - 393)) | (1 << (tsqlParser.SIZE - 393)) | (1 << (tsqlParser.SNAPSHOT - 393)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 393)) | (1 << (tsqlParser.STATIC - 393)) | (1 << (tsqlParser.STATS_STREAM - 393)) | (1 << (tsqlParser.STDEV - 393)) | (1 << (tsqlParser.STDEVP - 393)) | (1 << (tsqlParser.SUM - 393)) | (1 << (tsqlParser.TEXTIMAGE_ON - 393)) | (1 << (tsqlParser.THROW - 393)) | (1 << (tsqlParser.TIES - 393)) | (1 << (tsqlParser.TIME - 393)) | (1 << (tsqlParser.TRY - 393)) | (1 << (tsqlParser.TYPE - 393)) | (1 << (tsqlParser.TYPE_WARNING - 393)) | (1 << (tsqlParser.UNBOUNDED - 393)) | (1 << (tsqlParser.UNCOMMITTED - 393)) | (1 << (tsqlParser.UNKNOWN - 393)) | (1 << (tsqlParser.USING - 393)) | (1 << (tsqlParser.VAR - 393)) | (1 << (tsqlParser.VARP - 393)) | (1 << (tsqlParser.VIEWS - 393)) | (1 << (tsqlParser.VIEW_METADATA - 393)) | (1 << (tsqlParser.WORK - 393)) | (1 << (tsqlParser.XML - 393)) | (1 << (tsqlParser.XMLNAMESPACES - 393)) | (1 << (tsqlParser.ZONE - 393)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 393)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 393)) | (1 << (tsqlParser.ID - 393)))) != 0):
                    self.state = 1625
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.ANY:
                        self.state = 1624
                        self.match(tsqlParser.ANY)


                    self.state = 1629
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                        self.state = 1627
                        self.r_id()
                        pass
                    elif token in [tsqlParser.DATABASE]:
                        self.state = 1628
                        self.match(tsqlParser.DATABASE)
                        pass
                    else:
                        raise NoViableAltException(self)



                pass
            else:
                raise NoViableAltException(self)

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


    class Set_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

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

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


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

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def assignment_operator(self):
            return self.getTypedRuleContext(tsqlParser.Assignment_operatorContext,0)


        def CURSOR(self):
            return self.getToken(tsqlParser.CURSOR, 0)

        def declare_set_cursor_common(self):
            return self.getTypedRuleContext(tsqlParser.Declare_set_cursor_commonContext,0)


        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def READ(self):
            return self.getToken(tsqlParser.READ, 0)

        def ONLY(self):
            return self.getToken(tsqlParser.ONLY, 0)

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

        def OF(self):
            return self.getToken(tsqlParser.OF, 0)

        def column_name_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_name_listContext,0)


        def set_special(self):
            return self.getTypedRuleContext(tsqlParser.Set_specialContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_set_statement




    def set_statement(self):

        localctx = tsqlParser.Set_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_set_statement)
        self._la = 0 # Token type
        try:
            self.state = 1674
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,224,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1635
                self.match(tsqlParser.SET)
                self.state = 1636
                self.match(tsqlParser.LOCAL_ID)
                self.state = 1639
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.DOT:
                    self.state = 1637
                    self.match(tsqlParser.DOT)
                    self.state = 1638
                    localctx.member_name = self.r_id()


                self.state = 1641
                self.match(tsqlParser.EQUAL)
                self.state = 1642
                self.expression(0)
                self.state = 1644
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,218,self._ctx)
                if la_ == 1:
                    self.state = 1643
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1646
                self.match(tsqlParser.SET)
                self.state = 1647
                self.match(tsqlParser.LOCAL_ID)
                self.state = 1648
                self.assignment_operator()
                self.state = 1649
                self.expression(0)
                self.state = 1651
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,219,self._ctx)
                if la_ == 1:
                    self.state = 1650
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1653
                self.match(tsqlParser.SET)
                self.state = 1654
                self.match(tsqlParser.LOCAL_ID)
                self.state = 1655
                self.match(tsqlParser.EQUAL)
                self.state = 1656
                self.match(tsqlParser.CURSOR)
                self.state = 1657
                self.declare_set_cursor_common()
                self.state = 1668
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.FOR:
                    self.state = 1658
                    self.match(tsqlParser.FOR)
                    self.state = 1666
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [tsqlParser.READ]:
                        self.state = 1659
                        self.match(tsqlParser.READ)
                        self.state = 1660
                        self.match(tsqlParser.ONLY)
                        pass
                    elif token in [tsqlParser.UPDATE]:
                        self.state = 1661
                        self.match(tsqlParser.UPDATE)
                        self.state = 1664
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==tsqlParser.OF:
                            self.state = 1662
                            self.match(tsqlParser.OF)
                            self.state = 1663
                            self.column_name_list()


                        pass
                    else:
                        raise NoViableAltException(self)



                self.state = 1671
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
                if la_ == 1:
                    self.state = 1670
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1673
                self.set_special()
                pass


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


    class Transaction_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BEGIN(self):
            return self.getToken(tsqlParser.BEGIN, 0)

        def DISTRIBUTED(self):
            return self.getToken(tsqlParser.DISTRIBUTED, 0)

        def TRAN(self):
            return self.getToken(tsqlParser.TRAN, 0)

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

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

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

        def MARK(self):
            return self.getToken(tsqlParser.MARK, 0)

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

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

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

        def DELAYED_DURABILITY(self):
            return self.getToken(tsqlParser.DELAYED_DURABILITY, 0)

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

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

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

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

        def WORK(self):
            return self.getToken(tsqlParser.WORK, 0)

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_transaction_statement




    def transaction_statement(self):

        localctx = tsqlParser.Transaction_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_transaction_statement)
        self._la = 0 # Token type
        try:
            self.state = 1753
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,243,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1676
                self.match(tsqlParser.BEGIN)
                self.state = 1677
                self.match(tsqlParser.DISTRIBUTED)
                self.state = 1678
                _la = self._input.LA(1)
                if not(_la==tsqlParser.TRAN or _la==tsqlParser.TRANSACTION):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1681
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
                if la_ == 1:
                    self.state = 1679
                    self.r_id()

                elif la_ == 2:
                    self.state = 1680
                    self.match(tsqlParser.LOCAL_ID)


                self.state = 1684
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,226,self._ctx)
                if la_ == 1:
                    self.state = 1683
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1686
                self.match(tsqlParser.BEGIN)
                self.state = 1687
                _la = self._input.LA(1)
                if not(_la==tsqlParser.TRAN or _la==tsqlParser.TRANSACTION):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1697
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
                if la_ == 1:
                    self.state = 1690
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                        self.state = 1688
                        self.r_id()
                        pass
                    elif token in [tsqlParser.LOCAL_ID]:
                        self.state = 1689
                        self.match(tsqlParser.LOCAL_ID)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 1695
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,228,self._ctx)
                    if la_ == 1:
                        self.state = 1692
                        self.match(tsqlParser.WITH)
                        self.state = 1693
                        self.match(tsqlParser.MARK)
                        self.state = 1694
                        self.match(tsqlParser.STRING)




                self.state = 1700
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
                if la_ == 1:
                    self.state = 1699
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1702
                self.match(tsqlParser.COMMIT)
                self.state = 1703
                _la = self._input.LA(1)
                if not(_la==tsqlParser.TRAN or _la==tsqlParser.TRANSACTION):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1716
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
                if la_ == 1:
                    self.state = 1706
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                        self.state = 1704
                        self.r_id()
                        pass
                    elif token in [tsqlParser.LOCAL_ID]:
                        self.state = 1705
                        self.match(tsqlParser.LOCAL_ID)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 1714
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,232,self._ctx)
                    if la_ == 1:
                        self.state = 1708
                        self.match(tsqlParser.WITH)
                        self.state = 1709
                        self.match(tsqlParser.LR_BRACKET)
                        self.state = 1710
                        self.match(tsqlParser.DELAYED_DURABILITY)
                        self.state = 1711
                        self.match(tsqlParser.EQUAL)
                        self.state = 1712
                        _la = self._input.LA(1)
                        if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1713
                        self.match(tsqlParser.RR_BRACKET)




                self.state = 1719
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
                if la_ == 1:
                    self.state = 1718
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1721
                self.match(tsqlParser.COMMIT)
                self.state = 1723
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,235,self._ctx)
                if la_ == 1:
                    self.state = 1722
                    self.match(tsqlParser.WORK)


                self.state = 1726
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,236,self._ctx)
                if la_ == 1:
                    self.state = 1725
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1728
                self.match(tsqlParser.ROLLBACK)
                self.state = 1729
                _la = self._input.LA(1)
                if not(_la==tsqlParser.TRAN or _la==tsqlParser.TRANSACTION):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1732
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,237,self._ctx)
                if la_ == 1:
                    self.state = 1730
                    self.r_id()

                elif la_ == 2:
                    self.state = 1731
                    self.match(tsqlParser.LOCAL_ID)


                self.state = 1735
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
                if la_ == 1:
                    self.state = 1734
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1737
                self.match(tsqlParser.ROLLBACK)
                self.state = 1739
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,239,self._ctx)
                if la_ == 1:
                    self.state = 1738
                    self.match(tsqlParser.WORK)


                self.state = 1742
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,240,self._ctx)
                if la_ == 1:
                    self.state = 1741
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1744
                self.match(tsqlParser.SAVE)
                self.state = 1745
                _la = self._input.LA(1)
                if not(_la==tsqlParser.TRAN or _la==tsqlParser.TRANSACTION):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1748
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
                if la_ == 1:
                    self.state = 1746
                    self.r_id()

                elif la_ == 2:
                    self.state = 1747
                    self.match(tsqlParser.LOCAL_ID)


                self.state = 1751
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,242,self._ctx)
                if la_ == 1:
                    self.state = 1750
                    self.match(tsqlParser.SEMI)


                pass


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


    class Go_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GO(self):
            return self.getToken(tsqlParser.GO, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_go_statement




    def go_statement(self):

        localctx = tsqlParser.Go_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_go_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1755
            self.match(tsqlParser.GO)
            self.state = 1757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.DECIMAL:
                self.state = 1756
                localctx.count = self.match(tsqlParser.DECIMAL)


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


    class Use_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_use_statement




    def use_statement(self):

        localctx = tsqlParser.Use_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_use_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1759
            self.match(tsqlParser.USE)
            self.state = 1760
            localctx.database = self.r_id()
            self.state = 1762
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
            if la_ == 1:
                self.state = 1761
                self.match(tsqlParser.SEMI)


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


    class Execute_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EXECUTE(self):
            return self.getToken(tsqlParser.EXECUTE, 0)

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

        def CALLER(self):
            return self.getToken(tsqlParser.CALLER, 0)

        def SELF(self):
            return self.getToken(tsqlParser.SELF, 0)

        def OWNER(self):
            return self.getToken(tsqlParser.OWNER, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_execute_clause




    def execute_clause(self):

        localctx = tsqlParser.Execute_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_execute_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1764
            self.match(tsqlParser.EXECUTE)
            self.state = 1765
            self.match(tsqlParser.AS)
            self.state = 1766
            localctx.clause = self._input.LT(1)
            _la = self._input.LA(1)
            if not(_la==tsqlParser.CALLER or _la==tsqlParser.OWNER or _la==tsqlParser.SELF or _la==tsqlParser.STRING):
                localctx.clause = 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 Declare_localContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def data_type(self):
            return self.getTypedRuleContext(tsqlParser.Data_typeContext,0)


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

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

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


        def getRuleIndex(self):
            return tsqlParser.RULE_declare_local




    def declare_local(self):

        localctx = tsqlParser.Declare_localContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_declare_local)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1768
            self.match(tsqlParser.LOCAL_ID)
            self.state = 1770
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.AS:
                self.state = 1769
                self.match(tsqlParser.AS)


            self.state = 1772
            self.data_type()
            self.state = 1775
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.EQUAL:
                self.state = 1773
                self.match(tsqlParser.EQUAL)
                self.state = 1774
                self.expression(0)


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


    class Table_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def column_def_table_constraints(self):
            return self.getTypedRuleContext(tsqlParser.Column_def_table_constraintsContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_table_type_definition




    def table_type_definition(self):

        localctx = tsqlParser.Table_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_table_type_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1777
            self.match(tsqlParser.TABLE)
            self.state = 1778
            self.match(tsqlParser.LR_BRACKET)
            self.state = 1779
            self.column_def_table_constraints()
            self.state = 1780
            self.match(tsqlParser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Column_def_table_constraintsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def column_def_table_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Column_def_table_constraintContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Column_def_table_constraintContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_column_def_table_constraints




    def column_def_table_constraints(self):

        localctx = tsqlParser.Column_def_table_constraintsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_column_def_table_constraints)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1782
            self.column_def_table_constraint()
            self.state = 1789
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,249,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1784
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.COMMA:
                        self.state = 1783
                        self.match(tsqlParser.COMMA)


                    self.state = 1786
                    self.column_def_table_constraint() 
                self.state = 1791
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,249,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 Column_def_table_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def column_definition(self):
            return self.getTypedRuleContext(tsqlParser.Column_definitionContext,0)


        def table_constraint(self):
            return self.getTypedRuleContext(tsqlParser.Table_constraintContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_column_def_table_constraint




    def column_def_table_constraint(self):

        localctx = tsqlParser.Column_def_table_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_column_def_table_constraint)
        try:
            self.state = 1794
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1792
                self.column_definition()
                pass
            elif token in [tsqlParser.CHECK, tsqlParser.CONSTRAINT, tsqlParser.FOREIGN, tsqlParser.PRIMARY, tsqlParser.UNIQUE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1793
                self.table_constraint()
                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 Column_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def data_type(self):
            return self.getTypedRuleContext(tsqlParser.Data_typeContext,0)


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

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


        def COLLATE(self):
            return self.getToken(tsqlParser.COLLATE, 0)

        def null_notnull(self):
            return self.getTypedRuleContext(tsqlParser.Null_notnullContext,0)


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

        def constant_expression(self):
            return self.getTypedRuleContext(tsqlParser.Constant_expressionContext,0)


        def IDENTITY(self):
            return self.getToken(tsqlParser.IDENTITY, 0)

        def ROWGUIDCOL(self):
            return self.getToken(tsqlParser.ROWGUIDCOL, 0)

        def column_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Column_constraintContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Column_constraintContext,i)


        def CONSTRAINT(self):
            return self.getToken(tsqlParser.CONSTRAINT, 0)

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

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

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

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

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

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

        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def REPLICATION(self):
            return self.getToken(tsqlParser.REPLICATION, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_column_definition




    def column_definition(self):

        localctx = tsqlParser.Column_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_column_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1796
            self.r_id()
            self.state = 1800
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.DOUBLE, tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.BIGINT, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DATETIME2, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INT, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SMALLINT, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TINYINT, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.state = 1797
                self.data_type()
                pass
            elif token in [tsqlParser.AS]:
                self.state = 1798
                self.match(tsqlParser.AS)
                self.state = 1799
                self.expression(0)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1804
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.COLLATE:
                self.state = 1802
                self.match(tsqlParser.COLLATE)
                self.state = 1803
                self.r_id()


            self.state = 1807
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,253,self._ctx)
            if la_ == 1:
                self.state = 1806
                self.null_notnull()


            self.state = 1832
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
            if la_ == 1:
                self.state = 1811
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.CONSTRAINT:
                    self.state = 1809
                    self.match(tsqlParser.CONSTRAINT)
                    self.state = 1810
                    localctx.constraint = self.r_id()


                self.state = 1813
                self.match(tsqlParser.DEFAULT)
                self.state = 1814
                self.constant_expression()
                self.state = 1817
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,255,self._ctx)
                if la_ == 1:
                    self.state = 1815
                    self.match(tsqlParser.WITH)
                    self.state = 1816
                    self.match(tsqlParser.VALUES)



            elif la_ == 2:
                self.state = 1819
                self.match(tsqlParser.IDENTITY)
                self.state = 1825
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
                if la_ == 1:
                    self.state = 1820
                    self.match(tsqlParser.LR_BRACKET)
                    self.state = 1821
                    localctx.seed = self.match(tsqlParser.DECIMAL)
                    self.state = 1822
                    self.match(tsqlParser.COMMA)
                    self.state = 1823
                    localctx.increment = self.match(tsqlParser.DECIMAL)
                    self.state = 1824
                    self.match(tsqlParser.RR_BRACKET)


                self.state = 1830
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,257,self._ctx)
                if la_ == 1:
                    self.state = 1827
                    self.match(tsqlParser.NOT)
                    self.state = 1828
                    self.match(tsqlParser.FOR)
                    self.state = 1829
                    self.match(tsqlParser.REPLICATION)




            self.state = 1835
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.ROWGUIDCOL:
                self.state = 1834
                self.match(tsqlParser.ROWGUIDCOL)


            self.state = 1840
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,260,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1837
                    self.column_constraint() 
                self.state = 1842
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,260,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 Column_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHECK(self):
            return self.getToken(tsqlParser.CHECK, 0)

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

        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)


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

        def CONSTRAINT(self):
            return self.getToken(tsqlParser.CONSTRAINT, 0)

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def null_notnull(self):
            return self.getTypedRuleContext(tsqlParser.Null_notnullContext,0)


        def PRIMARY(self):
            return self.getToken(tsqlParser.PRIMARY, 0)

        def KEY(self):
            return self.getToken(tsqlParser.KEY, 0)

        def UNIQUE(self):
            return self.getToken(tsqlParser.UNIQUE, 0)

        def clustered(self):
            return self.getTypedRuleContext(tsqlParser.ClusteredContext,0)


        def index_options(self):
            return self.getTypedRuleContext(tsqlParser.Index_optionsContext,0)


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

        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def REPLICATION(self):
            return self.getToken(tsqlParser.REPLICATION, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_column_constraint




    def column_constraint(self):

        localctx = tsqlParser.Column_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_column_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1845
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.CONSTRAINT:
                self.state = 1843
                self.match(tsqlParser.CONSTRAINT)
                self.state = 1844
                self.r_id()


            self.state = 1848
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.NOT or _la==tsqlParser.NULL_:
                self.state = 1847
                self.null_notnull()


            self.state = 1871
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.PRIMARY, tsqlParser.UNIQUE]:
                self.state = 1853
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.PRIMARY]:
                    self.state = 1850
                    self.match(tsqlParser.PRIMARY)
                    self.state = 1851
                    self.match(tsqlParser.KEY)
                    pass
                elif token in [tsqlParser.UNIQUE]:
                    self.state = 1852
                    self.match(tsqlParser.UNIQUE)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1856
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.CLUSTERED or _la==tsqlParser.NONCLUSTERED:
                    self.state = 1855
                    self.clustered()


                self.state = 1859
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,265,self._ctx)
                if la_ == 1:
                    self.state = 1858
                    self.index_options()


                pass
            elif token in [tsqlParser.CHECK]:
                self.state = 1861
                self.match(tsqlParser.CHECK)
                self.state = 1865
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.NOT:
                    self.state = 1862
                    self.match(tsqlParser.NOT)
                    self.state = 1863
                    self.match(tsqlParser.FOR)
                    self.state = 1864
                    self.match(tsqlParser.REPLICATION)


                self.state = 1867
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1868
                self.search_condition(0)
                self.state = 1869
                self.match(tsqlParser.RR_BRACKET)
                pass
            else:
                raise NoViableAltException(self)

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


    class Table_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


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

        def FOREIGN(self):
            return self.getToken(tsqlParser.FOREIGN, 0)

        def KEY(self):
            return self.getToken(tsqlParser.KEY, 0)

        def REFERENCES(self):
            return self.getToken(tsqlParser.REFERENCES, 0)

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


        def CHECK(self):
            return self.getToken(tsqlParser.CHECK, 0)

        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)


        def CONSTRAINT(self):
            return self.getToken(tsqlParser.CONSTRAINT, 0)

        def column_name_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Column_name_listContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Column_name_listContext,i)


        def PRIMARY(self):
            return self.getToken(tsqlParser.PRIMARY, 0)

        def UNIQUE(self):
            return self.getToken(tsqlParser.UNIQUE, 0)

        def clustered(self):
            return self.getTypedRuleContext(tsqlParser.ClusteredContext,0)


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

        def index_options(self):
            return self.getTypedRuleContext(tsqlParser.Index_optionsContext,0)


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

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

        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def REPLICATION(self):
            return self.getToken(tsqlParser.REPLICATION, 0)

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_table_constraint




    def table_constraint(self):

        localctx = tsqlParser.Table_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_table_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1875
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.CONSTRAINT:
                self.state = 1873
                self.match(tsqlParser.CONSTRAINT)
                self.state = 1874
                self.r_id()


            self.state = 1929
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.PRIMARY, tsqlParser.UNIQUE]:
                self.state = 1880
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.PRIMARY]:
                    self.state = 1877
                    self.match(tsqlParser.PRIMARY)
                    self.state = 1878
                    self.match(tsqlParser.KEY)
                    pass
                elif token in [tsqlParser.UNIQUE]:
                    self.state = 1879
                    self.match(tsqlParser.UNIQUE)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1883
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.CLUSTERED or _la==tsqlParser.NONCLUSTERED:
                    self.state = 1882
                    self.clustered()


                self.state = 1885
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1886
                self.r_id()
                self.state = 1888
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ASC or _la==tsqlParser.DESC:
                    self.state = 1887
                    _la = self._input.LA(1)
                    if not(_la==tsqlParser.ASC or _la==tsqlParser.DESC):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1897
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 1890
                    self.match(tsqlParser.COMMA)
                    self.state = 1891
                    self.r_id()
                    self.state = 1893
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.ASC or _la==tsqlParser.DESC:
                        self.state = 1892
                        _la = self._input.LA(1)
                        if not(_la==tsqlParser.ASC or _la==tsqlParser.DESC):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


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

                self.state = 1900
                self.match(tsqlParser.RR_BRACKET)
                self.state = 1902
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
                if la_ == 1:
                    self.state = 1901
                    self.index_options()


                self.state = 1906
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ON:
                    self.state = 1904
                    self.match(tsqlParser.ON)
                    self.state = 1905
                    self.r_id()


                pass
            elif token in [tsqlParser.FOREIGN]:
                self.state = 1908
                self.match(tsqlParser.FOREIGN)
                self.state = 1909
                self.match(tsqlParser.KEY)
                self.state = 1910
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1911
                localctx.fk = self.column_name_list()
                self.state = 1912
                self.match(tsqlParser.RR_BRACKET)
                self.state = 1913
                self.match(tsqlParser.REFERENCES)
                self.state = 1914
                self.full_table_name()
                self.state = 1915
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1916
                localctx.pk = self.column_name_list()
                self.state = 1917
                self.match(tsqlParser.RR_BRACKET)
                pass
            elif token in [tsqlParser.CHECK]:
                self.state = 1919
                self.match(tsqlParser.CHECK)
                self.state = 1923
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.NOT:
                    self.state = 1920
                    self.match(tsqlParser.NOT)
                    self.state = 1921
                    self.match(tsqlParser.FOR)
                    self.state = 1922
                    self.match(tsqlParser.REPLICATION)


                self.state = 1925
                self.match(tsqlParser.LR_BRACKET)
                self.state = 1926
                self.search_condition(0)
                self.state = 1927
                self.match(tsqlParser.RR_BRACKET)
                pass
            else:
                raise NoViableAltException(self)

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


    class Index_optionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def index_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Index_optionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Index_optionContext,i)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_index_options




    def index_options(self):

        localctx = tsqlParser.Index_optionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_index_options)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1931
            self.match(tsqlParser.WITH)
            self.state = 1932
            self.match(tsqlParser.LR_BRACKET)
            self.state = 1933
            self.index_option()
            self.state = 1938
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 1934
                self.match(tsqlParser.COMMA)
                self.state = 1935
                self.index_option()
                self.state = 1940
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Index_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def simple_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Simple_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Simple_idContext,i)


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

        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_index_option




    def index_option(self):

        localctx = tsqlParser.Index_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_index_option)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1943
            self.simple_id()
            self.state = 1944
            self.match(tsqlParser.EQUAL)
            self.state = 1948
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.ID]:
                self.state = 1945
                self.simple_id()
                pass
            elif token in [tsqlParser.OFF, tsqlParser.ON]:
                self.state = 1946
                self.on_off()
                pass
            elif token in [tsqlParser.DECIMAL]:
                self.state = 1947
                self.match(tsqlParser.DECIMAL)
                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 Declare_cursorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DECLARE(self):
            return self.getToken(tsqlParser.DECLARE, 0)

        def cursor_name(self):
            return self.getTypedRuleContext(tsqlParser.Cursor_nameContext,0)


        def CURSOR(self):
            return self.getToken(tsqlParser.CURSOR, 0)

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

        def select_statement(self):
            return self.getTypedRuleContext(tsqlParser.Select_statementContext,0)


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

        def declare_set_cursor_common(self):
            return self.getTypedRuleContext(tsqlParser.Declare_set_cursor_commonContext,0)


        def INSENSITIVE(self):
            return self.getToken(tsqlParser.INSENSITIVE, 0)

        def SCROLL(self):
            return self.getToken(tsqlParser.SCROLL, 0)

        def READ(self):
            return self.getToken(tsqlParser.READ, 0)

        def ONLY(self):
            return self.getToken(tsqlParser.ONLY, 0)

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

        def OF(self):
            return self.getToken(tsqlParser.OF, 0)

        def column_name_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_name_listContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_declare_cursor




    def declare_cursor(self):

        localctx = tsqlParser.Declare_cursorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_declare_cursor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1950
            self.match(tsqlParser.DECLARE)
            self.state = 1951
            self.cursor_name()
            self.state = 1983
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,287,self._ctx)
            if la_ == 1:
                self.state = 1952
                self.match(tsqlParser.CURSOR)
                self.state = 1962
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,282,self._ctx)
                if la_ == 1:
                    self.state = 1953
                    self.declare_set_cursor_common()
                    self.state = 1960
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.FOR:
                        self.state = 1954
                        self.match(tsqlParser.FOR)
                        self.state = 1955
                        self.match(tsqlParser.UPDATE)
                        self.state = 1958
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==tsqlParser.OF:
                            self.state = 1956
                            self.match(tsqlParser.OF)
                            self.state = 1957
                            self.column_name_list()






                pass

            elif la_ == 2:
                self.state = 1965
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.INSENSITIVE:
                    self.state = 1964
                    self.match(tsqlParser.INSENSITIVE)


                self.state = 1968
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.SCROLL:
                    self.state = 1967
                    self.match(tsqlParser.SCROLL)


                self.state = 1970
                self.match(tsqlParser.CURSOR)
                self.state = 1971
                self.match(tsqlParser.FOR)
                self.state = 1972
                self.select_statement()
                self.state = 1981
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.FOR:
                    self.state = 1973
                    self.match(tsqlParser.FOR)
                    self.state = 1979
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [tsqlParser.READ]:
                        self.state = 1974
                        self.match(tsqlParser.READ)
                        self.state = 1975
                        self.match(tsqlParser.ONLY)
                        pass
                    elif token in [tsqlParser.UPDATE]:
                        self.state = 1976
                        self.match(tsqlParser.UPDATE)
                        pass
                    elif token in [tsqlParser.OF]:
                        self.state = 1977
                        self.match(tsqlParser.OF)
                        self.state = 1978
                        self.column_name_list()
                        pass
                    else:
                        raise NoViableAltException(self)



                pass


            self.state = 1986
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,288,self._ctx)
            if la_ == 1:
                self.state = 1985
                self.match(tsqlParser.SEMI)


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


    class Declare_set_cursor_commonContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def select_statement(self):
            return self.getTypedRuleContext(tsqlParser.Select_statementContext,0)


        def TYPE_WARNING(self):
            return self.getToken(tsqlParser.TYPE_WARNING, 0)

        def LOCAL(self):
            return self.getToken(tsqlParser.LOCAL, 0)

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

        def FORWARD_ONLY(self):
            return self.getToken(tsqlParser.FORWARD_ONLY, 0)

        def SCROLL(self):
            return self.getToken(tsqlParser.SCROLL, 0)

        def STATIC(self):
            return self.getToken(tsqlParser.STATIC, 0)

        def KEYSET(self):
            return self.getToken(tsqlParser.KEYSET, 0)

        def DYNAMIC(self):
            return self.getToken(tsqlParser.DYNAMIC, 0)

        def FAST_FORWARD(self):
            return self.getToken(tsqlParser.FAST_FORWARD, 0)

        def READ_ONLY(self):
            return self.getToken(tsqlParser.READ_ONLY, 0)

        def SCROLL_LOCKS(self):
            return self.getToken(tsqlParser.SCROLL_LOCKS, 0)

        def OPTIMISTIC(self):
            return self.getToken(tsqlParser.OPTIMISTIC, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_declare_set_cursor_common




    def declare_set_cursor_common(self):

        localctx = tsqlParser.Declare_set_cursor_commonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_declare_set_cursor_common)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1989
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.GLOBAL or _la==tsqlParser.LOCAL:
                self.state = 1988
                _la = self._input.LA(1)
                if not(_la==tsqlParser.GLOBAL or _la==tsqlParser.LOCAL):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1992
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FORWARD_ONLY or _la==tsqlParser.SCROLL:
                self.state = 1991
                _la = self._input.LA(1)
                if not(_la==tsqlParser.FORWARD_ONLY or _la==tsqlParser.SCROLL):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1995
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 269)) & ~0x3f) == 0 and ((1 << (_la - 269)) & ((1 << (tsqlParser.DYNAMIC - 269)) | (1 << (tsqlParser.FAST_FORWARD - 269)) | (1 << (tsqlParser.KEYSET - 269)))) != 0) or _la==tsqlParser.STATIC:
                self.state = 1994
                _la = self._input.LA(1)
                if not(((((_la - 269)) & ~0x3f) == 0 and ((1 << (_la - 269)) & ((1 << (tsqlParser.DYNAMIC - 269)) | (1 << (tsqlParser.FAST_FORWARD - 269)) | (1 << (tsqlParser.KEYSET - 269)))) != 0) or _la==tsqlParser.STATIC):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1998
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 350)) & ~0x3f) == 0 and ((1 << (_la - 350)) & ((1 << (tsqlParser.OPTIMISTIC - 350)) | (1 << (tsqlParser.READ_ONLY - 350)) | (1 << (tsqlParser.SCROLL_LOCKS - 350)))) != 0):
                self.state = 1997
                _la = self._input.LA(1)
                if not(((((_la - 350)) & ~0x3f) == 0 and ((1 << (_la - 350)) & ((1 << (tsqlParser.OPTIMISTIC - 350)) | (1 << (tsqlParser.READ_ONLY - 350)) | (1 << (tsqlParser.SCROLL_LOCKS - 350)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2001
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.TYPE_WARNING:
                self.state = 2000
                self.match(tsqlParser.TYPE_WARNING)


            self.state = 2003
            self.match(tsqlParser.FOR)
            self.state = 2004
            self.select_statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Fetch_cursorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FETCH(self):
            return self.getToken(tsqlParser.FETCH, 0)

        def cursor_name(self):
            return self.getTypedRuleContext(tsqlParser.Cursor_nameContext,0)


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

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

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

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

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

        def NEXT(self):
            return self.getToken(tsqlParser.NEXT, 0)

        def PRIOR(self):
            return self.getToken(tsqlParser.PRIOR, 0)

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

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

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


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

        def ABSOLUTE(self):
            return self.getToken(tsqlParser.ABSOLUTE, 0)

        def RELATIVE(self):
            return self.getToken(tsqlParser.RELATIVE, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_fetch_cursor




    def fetch_cursor(self):

        localctx = tsqlParser.Fetch_cursorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_fetch_cursor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2006
            self.match(tsqlParser.FETCH)
            self.state = 2016
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,295,self._ctx)
            if la_ == 1:
                self.state = 2013
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.NEXT]:
                    self.state = 2007
                    self.match(tsqlParser.NEXT)
                    pass
                elif token in [tsqlParser.PRIOR]:
                    self.state = 2008
                    self.match(tsqlParser.PRIOR)
                    pass
                elif token in [tsqlParser.FIRST]:
                    self.state = 2009
                    self.match(tsqlParser.FIRST)
                    pass
                elif token in [tsqlParser.LAST]:
                    self.state = 2010
                    self.match(tsqlParser.LAST)
                    pass
                elif token in [tsqlParser.ABSOLUTE, tsqlParser.RELATIVE]:
                    self.state = 2011
                    _la = self._input.LA(1)
                    if not(_la==tsqlParser.ABSOLUTE or _la==tsqlParser.RELATIVE):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2012
                    self.expression(0)
                    pass
                elif token in [tsqlParser.FROM]:
                    pass
                else:
                    pass
                self.state = 2015
                self.match(tsqlParser.FROM)


            self.state = 2019
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,296,self._ctx)
            if la_ == 1:
                self.state = 2018
                self.match(tsqlParser.GLOBAL)


            self.state = 2021
            self.cursor_name()
            self.state = 2031
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.INTO:
                self.state = 2022
                self.match(tsqlParser.INTO)
                self.state = 2023
                self.match(tsqlParser.LOCAL_ID)
                self.state = 2028
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 2024
                    self.match(tsqlParser.COMMA)
                    self.state = 2025
                    self.match(tsqlParser.LOCAL_ID)
                    self.state = 2030
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 2034
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,299,self._ctx)
            if la_ == 1:
                self.state = 2033
                self.match(tsqlParser.SEMI)


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


    class Set_specialContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def constant_LOCAL_ID(self):
            return self.getTypedRuleContext(tsqlParser.Constant_LOCAL_IDContext,0)


        def on_off(self):
            return self.getTypedRuleContext(tsqlParser.On_offContext,0)


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

        def ISOLATION(self):
            return self.getToken(tsqlParser.ISOLATION, 0)

        def LEVEL(self):
            return self.getToken(tsqlParser.LEVEL, 0)

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

        def READ(self):
            return self.getToken(tsqlParser.READ, 0)

        def UNCOMMITTED(self):
            return self.getToken(tsqlParser.UNCOMMITTED, 0)

        def COMMITTED(self):
            return self.getToken(tsqlParser.COMMITTED, 0)

        def REPEATABLE(self):
            return self.getToken(tsqlParser.REPEATABLE, 0)

        def SNAPSHOT(self):
            return self.getToken(tsqlParser.SNAPSHOT, 0)

        def SERIALIZABLE(self):
            return self.getToken(tsqlParser.SERIALIZABLE, 0)

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


        def IDENTITY_INSERT(self):
            return self.getToken(tsqlParser.IDENTITY_INSERT, 0)

        def ANSI_NULLS(self):
            return self.getToken(tsqlParser.ANSI_NULLS, 0)

        def QUOTED_IDENTIFIER(self):
            return self.getToken(tsqlParser.QUOTED_IDENTIFIER, 0)

        def ANSI_PADDING(self):
            return self.getToken(tsqlParser.ANSI_PADDING, 0)

        def STATISTICS(self):
            return self.getToken(tsqlParser.STATISTICS, 0)

        def TIME(self):
            return self.getToken(tsqlParser.TIME, 0)

        def IO(self):
            return self.getToken(tsqlParser.IO, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_set_special




    def set_special(self):

        localctx = tsqlParser.Set_specialContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_set_special)
        self._la = 0 # Token type
        try:
            self.state = 2083
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,305,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2036
                self.match(tsqlParser.SET)
                self.state = 2037
                localctx.key = self.r_id()
                self.state = 2041
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                    self.state = 2038
                    localctx.value = self.r_id()
                    pass
                elif token in [tsqlParser.LOCAL_ID, tsqlParser.DECIMAL, tsqlParser.STRING, tsqlParser.BINARY, tsqlParser.FLOAT, tsqlParser.REAL, tsqlParser.DOLLAR, tsqlParser.PLUS, tsqlParser.MINUS]:
                    self.state = 2039
                    self.constant_LOCAL_ID()
                    pass
                elif token in [tsqlParser.OFF, tsqlParser.ON]:
                    self.state = 2040
                    self.on_off()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2044
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,301,self._ctx)
                if la_ == 1:
                    self.state = 2043
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2046
                self.match(tsqlParser.SET)
                self.state = 2047
                localctx.set_type = self.match(tsqlParser.TRANSACTION)
                self.state = 2048
                self.match(tsqlParser.ISOLATION)
                self.state = 2049
                self.match(tsqlParser.LEVEL)
                self.state = 2058
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,302,self._ctx)
                if la_ == 1:
                    self.state = 2050
                    self.match(tsqlParser.READ)
                    self.state = 2051
                    self.match(tsqlParser.UNCOMMITTED)
                    pass

                elif la_ == 2:
                    self.state = 2052
                    self.match(tsqlParser.READ)
                    self.state = 2053
                    self.match(tsqlParser.COMMITTED)
                    pass

                elif la_ == 3:
                    self.state = 2054
                    self.match(tsqlParser.REPEATABLE)
                    self.state = 2055
                    self.match(tsqlParser.READ)
                    pass

                elif la_ == 4:
                    self.state = 2056
                    self.match(tsqlParser.SNAPSHOT)
                    pass

                elif la_ == 5:
                    self.state = 2057
                    self.match(tsqlParser.SERIALIZABLE)
                    pass


                self.state = 2061
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,303,self._ctx)
                if la_ == 1:
                    self.state = 2060
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2063
                self.match(tsqlParser.SET)
                self.state = 2064
                localctx.set_type = self.match(tsqlParser.IDENTITY_INSERT)
                self.state = 2065
                self.full_table_name()
                self.state = 2066
                self.on_off()
                self.state = 2068
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,304,self._ctx)
                if la_ == 1:
                    self.state = 2067
                    self.match(tsqlParser.SEMI)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2070
                self.match(tsqlParser.SET)
                self.state = 2071
                localctx.set_type = self.match(tsqlParser.ANSI_NULLS)
                self.state = 2072
                self.on_off()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2073
                self.match(tsqlParser.SET)
                self.state = 2074
                localctx.set_type = self.match(tsqlParser.QUOTED_IDENTIFIER)
                self.state = 2075
                self.on_off()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2076
                self.match(tsqlParser.SET)
                self.state = 2077
                localctx.set_type = self.match(tsqlParser.ANSI_PADDING)
                self.state = 2078
                self.on_off()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2079
                self.match(tsqlParser.SET)
                self.state = 2080
                localctx.set_type = self.match(tsqlParser.STATISTICS)
                self.state = 2081
                _la = self._input.LA(1)
                if not(_la==tsqlParser.IO or _la==tsqlParser.TIME):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2082
                self.on_off()
                pass


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


    class Constant_LOCAL_IDContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_constant_LOCAL_ID




    def constant_LOCAL_ID(self):

        localctx = tsqlParser.Constant_LOCAL_IDContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_constant_LOCAL_ID)
        try:
            self.state = 2087
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.DECIMAL, tsqlParser.STRING, tsqlParser.BINARY, tsqlParser.FLOAT, tsqlParser.REAL, tsqlParser.DOLLAR, tsqlParser.PLUS, tsqlParser.MINUS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2085
                self.constant()
                pass
            elif token in [tsqlParser.LOCAL_ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2086
                self.match(tsqlParser.LOCAL_ID)
                pass
            else:
                raise NoViableAltException(self)

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


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return tsqlParser.RULE_expression

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


    class Binary_operator_expressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.ExpressionContext
            super().__init__(parser)
            self.left = None # ExpressionContext
            self.op = None # Token
            self.right = None # ExpressionContext
            self.copyFrom(ctx)

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

        def STAR(self):
            return self.getToken(tsqlParser.STAR, 0)
        def DIVIDE(self):
            return self.getToken(tsqlParser.DIVIDE, 0)
        def MODULE(self):
            return self.getToken(tsqlParser.MODULE, 0)
        def PLUS(self):
            return self.getToken(tsqlParser.PLUS, 0)
        def MINUS(self):
            return self.getToken(tsqlParser.MINUS, 0)
        def BIT_AND(self):
            return self.getToken(tsqlParser.BIT_AND, 0)
        def BIT_XOR(self):
            return self.getToken(tsqlParser.BIT_XOR, 0)
        def BIT_OR(self):
            return self.getToken(tsqlParser.BIT_OR, 0)
        def comparison_operator(self):
            return self.getTypedRuleContext(tsqlParser.Comparison_operatorContext,0)



    class Unary_operator_expressionContext(ExpressionContext):

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

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

        def BIT_NOT(self):
            return self.getToken(tsqlParser.BIT_NOT, 0)
        def PLUS(self):
            return self.getToken(tsqlParser.PLUS, 0)
        def MINUS(self):
            return self.getToken(tsqlParser.MINUS, 0)


    class Function_call_expressionContext(ExpressionContext):

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

        def function_call(self):
            return self.getTypedRuleContext(tsqlParser.Function_callContext,0)

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

        def COLLATE(self):
            return self.getToken(tsqlParser.COLLATE, 0)
        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)



    class Conversion_expressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.ExpressionContext
            super().__init__(parser)
            self.left = None # ExpressionContext
            self.right = None # ExpressionContext
            self.copyFrom(ctx)

        def AT(self):
            return self.getToken(tsqlParser.AT, 0)
        def TIME(self):
            return self.getToken(tsqlParser.TIME, 0)
        def ZONE(self):
            return self.getToken(tsqlParser.ZONE, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.ExpressionContext,i)



    class Case_expressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.ExpressionContext
            super().__init__(parser)
            self.caseExpr = None # ExpressionContext
            self.elseExpr = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(tsqlParser.CASE, 0)
        def END(self):
            return self.getToken(tsqlParser.END, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.ExpressionContext,i)

        def switch_section(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Switch_sectionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Switch_sectionContext,i)

        def ELSE(self):
            return self.getToken(tsqlParser.ELSE, 0)
        def switch_search_condition_section(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Switch_search_condition_sectionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Switch_search_condition_sectionContext,i)



    class Column_ref_expressionContext(ExpressionContext):

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

        def full_column_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_column_nameContext,0)



    class String_agg_expressionContext(ExpressionContext):

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

        def string_agg(self):
            return self.getTypedRuleContext(tsqlParser.String_aggContext,0)



    class Percentile_cont_expressionContext(ExpressionContext):

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

        def percentile_cont(self):
            return self.getTypedRuleContext(tsqlParser.Percentile_contContext,0)



    class Primitive_expressionContext(ExpressionContext):

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

        def DEFAULT(self):
            return self.getToken(tsqlParser.DEFAULT, 0)
        def NULL_(self):
            return self.getToken(tsqlParser.NULL_, 0)
        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)
        def constant(self):
            return self.getTypedRuleContext(tsqlParser.ConstantContext,0)



    class Bracket_expressionContext(ExpressionContext):

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

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def expression(self):
            return self.getTypedRuleContext(tsqlParser.ExpressionContext,0)

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


    class Subquery_expressionContext(ExpressionContext):

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

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def subquery(self):
            return self.getTypedRuleContext(tsqlParser.SubqueryContext,0)

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


    class Over_clause_expressionContext(ExpressionContext):

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

        def over_clause(self):
            return self.getTypedRuleContext(tsqlParser.Over_clauseContext,0)



    class Xml_method_expressionContext(ExpressionContext):

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

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

        def DOT(self):
            return self.getToken(tsqlParser.DOT, 0)
        def xml_method_call(self):
            return self.getTypedRuleContext(tsqlParser.Xml_method_callContext,0)




    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = tsqlParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 208
        self.enterRecursionRule(localctx, 208, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2136
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,311,self._ctx)
            if la_ == 1:
                localctx = tsqlParser.Primitive_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2090
                self.match(tsqlParser.DEFAULT)
                pass

            elif la_ == 2:
                localctx = tsqlParser.Primitive_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2091
                self.match(tsqlParser.NULL_)
                pass

            elif la_ == 3:
                localctx = tsqlParser.Primitive_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2092
                self.match(tsqlParser.LOCAL_ID)
                pass

            elif la_ == 4:
                localctx = tsqlParser.Primitive_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2093
                self.constant()
                pass

            elif la_ == 5:
                localctx = tsqlParser.Function_call_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2094
                self.function_call()
                pass

            elif la_ == 6:
                localctx = tsqlParser.Case_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2095
                self.match(tsqlParser.CASE)
                self.state = 2096
                localctx.caseExpr = self.expression(0)
                self.state = 2098 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2097
                    self.switch_section()
                    self.state = 2100 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==tsqlParser.WHEN):
                        break

                self.state = 2104
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ELSE:
                    self.state = 2102
                    self.match(tsqlParser.ELSE)
                    self.state = 2103
                    localctx.elseExpr = self.expression(0)


                self.state = 2106
                self.match(tsqlParser.END)
                pass

            elif la_ == 7:
                localctx = tsqlParser.Case_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2108
                self.match(tsqlParser.CASE)
                self.state = 2110 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2109
                    self.switch_search_condition_section()
                    self.state = 2112 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==tsqlParser.WHEN):
                        break

                self.state = 2116
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ELSE:
                    self.state = 2114
                    self.match(tsqlParser.ELSE)
                    self.state = 2115
                    localctx.elseExpr = self.expression(0)


                self.state = 2118
                self.match(tsqlParser.END)
                pass

            elif la_ == 8:
                localctx = tsqlParser.Column_ref_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2120
                self.full_column_name()
                pass

            elif la_ == 9:
                localctx = tsqlParser.Bracket_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2121
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2122
                self.expression(0)
                self.state = 2123
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 10:
                localctx = tsqlParser.Subquery_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2125
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2126
                self.subquery()
                self.state = 2127
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 11:
                localctx = tsqlParser.Unary_operator_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2129
                localctx.op = self.match(tsqlParser.BIT_NOT)
                self.state = 2130
                self.expression(9)
                pass

            elif la_ == 12:
                localctx = tsqlParser.Unary_operator_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2131
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.PLUS or _la==tsqlParser.MINUS):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2132
                self.expression(7)
                pass

            elif la_ == 13:
                localctx = tsqlParser.Over_clause_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2133
                self.over_clause()
                pass

            elif la_ == 14:
                localctx = tsqlParser.Percentile_cont_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2134
                self.percentile_cont()
                pass

            elif la_ == 15:
                localctx = tsqlParser.String_agg_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2135
                self.string_agg()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 2161
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,313,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 2159
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,312,self._ctx)
                    if la_ == 1:
                        localctx = tsqlParser.Conversion_expressionContext(self, tsqlParser.ExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 2138
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 2139
                        self.match(tsqlParser.AT)
                        self.state = 2140
                        self.match(tsqlParser.TIME)
                        self.state = 2141
                        self.match(tsqlParser.ZONE)
                        self.state = 2142
                        localctx.right = self.expression(16)
                        pass

                    elif la_ == 2:
                        localctx = tsqlParser.Binary_operator_expressionContext(self, tsqlParser.ExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 2143
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 2144
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 477)) & ~0x3f) == 0 and ((1 << (_la - 477)) & ((1 << (tsqlParser.STAR - 477)) | (1 << (tsqlParser.DIVIDE - 477)) | (1 << (tsqlParser.MODULE - 477)))) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2145
                        localctx.right = self.expression(9)
                        pass

                    elif la_ == 3:
                        localctx = tsqlParser.Binary_operator_expressionContext(self, tsqlParser.ExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 2146
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 2147
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 480)) & ~0x3f) == 0 and ((1 << (_la - 480)) & ((1 << (tsqlParser.PLUS - 480)) | (1 << (tsqlParser.MINUS - 480)) | (1 << (tsqlParser.BIT_OR - 480)) | (1 << (tsqlParser.BIT_AND - 480)) | (1 << (tsqlParser.BIT_XOR - 480)))) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2148
                        localctx.right = self.expression(7)
                        pass

                    elif la_ == 4:
                        localctx = tsqlParser.Binary_operator_expressionContext(self, tsqlParser.ExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 2149
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 2150
                        self.comparison_operator()
                        self.state = 2151
                        localctx.right = self.expression(6)
                        pass

                    elif la_ == 5:
                        localctx = tsqlParser.Function_call_expressionContext(self, tsqlParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 2153
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 2154
                        self.match(tsqlParser.COLLATE)
                        self.state = 2155
                        self.r_id()
                        pass

                    elif la_ == 6:
                        localctx = tsqlParser.Xml_method_expressionContext(self, tsqlParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 2156
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 2157
                        self.match(tsqlParser.DOT)
                        self.state = 2158
                        self.xml_method_call()
                        pass

             
                self.state = 2163
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,313,self._ctx)

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


    class Xml_method_callContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def simple_xml_method_name(self):
            return self.getTypedRuleContext(tsqlParser.Simple_xml_method_nameContext,0)


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

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

        def expression_list(self):
            return self.getTypedRuleContext(tsqlParser.Expression_listContext,0)


        def NODES(self):
            return self.getToken(tsqlParser.NODES, 0)

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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def getRuleIndex(self):
            return tsqlParser.RULE_xml_method_call




    def xml_method_call(self):

        localctx = tsqlParser.Xml_method_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_xml_method_call)
        self._la = 0 # Token type
        try:
            self.state = 2183
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.VALUE, tsqlParser.EXIST, tsqlParser.QUERY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2164
                self.simple_xml_method_name()
                self.state = 2165
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2167
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << tsqlParser.CASE) | (1 << tsqlParser.COALESCE) | (1 << tsqlParser.CONVERT) | (1 << tsqlParser.CURRENT_TIMESTAMP) | (1 << tsqlParser.CURRENT_USER) | (1 << tsqlParser.DEFAULT))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (tsqlParser.EXP - 66)) | (1 << (tsqlParser.FILLFACTOR - 66)) | (1 << (tsqlParser.FORCESEEK - 66)) | (1 << (tsqlParser.IDENTITY - 66)) | (1 << (tsqlParser.IIF - 66)) | (1 << (tsqlParser.LEFT - 66)) | (1 << (tsqlParser.LOG - 66)) | (1 << (tsqlParser.LOG10 - 66)) | (1 << (tsqlParser.NEXT - 66)) | (1 << (tsqlParser.NULL_ - 66)) | (1 << (tsqlParser.NULLIF - 66)) | (1 << (tsqlParser.NUMERIC - 66)) | (1 << (tsqlParser.OVER - 66)))) != 0) or ((((_la - 152)) & ~0x3f) == 0 and ((1 << (_la - 152)) & ((1 << (tsqlParser.RIGHT - 152)) | (1 << (tsqlParser.SESSION_USER - 152)) | (1 << (tsqlParser.SIGN - 152)) | (1 << (tsqlParser.SYSTEM_USER - 152)) | (1 << (tsqlParser.TRY_CAST - 152)) | (1 << (tsqlParser.TRY_CONVERT - 152)) | (1 << (tsqlParser.TRY_PARSE - 152)) | (1 << (tsqlParser.VALUE - 152)) | (1 << (tsqlParser.ABSOLUTE - 152)) | (1 << (tsqlParser.APPLY - 152)))) != 0) or ((((_la - 217)) & ~0x3f) == 0 and ((1 << (_la - 217)) & ((1 << (tsqlParser.AUTO - 217)) | (1 << (tsqlParser.AVG - 217)) | (1 << (tsqlParser.BASE64 - 217)) | (1 << (tsqlParser.BINARY_CHECKSUM - 217)) | (1 << (tsqlParser.CALLER - 217)) | (1 << (tsqlParser.CAST - 217)) | (1 << (tsqlParser.CATCH - 217)) | (1 << (tsqlParser.CEILING - 217)) | (1 << (tsqlParser.CHECKSUM - 217)) | (1 << (tsqlParser.CHECKSUM_AGG - 217)) | (1 << (tsqlParser.COMMITTED - 217)) | (1 << (tsqlParser.CONCAT - 217)) | (1 << (tsqlParser.CONTROL - 217)) | (1 << (tsqlParser.COOKIE - 217)) | (1 << (tsqlParser.COS - 217)) | (1 << (tsqlParser.COUNT - 217)) | (1 << (tsqlParser.COUNT_BIG - 217)) | (1 << (tsqlParser.DATE - 217)) | (1 << (tsqlParser.DATEADD - 217)) | (1 << (tsqlParser.DATEDIFF - 217)) | (1 << (tsqlParser.DATENAME - 217)) | (1 << (tsqlParser.DATEPART - 217)) | (1 << (tsqlParser.DATETIMEOFFSETFROMPARTS - 217)) | (1 << (tsqlParser.DELAY - 217)) | (1 << (tsqlParser.DELETED - 217)) | (1 << (tsqlParser.DENSE_RANK - 217)) | (1 << (tsqlParser.DISABLE - 217)) | (1 << (tsqlParser.DYNAMIC - 217)) | (1 << (tsqlParser.ENCRYPTION - 217)) | (1 << (tsqlParser.EXIST - 217)) | (1 << (tsqlParser.EXPAND - 217)) | (1 << (tsqlParser.FAST - 217)) | (1 << (tsqlParser.FAST_FORWARD - 217)))) != 0) or ((((_la - 281)) & ~0x3f) == 0 and ((1 << (_la - 281)) & ((1 << (tsqlParser.FIRST - 281)) | (1 << (tsqlParser.FIRST_VALUE - 281)) | (1 << (tsqlParser.FLOOR - 281)) | (1 << (tsqlParser.FOLLOWING - 281)) | (1 << (tsqlParser.FORCE - 281)) | (1 << (tsqlParser.FORCED - 281)) | (1 << (tsqlParser.FORWARD_ONLY - 281)) | (1 << (tsqlParser.FULLSCAN - 281)) | (1 << (tsqlParser.GLOBAL - 281)) | (1 << (tsqlParser.GROUPING - 281)) | (1 << (tsqlParser.GROUPING_ID - 281)) | (1 << (tsqlParser.HASH - 281)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 281)) | (1 << (tsqlParser.IMPERSONATE - 281)) | (1 << (tsqlParser.INSENSITIVE - 281)) | (1 << (tsqlParser.INSERTED - 281)) | (1 << (tsqlParser.ISOLATION - 281)) | (1 << (tsqlParser.IO - 281)) | (1 << (tsqlParser.KEEP - 281)) | (1 << (tsqlParser.KEEPFIXED - 281)) | (1 << (tsqlParser.KEYSET - 281)) | (1 << (tsqlParser.LAG - 281)) | (1 << (tsqlParser.LAST - 281)) | (1 << (tsqlParser.LAST_VALUE - 281)) | (1 << (tsqlParser.LEAD - 281)) | (1 << (tsqlParser.LEVEL - 281)) | (1 << (tsqlParser.LOCAL - 281)) | (1 << (tsqlParser.LOCK_ESCALATION - 281)) | (1 << (tsqlParser.LOGIN - 281)) | (1 << (tsqlParser.LOOP - 281)) | (1 << (tsqlParser.MARK - 281)) | (1 << (tsqlParser.MAX - 281)) | (1 << (tsqlParser.MAXDOP - 281)) | (1 << (tsqlParser.MAXRECURSION - 281)) | (1 << (tsqlParser.MIN - 281)) | (1 << (tsqlParser.MIN_ACTIVE_ROWVERSION - 281)) | (1 << (tsqlParser.MODIFY - 281)) | (1 << (tsqlParser.NAME - 281)) | (1 << (tsqlParser.NOCOUNT - 281)) | (1 << (tsqlParser.NODES - 281)) | (1 << (tsqlParser.NOEXPAND - 281)) | (1 << (tsqlParser.NORECOMPUTE - 281)) | (1 << (tsqlParser.NTILE - 281)) | (1 << (tsqlParser.NUMBER - 281)))) != 0) or ((((_la - 347)) & ~0x3f) == 0 and ((1 << (_la - 347)) & ((1 << (tsqlParser.OFFSET - 347)) | (1 << (tsqlParser.ONLINE - 347)) | (1 << (tsqlParser.ONLY - 347)) | (1 << (tsqlParser.OPTIMISTIC - 347)) | (1 << (tsqlParser.OPTIMIZE - 347)) | (1 << (tsqlParser.OUT - 347)) | (1 << (tsqlParser.OUTPUT - 347)) | (1 << (tsqlParser.OWNER - 347)) | (1 << (tsqlParser.PARAMETERIZATION - 347)) | (1 << (tsqlParser.PARSE - 347)) | (1 << (tsqlParser.PARTITION - 347)) | (1 << (tsqlParser.PATH - 347)) | (1 << (tsqlParser.PERCENTILE_CONT - 347)) | (1 << (tsqlParser.POWER - 347)) | (1 << (tsqlParser.PRECEDING - 347)) | (1 << (tsqlParser.PRIOR - 347)) | (1 << (tsqlParser.PRIVILEGES - 347)) | (1 << (tsqlParser.QUERY - 347)) | (1 << (tsqlParser.RANGE - 347)) | (1 << (tsqlParser.RANK - 347)) | (1 << (tsqlParser.READONLY - 347)) | (1 << (tsqlParser.READ_ONLY - 347)) | (1 << (tsqlParser.RECOMPILE - 347)) | (1 << (tsqlParser.RELATIVE - 347)) | (1 << (tsqlParser.REMOTE - 347)) | (1 << (tsqlParser.REPEATABLE - 347)) | (1 << (tsqlParser.ROBUST - 347)) | (1 << (tsqlParser.ROOT - 347)) | (1 << (tsqlParser.ROUND - 347)) | (1 << (tsqlParser.ROW - 347)) | (1 << (tsqlParser.ROWGUID - 347)) | (1 << (tsqlParser.ROWS - 347)) | (1 << (tsqlParser.ROW_NUMBER - 347)) | (1 << (tsqlParser.SAMPLE - 347)) | (1 << (tsqlParser.SCHEMABINDING - 347)) | (1 << (tsqlParser.SCROLL - 347)) | (1 << (tsqlParser.SCROLL_LOCKS - 347)) | (1 << (tsqlParser.SELF - 347)) | (1 << (tsqlParser.SERIALIZABLE - 347)) | (1 << (tsqlParser.SIMPLE - 347)) | (1 << (tsqlParser.SIN - 347)) | (1 << (tsqlParser.SIZE - 347)) | (1 << (tsqlParser.SNAPSHOT - 347)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 347)) | (1 << (tsqlParser.STATIC - 347)) | (1 << (tsqlParser.STATS_STREAM - 347)) | (1 << (tsqlParser.STDEV - 347)) | (1 << (tsqlParser.STDEVP - 347)) | (1 << (tsqlParser.STRING_AGG - 347)) | (1 << (tsqlParser.STRING_SPLIT - 347)) | (1 << (tsqlParser.SUM - 347)))) != 0) or ((((_la - 411)) & ~0x3f) == 0 and ((1 << (_la - 411)) & ((1 << (tsqlParser.SQRT - 411)) | (1 << (tsqlParser.SQUARE - 411)) | (1 << (tsqlParser.TAN - 411)) | (1 << (tsqlParser.TEXTIMAGE_ON - 411)) | (1 << (tsqlParser.THROW - 411)) | (1 << (tsqlParser.TIES - 411)) | (1 << (tsqlParser.TIME - 411)) | (1 << (tsqlParser.TRY - 411)) | (1 << (tsqlParser.TYPE - 411)) | (1 << (tsqlParser.TYPE_WARNING - 411)) | (1 << (tsqlParser.UNBOUNDED - 411)) | (1 << (tsqlParser.UNCOMMITTED - 411)) | (1 << (tsqlParser.UNKNOWN - 411)) | (1 << (tsqlParser.USING - 411)) | (1 << (tsqlParser.VAR - 411)) | (1 << (tsqlParser.VARP - 411)) | (1 << (tsqlParser.VIEWS - 411)) | (1 << (tsqlParser.VIEW_METADATA - 411)) | (1 << (tsqlParser.WORK - 411)) | (1 << (tsqlParser.XML - 411)) | (1 << (tsqlParser.XMLNAMESPACES - 411)) | (1 << (tsqlParser.ZONE - 411)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 411)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 411)) | (1 << (tsqlParser.LOCAL_ID - 411)) | (1 << (tsqlParser.DECIMAL - 411)) | (1 << (tsqlParser.ID - 411)) | (1 << (tsqlParser.STRING - 411)) | (1 << (tsqlParser.BINARY - 411)) | (1 << (tsqlParser.FLOAT - 411)) | (1 << (tsqlParser.REAL - 411)) | (1 << (tsqlParser.DOLLAR - 411)) | (1 << (tsqlParser.LR_BRACKET - 411)))) != 0) or ((((_la - 480)) & ~0x3f) == 0 and ((1 << (_la - 480)) & ((1 << (tsqlParser.PLUS - 480)) | (1 << (tsqlParser.MINUS - 480)) | (1 << (tsqlParser.BIT_NOT - 480)))) != 0):
                    self.state = 2166
                    self.expression_list()


                self.state = 2169
                self.match(tsqlParser.RR_BRACKET)
                pass
            elif token in [tsqlParser.NODES]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2171
                self.match(tsqlParser.NODES)
                self.state = 2172
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2174
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << tsqlParser.CASE) | (1 << tsqlParser.COALESCE) | (1 << tsqlParser.CONVERT) | (1 << tsqlParser.CURRENT_TIMESTAMP) | (1 << tsqlParser.CURRENT_USER) | (1 << tsqlParser.DEFAULT))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (tsqlParser.EXP - 66)) | (1 << (tsqlParser.FILLFACTOR - 66)) | (1 << (tsqlParser.FORCESEEK - 66)) | (1 << (tsqlParser.IDENTITY - 66)) | (1 << (tsqlParser.IIF - 66)) | (1 << (tsqlParser.LEFT - 66)) | (1 << (tsqlParser.LOG - 66)) | (1 << (tsqlParser.LOG10 - 66)) | (1 << (tsqlParser.NEXT - 66)) | (1 << (tsqlParser.NULL_ - 66)) | (1 << (tsqlParser.NULLIF - 66)) | (1 << (tsqlParser.NUMERIC - 66)) | (1 << (tsqlParser.OVER - 66)))) != 0) or ((((_la - 152)) & ~0x3f) == 0 and ((1 << (_la - 152)) & ((1 << (tsqlParser.RIGHT - 152)) | (1 << (tsqlParser.SESSION_USER - 152)) | (1 << (tsqlParser.SIGN - 152)) | (1 << (tsqlParser.SYSTEM_USER - 152)) | (1 << (tsqlParser.TRY_CAST - 152)) | (1 << (tsqlParser.TRY_CONVERT - 152)) | (1 << (tsqlParser.TRY_PARSE - 152)) | (1 << (tsqlParser.VALUE - 152)) | (1 << (tsqlParser.ABSOLUTE - 152)) | (1 << (tsqlParser.APPLY - 152)))) != 0) or ((((_la - 217)) & ~0x3f) == 0 and ((1 << (_la - 217)) & ((1 << (tsqlParser.AUTO - 217)) | (1 << (tsqlParser.AVG - 217)) | (1 << (tsqlParser.BASE64 - 217)) | (1 << (tsqlParser.BINARY_CHECKSUM - 217)) | (1 << (tsqlParser.CALLER - 217)) | (1 << (tsqlParser.CAST - 217)) | (1 << (tsqlParser.CATCH - 217)) | (1 << (tsqlParser.CEILING - 217)) | (1 << (tsqlParser.CHECKSUM - 217)) | (1 << (tsqlParser.CHECKSUM_AGG - 217)) | (1 << (tsqlParser.COMMITTED - 217)) | (1 << (tsqlParser.CONCAT - 217)) | (1 << (tsqlParser.CONTROL - 217)) | (1 << (tsqlParser.COOKIE - 217)) | (1 << (tsqlParser.COS - 217)) | (1 << (tsqlParser.COUNT - 217)) | (1 << (tsqlParser.COUNT_BIG - 217)) | (1 << (tsqlParser.DATE - 217)) | (1 << (tsqlParser.DATEADD - 217)) | (1 << (tsqlParser.DATEDIFF - 217)) | (1 << (tsqlParser.DATENAME - 217)) | (1 << (tsqlParser.DATEPART - 217)) | (1 << (tsqlParser.DATETIMEOFFSETFROMPARTS - 217)) | (1 << (tsqlParser.DELAY - 217)) | (1 << (tsqlParser.DELETED - 217)) | (1 << (tsqlParser.DENSE_RANK - 217)) | (1 << (tsqlParser.DISABLE - 217)) | (1 << (tsqlParser.DYNAMIC - 217)) | (1 << (tsqlParser.ENCRYPTION - 217)) | (1 << (tsqlParser.EXIST - 217)) | (1 << (tsqlParser.EXPAND - 217)) | (1 << (tsqlParser.FAST - 217)) | (1 << (tsqlParser.FAST_FORWARD - 217)))) != 0) or ((((_la - 281)) & ~0x3f) == 0 and ((1 << (_la - 281)) & ((1 << (tsqlParser.FIRST - 281)) | (1 << (tsqlParser.FIRST_VALUE - 281)) | (1 << (tsqlParser.FLOOR - 281)) | (1 << (tsqlParser.FOLLOWING - 281)) | (1 << (tsqlParser.FORCE - 281)) | (1 << (tsqlParser.FORCED - 281)) | (1 << (tsqlParser.FORWARD_ONLY - 281)) | (1 << (tsqlParser.FULLSCAN - 281)) | (1 << (tsqlParser.GLOBAL - 281)) | (1 << (tsqlParser.GROUPING - 281)) | (1 << (tsqlParser.GROUPING_ID - 281)) | (1 << (tsqlParser.HASH - 281)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 281)) | (1 << (tsqlParser.IMPERSONATE - 281)) | (1 << (tsqlParser.INSENSITIVE - 281)) | (1 << (tsqlParser.INSERTED - 281)) | (1 << (tsqlParser.ISOLATION - 281)) | (1 << (tsqlParser.IO - 281)) | (1 << (tsqlParser.KEEP - 281)) | (1 << (tsqlParser.KEEPFIXED - 281)) | (1 << (tsqlParser.KEYSET - 281)) | (1 << (tsqlParser.LAG - 281)) | (1 << (tsqlParser.LAST - 281)) | (1 << (tsqlParser.LAST_VALUE - 281)) | (1 << (tsqlParser.LEAD - 281)) | (1 << (tsqlParser.LEVEL - 281)) | (1 << (tsqlParser.LOCAL - 281)) | (1 << (tsqlParser.LOCK_ESCALATION - 281)) | (1 << (tsqlParser.LOGIN - 281)) | (1 << (tsqlParser.LOOP - 281)) | (1 << (tsqlParser.MARK - 281)) | (1 << (tsqlParser.MAX - 281)) | (1 << (tsqlParser.MAXDOP - 281)) | (1 << (tsqlParser.MAXRECURSION - 281)) | (1 << (tsqlParser.MIN - 281)) | (1 << (tsqlParser.MIN_ACTIVE_ROWVERSION - 281)) | (1 << (tsqlParser.MODIFY - 281)) | (1 << (tsqlParser.NAME - 281)) | (1 << (tsqlParser.NOCOUNT - 281)) | (1 << (tsqlParser.NODES - 281)) | (1 << (tsqlParser.NOEXPAND - 281)) | (1 << (tsqlParser.NORECOMPUTE - 281)) | (1 << (tsqlParser.NTILE - 281)) | (1 << (tsqlParser.NUMBER - 281)))) != 0) or ((((_la - 347)) & ~0x3f) == 0 and ((1 << (_la - 347)) & ((1 << (tsqlParser.OFFSET - 347)) | (1 << (tsqlParser.ONLINE - 347)) | (1 << (tsqlParser.ONLY - 347)) | (1 << (tsqlParser.OPTIMISTIC - 347)) | (1 << (tsqlParser.OPTIMIZE - 347)) | (1 << (tsqlParser.OUT - 347)) | (1 << (tsqlParser.OUTPUT - 347)) | (1 << (tsqlParser.OWNER - 347)) | (1 << (tsqlParser.PARAMETERIZATION - 347)) | (1 << (tsqlParser.PARSE - 347)) | (1 << (tsqlParser.PARTITION - 347)) | (1 << (tsqlParser.PATH - 347)) | (1 << (tsqlParser.PERCENTILE_CONT - 347)) | (1 << (tsqlParser.POWER - 347)) | (1 << (tsqlParser.PRECEDING - 347)) | (1 << (tsqlParser.PRIOR - 347)) | (1 << (tsqlParser.PRIVILEGES - 347)) | (1 << (tsqlParser.QUERY - 347)) | (1 << (tsqlParser.RANGE - 347)) | (1 << (tsqlParser.RANK - 347)) | (1 << (tsqlParser.READONLY - 347)) | (1 << (tsqlParser.READ_ONLY - 347)) | (1 << (tsqlParser.RECOMPILE - 347)) | (1 << (tsqlParser.RELATIVE - 347)) | (1 << (tsqlParser.REMOTE - 347)) | (1 << (tsqlParser.REPEATABLE - 347)) | (1 << (tsqlParser.ROBUST - 347)) | (1 << (tsqlParser.ROOT - 347)) | (1 << (tsqlParser.ROUND - 347)) | (1 << (tsqlParser.ROW - 347)) | (1 << (tsqlParser.ROWGUID - 347)) | (1 << (tsqlParser.ROWS - 347)) | (1 << (tsqlParser.ROW_NUMBER - 347)) | (1 << (tsqlParser.SAMPLE - 347)) | (1 << (tsqlParser.SCHEMABINDING - 347)) | (1 << (tsqlParser.SCROLL - 347)) | (1 << (tsqlParser.SCROLL_LOCKS - 347)) | (1 << (tsqlParser.SELF - 347)) | (1 << (tsqlParser.SERIALIZABLE - 347)) | (1 << (tsqlParser.SIMPLE - 347)) | (1 << (tsqlParser.SIN - 347)) | (1 << (tsqlParser.SIZE - 347)) | (1 << (tsqlParser.SNAPSHOT - 347)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 347)) | (1 << (tsqlParser.STATIC - 347)) | (1 << (tsqlParser.STATS_STREAM - 347)) | (1 << (tsqlParser.STDEV - 347)) | (1 << (tsqlParser.STDEVP - 347)) | (1 << (tsqlParser.STRING_AGG - 347)) | (1 << (tsqlParser.STRING_SPLIT - 347)) | (1 << (tsqlParser.SUM - 347)))) != 0) or ((((_la - 411)) & ~0x3f) == 0 and ((1 << (_la - 411)) & ((1 << (tsqlParser.SQRT - 411)) | (1 << (tsqlParser.SQUARE - 411)) | (1 << (tsqlParser.TAN - 411)) | (1 << (tsqlParser.TEXTIMAGE_ON - 411)) | (1 << (tsqlParser.THROW - 411)) | (1 << (tsqlParser.TIES - 411)) | (1 << (tsqlParser.TIME - 411)) | (1 << (tsqlParser.TRY - 411)) | (1 << (tsqlParser.TYPE - 411)) | (1 << (tsqlParser.TYPE_WARNING - 411)) | (1 << (tsqlParser.UNBOUNDED - 411)) | (1 << (tsqlParser.UNCOMMITTED - 411)) | (1 << (tsqlParser.UNKNOWN - 411)) | (1 << (tsqlParser.USING - 411)) | (1 << (tsqlParser.VAR - 411)) | (1 << (tsqlParser.VARP - 411)) | (1 << (tsqlParser.VIEWS - 411)) | (1 << (tsqlParser.VIEW_METADATA - 411)) | (1 << (tsqlParser.WORK - 411)) | (1 << (tsqlParser.XML - 411)) | (1 << (tsqlParser.XMLNAMESPACES - 411)) | (1 << (tsqlParser.ZONE - 411)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 411)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 411)) | (1 << (tsqlParser.LOCAL_ID - 411)) | (1 << (tsqlParser.DECIMAL - 411)) | (1 << (tsqlParser.ID - 411)) | (1 << (tsqlParser.STRING - 411)) | (1 << (tsqlParser.BINARY - 411)) | (1 << (tsqlParser.FLOAT - 411)) | (1 << (tsqlParser.REAL - 411)) | (1 << (tsqlParser.DOLLAR - 411)) | (1 << (tsqlParser.LR_BRACKET - 411)))) != 0) or ((((_la - 480)) & ~0x3f) == 0 and ((1 << (_la - 480)) & ((1 << (tsqlParser.PLUS - 480)) | (1 << (tsqlParser.MINUS - 480)) | (1 << (tsqlParser.BIT_NOT - 480)))) != 0):
                    self.state = 2173
                    self.expression_list()


                self.state = 2176
                self.match(tsqlParser.RR_BRACKET)
                self.state = 2177
                self.match(tsqlParser.AS)
                self.state = 2178
                localctx.table = self.r_id()
                self.state = 2179
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2180
                localctx.column = self.r_id()
                self.state = 2181
                self.match(tsqlParser.RR_BRACKET)
                pass
            else:
                raise NoViableAltException(self)

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


    class Simple_xml_method_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def QUERY(self):
            return self.getToken(tsqlParser.QUERY, 0)

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

        def EXIST(self):
            return self.getToken(tsqlParser.EXIST, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_simple_xml_method_name




    def simple_xml_method_name(self):

        localctx = tsqlParser.Simple_xml_method_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_simple_xml_method_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2185
            _la = self._input.LA(1)
            if not(_la==tsqlParser.VALUE or _la==tsqlParser.EXIST or _la==tsqlParser.QUERY):
                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 Constant_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NULL_(self):
            return self.getToken(tsqlParser.NULL_, 0)

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


        def function_call(self):
            return self.getTypedRuleContext(tsqlParser.Function_callContext,0)


        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

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

        def constant_expression(self):
            return self.getTypedRuleContext(tsqlParser.Constant_expressionContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_constant_expression




    def constant_expression(self):

        localctx = tsqlParser.Constant_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_constant_expression)
        try:
            self.state = 2195
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.NULL_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2187
                self.match(tsqlParser.NULL_)
                pass
            elif token in [tsqlParser.DECIMAL, tsqlParser.STRING, tsqlParser.BINARY, tsqlParser.FLOAT, tsqlParser.REAL, tsqlParser.DOLLAR, tsqlParser.PLUS, tsqlParser.MINUS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2188
                self.constant()
                pass
            elif token in [tsqlParser.COALESCE, tsqlParser.CONVERT, tsqlParser.CURRENT_TIMESTAMP, tsqlParser.CURRENT_USER, tsqlParser.EXP, tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.IDENTITY, tsqlParser.IIF, tsqlParser.LEFT, tsqlParser.LOG, tsqlParser.LOG10, tsqlParser.NEXT, tsqlParser.NULLIF, tsqlParser.NUMERIC, tsqlParser.RIGHT, tsqlParser.SESSION_USER, tsqlParser.SIGN, tsqlParser.SYSTEM_USER, tsqlParser.TRY_CAST, tsqlParser.TRY_CONVERT, tsqlParser.TRY_PARSE, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.BINARY_CHECKSUM, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CEILING, tsqlParser.CHECKSUM, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COS, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DATEADD, tsqlParser.DATEDIFF, tsqlParser.DATENAME, tsqlParser.DATEPART, tsqlParser.DATETIMEOFFSETFROMPARTS, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FLOOR, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MIN_ACTIVE_ROWVERSION, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARSE, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.POWER, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROUND, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIN, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.STRING_SPLIT, tsqlParser.SUM, tsqlParser.SQRT, tsqlParser.SQUARE, tsqlParser.TAN, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2189
                self.function_call()
                pass
            elif token in [tsqlParser.LOCAL_ID]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2190
                self.match(tsqlParser.LOCAL_ID)
                pass
            elif token in [tsqlParser.LR_BRACKET]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2191
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2192
                self.constant_expression()
                self.state = 2193
                self.match(tsqlParser.RR_BRACKET)
                pass
            else:
                raise NoViableAltException(self)

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


    class SubqueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def select_statement(self):
            return self.getTypedRuleContext(tsqlParser.Select_statementContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_subquery




    def subquery(self):

        localctx = tsqlParser.SubqueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_subquery)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2197
            self.select_statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class With_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def common_table_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Common_table_expressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Common_table_expressionContext,i)


        def XMLNAMESPACES(self):
            return self.getToken(tsqlParser.XMLNAMESPACES, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_with_expression




    def with_expression(self):

        localctx = tsqlParser.With_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_with_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2199
            self.match(tsqlParser.WITH)
            self.state = 2202
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,318,self._ctx)
            if la_ == 1:
                self.state = 2200
                self.match(tsqlParser.XMLNAMESPACES)
                self.state = 2201
                self.match(tsqlParser.COMMA)


            self.state = 2204
            self.common_table_expression()
            self.state = 2209
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 2205
                self.match(tsqlParser.COMMA)
                self.state = 2206
                self.common_table_expression()
                self.state = 2211
                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 Common_table_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def select_statement(self):
            return self.getTypedRuleContext(tsqlParser.Select_statementContext,0)


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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def column_name_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_name_listContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_common_table_expression




    def common_table_expression(self):

        localctx = tsqlParser.Common_table_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_common_table_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2212
            localctx.expression_name = self.r_id()
            self.state = 2217
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.LR_BRACKET:
                self.state = 2213
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2214
                self.column_name_list()
                self.state = 2215
                self.match(tsqlParser.RR_BRACKET)


            self.state = 2219
            self.match(tsqlParser.AS)
            self.state = 2220
            self.match(tsqlParser.LR_BRACKET)
            self.state = 2221
            self.select_statement()
            self.state = 2222
            self.match(tsqlParser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Update_elemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def full_column_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_column_nameContext,0)


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

        def assignment_operator(self):
            return self.getTypedRuleContext(tsqlParser.Assignment_operatorContext,0)


        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

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

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

        def expression_list(self):
            return self.getTypedRuleContext(tsqlParser.Expression_listContext,0)


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

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def getRuleIndex(self):
            return tsqlParser.RULE_update_elem




    def update_elem(self):

        localctx = tsqlParser.Update_elemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_update_elem)
        try:
            self.state = 2240
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,323,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2226
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                    self.state = 2224
                    self.full_column_name()
                    pass
                elif token in [tsqlParser.LOCAL_ID]:
                    self.state = 2225
                    localctx.name = self.match(tsqlParser.LOCAL_ID)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2230
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.EQUAL]:
                    self.state = 2228
                    self.match(tsqlParser.EQUAL)
                    pass
                elif token in [tsqlParser.PLUS_ASSIGN, tsqlParser.MINUS_ASSIGN, tsqlParser.MULT_ASSIGN, tsqlParser.DIV_ASSIGN, tsqlParser.MOD_ASSIGN, tsqlParser.AND_ASSIGN, tsqlParser.XOR_ASSIGN, tsqlParser.OR_ASSIGN]:
                    self.state = 2229
                    self.assignment_operator()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2232
                self.expression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2233
                localctx.udt_column_name = self.r_id()
                self.state = 2234
                self.match(tsqlParser.DOT)
                self.state = 2235
                localctx.method_name = self.r_id()
                self.state = 2236
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2237
                self.expression_list()
                self.state = 2238
                self.match(tsqlParser.RR_BRACKET)
                pass


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


    class Search_condition_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def search_condition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Search_conditionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Search_conditionContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_search_condition_list




    def search_condition_list(self):

        localctx = tsqlParser.Search_condition_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_search_condition_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2242
            self.search_condition(0)
            self.state = 2247
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 2243
                self.match(tsqlParser.COMMA)
                self.state = 2244
                self.search_condition(0)
                self.state = 2249
                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 Search_conditionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return tsqlParser.RULE_search_condition

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


    class Search_cond_orContext(Search_conditionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Search_conditionContext
            super().__init__(parser)
            self.left = None # Search_conditionContext
            self.op = None # Token
            self.right = None # Search_conditionContext
            self.copyFrom(ctx)

        def search_condition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Search_conditionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Search_conditionContext,i)

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


    class Search_cond_predContext(Search_conditionContext):

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

        def predicate(self):
            return self.getTypedRuleContext(tsqlParser.PredicateContext,0)



    class Search_cond_andContext(Search_conditionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Search_conditionContext
            super().__init__(parser)
            self.left = None # Search_conditionContext
            self.op = None # Token
            self.right = None # Search_conditionContext
            self.copyFrom(ctx)

        def search_condition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Search_conditionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Search_conditionContext,i)

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



    def search_condition(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = tsqlParser.Search_conditionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 226
        self.enterRecursionRule(localctx, 226, self.RULE_search_condition, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = tsqlParser.Search_cond_predContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 2251
            self.predicate()
            self._ctx.stop = self._input.LT(-1)
            self.state = 2261
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,326,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 = 2259
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,325,self._ctx)
                    if la_ == 1:
                        localctx = tsqlParser.Search_cond_andContext(self, tsqlParser.Search_conditionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_search_condition)
                        self.state = 2253
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 2254
                        localctx.op = self.match(tsqlParser.AND)
                        self.state = 2255
                        localctx.right = self.search_condition(4)
                        pass

                    elif la_ == 2:
                        localctx = tsqlParser.Search_cond_orContext(self, tsqlParser.Search_conditionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_search_condition)
                        self.state = 2256
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 2257
                        localctx.op = self.match(tsqlParser.OR)
                        self.state = 2258
                        localctx.right = self.search_condition(3)
                        pass

             
                self.state = 2263
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,326,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):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return tsqlParser.RULE_predicate

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



    class Binary_in_expressionContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.PredicateContext
            super().__init__(parser)
            self.left = None # ExpressionContext
            self.op = None # Token
            self.copyFrom(ctx)

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)
        def expression(self):
            return self.getTypedRuleContext(tsqlParser.ExpressionContext,0)

        def IN(self):
            return self.getToken(tsqlParser.IN, 0)
        def subquery(self):
            return self.getTypedRuleContext(tsqlParser.SubqueryContext,0)

        def expression_list(self):
            return self.getTypedRuleContext(tsqlParser.Expression_listContext,0)

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


    class Unary_operator_expression2Context(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.PredicateContext
            super().__init__(parser)
            self.op = None # Token
            self.expr = None # SubqueryContext
            self.copyFrom(ctx)

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)
        def EXISTS(self):
            return self.getToken(tsqlParser.EXISTS, 0)
        def subquery(self):
            return self.getTypedRuleContext(tsqlParser.SubqueryContext,0)



    class Binary_mod_expressionContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.PredicateContext
            super().__init__(parser)
            self.left = None # ExpressionContext
            self.op = None # Token
            self.right_1 = None # ExpressionContext
            self.right_2 = None # ExpressionContext
            self.copyFrom(ctx)

        def AND(self):
            return self.getToken(tsqlParser.AND, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.ExpressionContext,i)

        def BETWEEN(self):
            return self.getToken(tsqlParser.BETWEEN, 0)
        def NOT(self):
            return self.getToken(tsqlParser.NOT, 0)
        def LIKE(self):
            return self.getToken(tsqlParser.LIKE, 0)
        def ESCAPE(self):
            return self.getToken(tsqlParser.ESCAPE, 0)


    class Unary_operator_expression3Context(PredicateContext):

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

        def NOT(self):
            return self.getToken(tsqlParser.NOT, 0)
        def predicate(self):
            return self.getTypedRuleContext(tsqlParser.PredicateContext,0)



    class Bracket_search_expressionContext(PredicateContext):

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

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)

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


    class Sublink_expressionContext(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.PredicateContext
            super().__init__(parser)
            self.test_expr = None # ExpressionContext
            self.op = None # Comparison_operatorContext
            self.pref = None # Token
            self.copyFrom(ctx)

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def subquery(self):
            return self.getTypedRuleContext(tsqlParser.SubqueryContext,0)

        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)
        def expression(self):
            return self.getTypedRuleContext(tsqlParser.ExpressionContext,0)

        def comparison_operator(self):
            return self.getTypedRuleContext(tsqlParser.Comparison_operatorContext,0)

        def ALL(self):
            return self.getToken(tsqlParser.ALL, 0)
        def SOME(self):
            return self.getToken(tsqlParser.SOME, 0)
        def ANY(self):
            return self.getToken(tsqlParser.ANY, 0)


    class Binary_operator_expression3Context(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.PredicateContext
            super().__init__(parser)
            self.left = None # ExpressionContext
            self.op = None # Token
            self.right = None # Null_notnullContext
            self.copyFrom(ctx)

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

        def IS(self):
            return self.getToken(tsqlParser.IS, 0)
        def null_notnull(self):
            return self.getTypedRuleContext(tsqlParser.Null_notnullContext,0)



    class Binary_operator_expression2Context(PredicateContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.PredicateContext
            super().__init__(parser)
            self.left = None # ExpressionContext
            self.op = None # Comparison_operatorContext
            self.right = None # ExpressionContext
            self.copyFrom(ctx)

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

        def comparison_operator(self):
            return self.getTypedRuleContext(tsqlParser.Comparison_operatorContext,0)



    class Decimal_expressionContext(PredicateContext):

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

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



    def predicate(self):

        localctx = tsqlParser.PredicateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_predicate)
        self._la = 0 # Token type
        try:
            self.state = 2322
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,332,self._ctx)
            if la_ == 1:
                localctx = tsqlParser.Unary_operator_expression3Context(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2264
                localctx.op = self.match(tsqlParser.NOT)
                self.state = 2265
                localctx.expr = self.predicate()
                pass

            elif la_ == 2:
                localctx = tsqlParser.Unary_operator_expression2Context(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2266
                localctx.op = self.match(tsqlParser.EXISTS)
                self.state = 2267
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2268
                localctx.expr = self.subquery()
                self.state = 2269
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 3:
                localctx = tsqlParser.Binary_operator_expression2Context(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2271
                localctx.left = self.expression(0)
                self.state = 2272
                localctx.op = self.comparison_operator()
                self.state = 2273
                localctx.right = self.expression(0)
                pass

            elif la_ == 4:
                localctx = tsqlParser.Sublink_expressionContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2275
                localctx.test_expr = self.expression(0)
                self.state = 2276
                localctx.op = self.comparison_operator()
                self.state = 2277
                localctx.pref = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.ALL or _la==tsqlParser.ANY or _la==tsqlParser.SOME):
                    localctx.pref = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2278
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2279
                self.subquery()
                self.state = 2280
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 5:
                localctx = tsqlParser.Binary_mod_expressionContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2282
                localctx.left = self.expression(0)
                self.state = 2284
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.NOT:
                    self.state = 2283
                    self.match(tsqlParser.NOT)


                self.state = 2286
                localctx.op = self.match(tsqlParser.BETWEEN)
                self.state = 2287
                localctx.right_1 = self.expression(0)
                self.state = 2288
                self.match(tsqlParser.AND)
                self.state = 2289
                localctx.right_2 = self.expression(0)
                pass

            elif la_ == 6:
                localctx = tsqlParser.Binary_in_expressionContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 2291
                localctx.left = self.expression(0)
                self.state = 2293
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.NOT:
                    self.state = 2292
                    self.match(tsqlParser.NOT)


                self.state = 2295
                localctx.op = self.match(tsqlParser.IN)
                self.state = 2296
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2299
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,329,self._ctx)
                if la_ == 1:
                    self.state = 2297
                    self.subquery()
                    pass

                elif la_ == 2:
                    self.state = 2298
                    self.expression_list()
                    pass


                self.state = 2301
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 7:
                localctx = tsqlParser.Binary_mod_expressionContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 2303
                localctx.left = self.expression(0)
                self.state = 2305
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.NOT:
                    self.state = 2304
                    self.match(tsqlParser.NOT)


                self.state = 2307
                localctx.op = self.match(tsqlParser.LIKE)
                self.state = 2308
                localctx.right_1 = self.expression(0)
                self.state = 2311
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,331,self._ctx)
                if la_ == 1:
                    self.state = 2309
                    self.match(tsqlParser.ESCAPE)
                    self.state = 2310
                    localctx.right_2 = self.expression(0)


                pass

            elif la_ == 8:
                localctx = tsqlParser.Binary_operator_expression3Context(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 2313
                localctx.left = self.expression(0)
                self.state = 2314
                localctx.op = self.match(tsqlParser.IS)
                self.state = 2315
                localctx.right = self.null_notnull()
                pass

            elif la_ == 9:
                localctx = tsqlParser.Bracket_search_expressionContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 2317
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2318
                self.search_condition(0)
                self.state = 2319
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 10:
                localctx = tsqlParser.Decimal_expressionContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 2321
                self.match(tsqlParser.DECIMAL)
                pass


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


    class Query_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return tsqlParser.RULE_query_expression

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


    class Bracket_query_expressionContext(Query_expressionContext):

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

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def query_expression(self):
            return self.getTypedRuleContext(tsqlParser.Query_expressionContext,0)

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


    class Query_specification_expressionContext(Query_expressionContext):

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

        def query_specification(self):
            return self.getTypedRuleContext(tsqlParser.Query_specificationContext,0)



    class Union_query_expressionContext(Query_expressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Query_expressionContext
            super().__init__(parser)
            self.left = None # Query_expressionContext
            self.op = None # Union_opContext
            self.right = None # Query_expressionContext
            self.copyFrom(ctx)

        def query_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Query_expressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Query_expressionContext,i)

        def union_op(self):
            return self.getTypedRuleContext(tsqlParser.Union_opContext,0)




    def query_expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = tsqlParser.Query_expressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 230
        self.enterRecursionRule(localctx, 230, self.RULE_query_expression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2330
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.LR_BRACKET]:
                localctx = tsqlParser.Bracket_query_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2325
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2326
                self.query_expression(0)
                self.state = 2327
                self.match(tsqlParser.RR_BRACKET)
                pass
            elif token in [tsqlParser.SELECT]:
                localctx = tsqlParser.Query_specification_expressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2329
                self.query_specification()
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 2338
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,334,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 = tsqlParser.Union_query_expressionContext(self, tsqlParser.Query_expressionContext(self, _parentctx, _parentState))
                    localctx.left = _prevctx
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_query_expression)
                    self.state = 2332
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 2333
                    localctx.op = self.union_op()
                    self.state = 2334
                    localctx.right = self.query_expression(3) 
                self.state = 2340
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,334,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 Union_opContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNION(self):
            return self.getToken(tsqlParser.UNION, 0)

        def EXCEPT(self):
            return self.getToken(tsqlParser.EXCEPT, 0)

        def INTERSECT(self):
            return self.getToken(tsqlParser.INTERSECT, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_union_op




    def union_op(self):

        localctx = tsqlParser.Union_opContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_union_op)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2347
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.UNION]:
                self.state = 2341
                self.match(tsqlParser.UNION)
                self.state = 2343
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ALL:
                    self.state = 2342
                    self.match(tsqlParser.ALL)


                pass
            elif token in [tsqlParser.EXCEPT]:
                self.state = 2345
                self.match(tsqlParser.EXCEPT)
                pass
            elif token in [tsqlParser.INTERSECT]:
                self.state = 2346
                self.match(tsqlParser.INTERSECT)
                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 Cross_apply_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def cross_apply_expression(self):
            return self.getTypedRuleContext(tsqlParser.Cross_apply_expressionContext,0)


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

        def query_expression(self):
            return self.getTypedRuleContext(tsqlParser.Query_expressionContext,0)


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


        def table_value_constructor(self):
            return self.getTypedRuleContext(tsqlParser.Table_value_constructorContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_cross_apply_expression




    def cross_apply_expression(self):

        localctx = tsqlParser.Cross_apply_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_cross_apply_expression)
        try:
            self.state = 2356
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,337,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2349
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2350
                self.cross_apply_expression()
                self.state = 2351
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2353
                self.query_expression(0)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2354
                self.expression(0)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2355
                self.table_value_constructor()
                pass


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


    class Query_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def select_list(self):
            return self.getTypedRuleContext(tsqlParser.Select_listContext,0)


        def top_clause(self):
            return self.getTypedRuleContext(tsqlParser.Top_clauseContext,0)


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

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

        def table_sources(self):
            return self.getTypedRuleContext(tsqlParser.Table_sourcesContext,0)


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

        def APPLY(self):
            return self.getToken(tsqlParser.APPLY, 0)

        def cross_apply_expression(self):
            return self.getTypedRuleContext(tsqlParser.Cross_apply_expressionContext,0)


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

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

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

        def group_by_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Group_by_itemContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Group_by_itemContext,i)


        def group_by_grouping_sets(self):
            return self.getTypedRuleContext(tsqlParser.Group_by_grouping_setsContext,0)


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

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

        def search_condition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Search_conditionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Search_conditionContext,i)


        def CUBE(self):
            return self.getToken(tsqlParser.CUBE, 0)

        def ROLLUP(self):
            return self.getToken(tsqlParser.ROLLUP, 0)

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

        def DISTINCT(self):
            return self.getToken(tsqlParser.DISTINCT, 0)

        def output_dml_list_elem(self):
            return self.getTypedRuleContext(tsqlParser.Output_dml_list_elemContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_query_specification




    def query_specification(self):

        localctx = tsqlParser.Query_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_query_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2358
            self.match(tsqlParser.SELECT)
            self.state = 2360
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.ALL or _la==tsqlParser.DISTINCT:
                self.state = 2359
                localctx.pref = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.ALL or _la==tsqlParser.DISTINCT):
                    localctx.pref = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2363
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.TOP:
                self.state = 2362
                self.top_clause()


            self.state = 2365
            self.select_list()
            self.state = 2368
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,340,self._ctx)
            if la_ == 1:
                self.state = 2366
                self.match(tsqlParser.INTO)
                self.state = 2367
                self.full_table_name()


            self.state = 2372
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,341,self._ctx)
            if la_ == 1:
                self.state = 2370
                self.match(tsqlParser.FROM)
                self.state = 2371
                self.table_sources()


            self.state = 2380
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,343,self._ctx)
            if la_ == 1:
                self.state = 2374
                self.match(tsqlParser.CROSS)
                self.state = 2375
                self.match(tsqlParser.APPLY)
                self.state = 2376
                self.cross_apply_expression()
                self.state = 2378
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,342,self._ctx)
                if la_ == 1:
                    self.state = 2377
                    self.output_dml_list_elem()




            self.state = 2384
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,344,self._ctx)
            if la_ == 1:
                self.state = 2382
                self.match(tsqlParser.WHERE)
                self.state = 2383
                localctx.where = self.search_condition(0)


            self.state = 2396
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,346,self._ctx)
            if la_ == 1:
                self.state = 2386
                self.match(tsqlParser.GROUP)
                self.state = 2387
                self.match(tsqlParser.BY)
                self.state = 2388
                self.group_by_item()
                self.state = 2393
                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 = 2389
                        self.match(tsqlParser.COMMA)
                        self.state = 2390
                        self.group_by_item() 
                    self.state = 2395
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,345,self._ctx)



            self.state = 2399
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,347,self._ctx)
            if la_ == 1:
                self.state = 2398
                self.group_by_grouping_sets()


            self.state = 2403
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,348,self._ctx)
            if la_ == 1:
                self.state = 2401
                self.match(tsqlParser.WITH)
                self.state = 2402
                _la = self._input.LA(1)
                if not(_la==tsqlParser.CUBE or _la==tsqlParser.ROLLUP):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2407
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,349,self._ctx)
            if la_ == 1:
                self.state = 2405
                self.match(tsqlParser.HAVING)
                self.state = 2406
                localctx.having = self.search_condition(0)


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


    class Group_by_grouping_setsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def GROUPING(self):
            return self.getToken(tsqlParser.GROUPING, 0)

        def SETS(self):
            return self.getToken(tsqlParser.SETS, 0)

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

        def grouping_set(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Grouping_setContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Grouping_setContext,i)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_group_by_grouping_sets




    def group_by_grouping_sets(self):

        localctx = tsqlParser.Group_by_grouping_setsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_group_by_grouping_sets)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2409
            self.match(tsqlParser.GROUP)
            self.state = 2410
            self.match(tsqlParser.BY)
            self.state = 2411
            self.match(tsqlParser.GROUPING)
            self.state = 2412
            self.match(tsqlParser.SETS)
            self.state = 2413
            self.match(tsqlParser.LR_BRACKET)
            self.state = 2414
            self.grouping_set()
            self.state = 2419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 2415
                self.match(tsqlParser.COMMA)
                self.state = 2416
                self.grouping_set()
                self.state = 2421
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Grouping_setContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def group_by_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Group_by_itemContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Group_by_itemContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_grouping_set




    def grouping_set(self):

        localctx = tsqlParser.Grouping_setContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_grouping_set)
        self._la = 0 # Token type
        try:
            self.state = 2438
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,352,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2424
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2425
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2426
                self.group_by_item()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2427
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2428
                self.group_by_item()
                self.state = 2433
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 2429
                    self.match(tsqlParser.COMMA)
                    self.state = 2430
                    self.group_by_item()
                    self.state = 2435
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2436
                self.match(tsqlParser.RR_BRACKET)
                pass


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


    class Top_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TOP(self):
            return self.getToken(tsqlParser.TOP, 0)

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


        def PERCENT(self):
            return self.getToken(tsqlParser.PERCENT, 0)

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

        def TIES(self):
            return self.getToken(tsqlParser.TIES, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_top_clause




    def top_clause(self):

        localctx = tsqlParser.Top_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_top_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2440
            self.match(tsqlParser.TOP)
            self.state = 2441
            self.expression(0)
            self.state = 2443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.PERCENT:
                self.state = 2442
                self.match(tsqlParser.PERCENT)


            self.state = 2447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 2445
                self.match(tsqlParser.WITH)
                self.state = 2446
                self.match(tsqlParser.TIES)


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


    class Top_clause_dmContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TOP(self):
            return self.getToken(tsqlParser.TOP, 0)

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

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


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

        def PERCENT(self):
            return self.getToken(tsqlParser.PERCENT, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_top_clause_dm




    def top_clause_dm(self):

        localctx = tsqlParser.Top_clause_dmContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_top_clause_dm)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2449
            self.match(tsqlParser.TOP)
            self.state = 2450
            self.match(tsqlParser.LR_BRACKET)
            self.state = 2451
            self.expression(0)
            self.state = 2452
            self.match(tsqlParser.RR_BRACKET)
            self.state = 2454
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.PERCENT:
                self.state = 2453
                self.match(tsqlParser.PERCENT)


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


    class Order_by_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def order_by_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Order_by_expressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Order_by_expressionContext,i)


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

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

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


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

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

        def fetch_expression(self):
            return self.getTypedRuleContext(tsqlParser.Fetch_expressionContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_order_by_clause




    def order_by_clause(self):

        localctx = tsqlParser.Order_by_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_order_by_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2456
            self.match(tsqlParser.ORDER)
            self.state = 2457
            self.match(tsqlParser.BY)
            self.state = 2458
            self.order_by_expression()
            self.state = 2463
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,356,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2459
                    self.match(tsqlParser.COMMA)
                    self.state = 2460
                    self.order_by_expression() 
                self.state = 2465
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,356,self._ctx)

            self.state = 2472
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,358,self._ctx)
            if la_ == 1:
                self.state = 2466
                self.match(tsqlParser.OFFSET)
                self.state = 2467
                localctx.offset = self.expression(0)
                self.state = 2468
                _la = self._input.LA(1)
                if not(_la==tsqlParser.ROW or _la==tsqlParser.ROWS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2470
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,357,self._ctx)
                if la_ == 1:
                    self.state = 2469
                    self.fetch_expression()




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


    class Fetch_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FETCH(self):
            return self.getToken(tsqlParser.FETCH, 0)

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


        def ONLY(self):
            return self.getToken(tsqlParser.ONLY, 0)

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

        def NEXT(self):
            return self.getToken(tsqlParser.NEXT, 0)

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_fetch_expression




    def fetch_expression(self):

        localctx = tsqlParser.Fetch_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_fetch_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2474
            self.match(tsqlParser.FETCH)
            self.state = 2475
            _la = self._input.LA(1)
            if not(_la==tsqlParser.NEXT or _la==tsqlParser.FIRST):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2476
            self.expression(0)
            self.state = 2477
            _la = self._input.LA(1)
            if not(_la==tsqlParser.ROW or _la==tsqlParser.ROWS):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2478
            self.match(tsqlParser.ONLY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class For_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def BROWSE(self):
            return self.getToken(tsqlParser.BROWSE, 0)

        def XML(self):
            return self.getToken(tsqlParser.XML, 0)

        def AUTO(self):
            return self.getToken(tsqlParser.AUTO, 0)

        def xml_common_directives(self):
            return self.getTypedRuleContext(tsqlParser.Xml_common_directivesContext,0)


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

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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_for_clause




    def for_clause(self):

        localctx = tsqlParser.For_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_for_clause)
        try:
            self.state = 2499
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,362,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2480
                self.match(tsqlParser.FOR)
                self.state = 2481
                self.match(tsqlParser.BROWSE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2482
                self.match(tsqlParser.FOR)
                self.state = 2483
                self.match(tsqlParser.XML)
                self.state = 2484
                self.match(tsqlParser.AUTO)
                self.state = 2486
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,359,self._ctx)
                if la_ == 1:
                    self.state = 2485
                    self.xml_common_directives()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2488
                self.match(tsqlParser.FOR)
                self.state = 2489
                self.match(tsqlParser.XML)
                self.state = 2490
                self.match(tsqlParser.PATH)
                self.state = 2494
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,360,self._ctx)
                if la_ == 1:
                    self.state = 2491
                    self.match(tsqlParser.LR_BRACKET)
                    self.state = 2492
                    self.match(tsqlParser.STRING)
                    self.state = 2493
                    self.match(tsqlParser.RR_BRACKET)


                self.state = 2497
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,361,self._ctx)
                if la_ == 1:
                    self.state = 2496
                    self.xml_common_directives()


                pass


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


    class Xml_common_directivesContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def BINARY(self):
            return self.getToken(tsqlParser.BINARY, 0)

        def BASE64(self):
            return self.getToken(tsqlParser.BASE64, 0)

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

        def ROOT(self):
            return self.getToken(tsqlParser.ROOT, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_xml_common_directives




    def xml_common_directives(self):

        localctx = tsqlParser.Xml_common_directivesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_xml_common_directives)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2501
            self.match(tsqlParser.COMMA)
            self.state = 2506
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.BINARY]:
                self.state = 2502
                self.match(tsqlParser.BINARY)
                self.state = 2503
                self.match(tsqlParser.BASE64)
                pass
            elif token in [tsqlParser.TYPE]:
                self.state = 2504
                self.match(tsqlParser.TYPE)
                pass
            elif token in [tsqlParser.ROOT]:
                self.state = 2505
                self.match(tsqlParser.ROOT)
                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 Order_by_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_order_by_expression




    def order_by_expression(self):

        localctx = tsqlParser.Order_by_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_order_by_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2508
            self.expression(0)
            self.state = 2510
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,364,self._ctx)
            if la_ == 1:
                self.state = 2509
                localctx.direction = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.ASC or _la==tsqlParser.DESC):
                    localctx.direction = 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 Group_by_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return tsqlParser.RULE_group_by_item




    def group_by_item(self):

        localctx = tsqlParser.Group_by_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_group_by_item)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2512
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Option_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPTION(self):
            return self.getToken(tsqlParser.OPTION, 0)

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

        def option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.OptionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.OptionContext,i)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_option_clause




    def option_clause(self):

        localctx = tsqlParser.Option_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_option_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2514
            self.match(tsqlParser.OPTION)
            self.state = 2515
            self.match(tsqlParser.LR_BRACKET)
            self.state = 2516
            self.option()
            self.state = 2521
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 2517
                self.match(tsqlParser.COMMA)
                self.state = 2518
                self.option()
                self.state = 2523
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class OptionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FAST(self):
            return self.getToken(tsqlParser.FAST, 0)

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

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

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

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

        def UNION(self):
            return self.getToken(tsqlParser.UNION, 0)

        def MERGE(self):
            return self.getToken(tsqlParser.MERGE, 0)

        def CONCAT(self):
            return self.getToken(tsqlParser.CONCAT, 0)

        def JOIN(self):
            return self.getToken(tsqlParser.JOIN, 0)

        def LOOP(self):
            return self.getToken(tsqlParser.LOOP, 0)

        def EXPAND(self):
            return self.getToken(tsqlParser.EXPAND, 0)

        def VIEWS(self):
            return self.getToken(tsqlParser.VIEWS, 0)

        def FORCE(self):
            return self.getToken(tsqlParser.FORCE, 0)

        def IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX(self):
            return self.getToken(tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, 0)

        def KEEP(self):
            return self.getToken(tsqlParser.KEEP, 0)

        def PLAN(self):
            return self.getToken(tsqlParser.PLAN, 0)

        def KEEPFIXED(self):
            return self.getToken(tsqlParser.KEEPFIXED, 0)

        def MAXDOP(self):
            return self.getToken(tsqlParser.MAXDOP, 0)

        def MAXRECURSION(self):
            return self.getToken(tsqlParser.MAXRECURSION, 0)

        def OPTIMIZE(self):
            return self.getToken(tsqlParser.OPTIMIZE, 0)

        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

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

        def optimize_for_arg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Optimize_for_argContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Optimize_for_argContext,i)


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

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

        def UNKNOWN(self):
            return self.getToken(tsqlParser.UNKNOWN, 0)

        def PARAMETERIZATION(self):
            return self.getToken(tsqlParser.PARAMETERIZATION, 0)

        def SIMPLE(self):
            return self.getToken(tsqlParser.SIMPLE, 0)

        def FORCED(self):
            return self.getToken(tsqlParser.FORCED, 0)

        def RECOMPILE(self):
            return self.getToken(tsqlParser.RECOMPILE, 0)

        def ROBUST(self):
            return self.getToken(tsqlParser.ROBUST, 0)

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_option




    def option(self):

        localctx = tsqlParser.OptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_option)
        self._la = 0 # Token type
        try:
            self.state = 2571
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,367,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2526
                self.match(tsqlParser.FAST)
                self.state = 2527
                localctx.number_rows = self.match(tsqlParser.DECIMAL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2528
                _la = self._input.LA(1)
                if not(_la==tsqlParser.ORDER or _la==tsqlParser.HASH):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2529
                self.match(tsqlParser.GROUP)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2530
                _la = self._input.LA(1)
                if not(_la==tsqlParser.MERGE or _la==tsqlParser.CONCAT or _la==tsqlParser.HASH):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2531
                self.match(tsqlParser.UNION)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2532
                _la = self._input.LA(1)
                if not(_la==tsqlParser.MERGE or _la==tsqlParser.HASH or _la==tsqlParser.LOOP):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2533
                self.match(tsqlParser.JOIN)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2534
                self.match(tsqlParser.EXPAND)
                self.state = 2535
                self.match(tsqlParser.VIEWS)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2536
                self.match(tsqlParser.FORCE)
                self.state = 2537
                self.match(tsqlParser.ORDER)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2538
                self.match(tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2539
                self.match(tsqlParser.KEEP)
                self.state = 2540
                self.match(tsqlParser.PLAN)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 2541
                self.match(tsqlParser.KEEPFIXED)
                self.state = 2542
                self.match(tsqlParser.PLAN)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 2543
                self.match(tsqlParser.MAXDOP)
                self.state = 2544
                localctx.number_of_processors = self.match(tsqlParser.DECIMAL)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 2545
                self.match(tsqlParser.MAXRECURSION)
                self.state = 2546
                localctx.number_recursion = self.match(tsqlParser.DECIMAL)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 2547
                self.match(tsqlParser.OPTIMIZE)
                self.state = 2548
                self.match(tsqlParser.FOR)
                self.state = 2549
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2550
                self.optimize_for_arg()
                self.state = 2555
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 2551
                    self.match(tsqlParser.COMMA)
                    self.state = 2552
                    self.optimize_for_arg()
                    self.state = 2557
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2558
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 2560
                self.match(tsqlParser.OPTIMIZE)
                self.state = 2561
                self.match(tsqlParser.FOR)
                self.state = 2562
                self.match(tsqlParser.UNKNOWN)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 2563
                self.match(tsqlParser.PARAMETERIZATION)
                self.state = 2564
                _la = self._input.LA(1)
                if not(_la==tsqlParser.FORCED or _la==tsqlParser.SIMPLE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 2565
                self.match(tsqlParser.RECOMPILE)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 2566
                self.match(tsqlParser.ROBUST)
                self.state = 2567
                self.match(tsqlParser.PLAN)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 2568
                self.match(tsqlParser.USE)
                self.state = 2569
                self.match(tsqlParser.PLAN)
                self.state = 2570
                self.match(tsqlParser.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 Optimize_for_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def UNKNOWN(self):
            return self.getToken(tsqlParser.UNKNOWN, 0)

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

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


        def getRuleIndex(self):
            return tsqlParser.RULE_optimize_for_arg




    def optimize_for_arg(self):

        localctx = tsqlParser.Optimize_for_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_optimize_for_arg)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2573
            self.match(tsqlParser.LOCAL_ID)
            self.state = 2577
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.UNKNOWN]:
                self.state = 2574
                self.match(tsqlParser.UNKNOWN)
                pass
            elif token in [tsqlParser.EQUAL]:
                self.state = 2575
                self.match(tsqlParser.EQUAL)
                self.state = 2576
                self.constant()
                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 Select_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def select_list_elem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Select_list_elemContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Select_list_elemContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_select_list




    def select_list(self):

        localctx = tsqlParser.Select_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_select_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2579
            self.select_list_elem()
            self.state = 2584
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,369,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2580
                    self.match(tsqlParser.COMMA)
                    self.state = 2581
                    self.select_list_elem() 
                self.state = 2586
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,369,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 Select_list_elemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def a_star(self):
            return self.getTypedRuleContext(tsqlParser.A_starContext,0)


        def DOLLAR(self):
            return self.getToken(tsqlParser.DOLLAR, 0)

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

        def IDENTITY(self):
            return self.getToken(tsqlParser.IDENTITY, 0)

        def ROWGUID(self):
            return self.getToken(tsqlParser.ROWGUID, 0)

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

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


        def column_alias(self):
            return self.getTypedRuleContext(tsqlParser.Column_aliasContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_select_list_elem




    def select_list_elem(self):

        localctx = tsqlParser.Select_list_elemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_select_list_elem)
        self._la = 0 # Token type
        try:
            self.state = 2608
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,374,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2590
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (tsqlParser.FILLFACTOR - 71)) | (1 << (tsqlParser.FORCESEEK - 71)) | (1 << (tsqlParser.NEXT - 71)) | (1 << (tsqlParser.NUMERIC - 71)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (tsqlParser.VALUE - 196)) | (1 << (tsqlParser.ABSOLUTE - 196)) | (1 << (tsqlParser.APPLY - 196)) | (1 << (tsqlParser.AUTO - 196)) | (1 << (tsqlParser.AVG - 196)) | (1 << (tsqlParser.BASE64 - 196)) | (1 << (tsqlParser.CALLER - 196)) | (1 << (tsqlParser.CAST - 196)) | (1 << (tsqlParser.CATCH - 196)) | (1 << (tsqlParser.CHECKSUM_AGG - 196)) | (1 << (tsqlParser.COMMITTED - 196)) | (1 << (tsqlParser.CONCAT - 196)) | (1 << (tsqlParser.CONTROL - 196)) | (1 << (tsqlParser.COOKIE - 196)) | (1 << (tsqlParser.COUNT - 196)) | (1 << (tsqlParser.COUNT_BIG - 196)) | (1 << (tsqlParser.DATE - 196)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (tsqlParser.DELAY - 261)) | (1 << (tsqlParser.DELETED - 261)) | (1 << (tsqlParser.DENSE_RANK - 261)) | (1 << (tsqlParser.DISABLE - 261)) | (1 << (tsqlParser.DYNAMIC - 261)) | (1 << (tsqlParser.ENCRYPTION - 261)) | (1 << (tsqlParser.EXIST - 261)) | (1 << (tsqlParser.EXPAND - 261)) | (1 << (tsqlParser.FAST - 261)) | (1 << (tsqlParser.FAST_FORWARD - 261)) | (1 << (tsqlParser.FIRST - 261)) | (1 << (tsqlParser.FIRST_VALUE - 261)) | (1 << (tsqlParser.FOLLOWING - 261)) | (1 << (tsqlParser.FORCE - 261)) | (1 << (tsqlParser.FORCED - 261)) | (1 << (tsqlParser.FORWARD_ONLY - 261)) | (1 << (tsqlParser.FULLSCAN - 261)) | (1 << (tsqlParser.GLOBAL - 261)) | (1 << (tsqlParser.GROUPING - 261)) | (1 << (tsqlParser.GROUPING_ID - 261)) | (1 << (tsqlParser.HASH - 261)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 261)) | (1 << (tsqlParser.IMPERSONATE - 261)) | (1 << (tsqlParser.INSENSITIVE - 261)) | (1 << (tsqlParser.INSERTED - 261)) | (1 << (tsqlParser.ISOLATION - 261)) | (1 << (tsqlParser.IO - 261)) | (1 << (tsqlParser.KEEP - 261)) | (1 << (tsqlParser.KEEPFIXED - 261)) | (1 << (tsqlParser.KEYSET - 261)) | (1 << (tsqlParser.LAG - 261)) | (1 << (tsqlParser.LAST - 261)) | (1 << (tsqlParser.LAST_VALUE - 261)) | (1 << (tsqlParser.LEAD - 261)) | (1 << (tsqlParser.LEVEL - 261)) | (1 << (tsqlParser.LOCAL - 261)) | (1 << (tsqlParser.LOCK_ESCALATION - 261)) | (1 << (tsqlParser.LOGIN - 261)) | (1 << (tsqlParser.LOOP - 261)) | (1 << (tsqlParser.MARK - 261)) | (1 << (tsqlParser.MAX - 261)) | (1 << (tsqlParser.MAXDOP - 261)) | (1 << (tsqlParser.MAXRECURSION - 261)))) != 0) or ((((_la - 328)) & ~0x3f) == 0 and ((1 << (_la - 328)) & ((1 << (tsqlParser.MIN - 328)) | (1 << (tsqlParser.MODIFY - 328)) | (1 << (tsqlParser.NAME - 328)) | (1 << (tsqlParser.NOCOUNT - 328)) | (1 << (tsqlParser.NODES - 328)) | (1 << (tsqlParser.NOEXPAND - 328)) | (1 << (tsqlParser.NORECOMPUTE - 328)) | (1 << (tsqlParser.NTILE - 328)) | (1 << (tsqlParser.NUMBER - 328)) | (1 << (tsqlParser.OFFSET - 328)) | (1 << (tsqlParser.ONLINE - 328)) | (1 << (tsqlParser.ONLY - 328)) | (1 << (tsqlParser.OPTIMISTIC - 328)) | (1 << (tsqlParser.OPTIMIZE - 328)) | (1 << (tsqlParser.OUT - 328)) | (1 << (tsqlParser.OUTPUT - 328)) | (1 << (tsqlParser.OWNER - 328)) | (1 << (tsqlParser.PARAMETERIZATION - 328)) | (1 << (tsqlParser.PARTITION - 328)) | (1 << (tsqlParser.PATH - 328)) | (1 << (tsqlParser.PRECEDING - 328)) | (1 << (tsqlParser.PRIOR - 328)) | (1 << (tsqlParser.PRIVILEGES - 328)) | (1 << (tsqlParser.QUERY - 328)) | (1 << (tsqlParser.RANGE - 328)) | (1 << (tsqlParser.RANK - 328)) | (1 << (tsqlParser.READONLY - 328)) | (1 << (tsqlParser.READ_ONLY - 328)) | (1 << (tsqlParser.RECOMPILE - 328)) | (1 << (tsqlParser.RELATIVE - 328)) | (1 << (tsqlParser.REMOTE - 328)) | (1 << (tsqlParser.REPEATABLE - 328)) | (1 << (tsqlParser.ROBUST - 328)) | (1 << (tsqlParser.ROOT - 328)) | (1 << (tsqlParser.ROW - 328)) | (1 << (tsqlParser.ROWGUID - 328)) | (1 << (tsqlParser.ROWS - 328)) | (1 << (tsqlParser.ROW_NUMBER - 328)) | (1 << (tsqlParser.SAMPLE - 328)) | (1 << (tsqlParser.SCHEMABINDING - 328)) | (1 << (tsqlParser.SCROLL - 328)) | (1 << (tsqlParser.SCROLL_LOCKS - 328)))) != 0) or ((((_la - 393)) & ~0x3f) == 0 and ((1 << (_la - 393)) & ((1 << (tsqlParser.SELF - 393)) | (1 << (tsqlParser.SERIALIZABLE - 393)) | (1 << (tsqlParser.SIMPLE - 393)) | (1 << (tsqlParser.SIZE - 393)) | (1 << (tsqlParser.SNAPSHOT - 393)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 393)) | (1 << (tsqlParser.STATIC - 393)) | (1 << (tsqlParser.STATS_STREAM - 393)) | (1 << (tsqlParser.STDEV - 393)) | (1 << (tsqlParser.STDEVP - 393)) | (1 << (tsqlParser.SUM - 393)) | (1 << (tsqlParser.TEXTIMAGE_ON - 393)) | (1 << (tsqlParser.THROW - 393)) | (1 << (tsqlParser.TIES - 393)) | (1 << (tsqlParser.TIME - 393)) | (1 << (tsqlParser.TRY - 393)) | (1 << (tsqlParser.TYPE - 393)) | (1 << (tsqlParser.TYPE_WARNING - 393)) | (1 << (tsqlParser.UNBOUNDED - 393)) | (1 << (tsqlParser.UNCOMMITTED - 393)) | (1 << (tsqlParser.UNKNOWN - 393)) | (1 << (tsqlParser.USING - 393)) | (1 << (tsqlParser.VAR - 393)) | (1 << (tsqlParser.VARP - 393)) | (1 << (tsqlParser.VIEWS - 393)) | (1 << (tsqlParser.VIEW_METADATA - 393)) | (1 << (tsqlParser.WORK - 393)) | (1 << (tsqlParser.XML - 393)) | (1 << (tsqlParser.XMLNAMESPACES - 393)) | (1 << (tsqlParser.ZONE - 393)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 393)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 393)) | (1 << (tsqlParser.ID - 393)))) != 0):
                    self.state = 2587
                    self.full_table_name()
                    self.state = 2588
                    self.match(tsqlParser.DOT)


                self.state = 2595
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.STAR]:
                    self.state = 2592
                    self.a_star()
                    pass
                elif token in [tsqlParser.DOLLAR]:
                    self.state = 2593
                    self.match(tsqlParser.DOLLAR)
                    self.state = 2594
                    _la = self._input.LA(1)
                    if not(_la==tsqlParser.IDENTITY or _la==tsqlParser.ROWGUID):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2597
                localctx.alias = self.column_alias()
                self.state = 2598
                self.match(tsqlParser.EQUAL)
                self.state = 2599
                self.expression(0)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2601
                self.expression(0)
                self.state = 2606
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,373,self._ctx)
                if la_ == 1:
                    self.state = 2603
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.AS:
                        self.state = 2602
                        self.match(tsqlParser.AS)


                    self.state = 2605
                    localctx.alias = self.column_alias()


                pass


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


    class Table_sourcesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def table_source(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Table_sourceContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Table_sourceContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_table_sources




    def table_sources(self):

        localctx = tsqlParser.Table_sourcesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_table_sources)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2610
            self.table_source(0)
            self.state = 2615
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,375,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2611
                    self.match(tsqlParser.COMMA)
                    self.state = 2612
                    self.table_source(0) 
                self.state = 2617
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,375,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 Table_sourceContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return tsqlParser.RULE_table_source

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


    class Cross_joinContext(Table_sourceContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Table_sourceContext
            super().__init__(parser)
            self.left = None # Table_sourceContext
            self.op = None # Token
            self.right = None # Table_sourceContext
            self.copyFrom(ctx)

        def JOIN(self):
            return self.getToken(tsqlParser.JOIN, 0)
        def table_source(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Table_sourceContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Table_sourceContext,i)

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


    class Table_source_item_joinContext(Table_sourceContext):

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

        def table_source_item(self):
            return self.getTypedRuleContext(tsqlParser.Table_source_itemContext,0)



    class Standard_joinContext(Table_sourceContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Table_sourceContext
            super().__init__(parser)
            self.left = None # Table_sourceContext
            self.right = None # Table_sourceContext
            self.copyFrom(ctx)

        def join_type(self):
            return self.getTypedRuleContext(tsqlParser.Join_typeContext,0)

        def JOIN(self):
            return self.getToken(tsqlParser.JOIN, 0)
        def ON(self):
            return self.getToken(tsqlParser.ON, 0)
        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)

        def table_source(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Table_sourceContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Table_sourceContext,i)



    class Apply_joinContext(Table_sourceContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Table_sourceContext
            super().__init__(parser)
            self.left = None # Table_sourceContext
            self.op = None # Token
            self.right = None # Table_sourceContext
            self.copyFrom(ctx)

        def APPLY(self):
            return self.getToken(tsqlParser.APPLY, 0)
        def table_source(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Table_sourceContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Table_sourceContext,i)

        def CROSS(self):
            return self.getToken(tsqlParser.CROSS, 0)
        def OUTER(self):
            return self.getToken(tsqlParser.OUTER, 0)


    class Bracket_table_sourceContext(Table_sourceContext):

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

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def table_source(self):
            return self.getTypedRuleContext(tsqlParser.Table_sourceContext,0)

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



    def table_source(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = tsqlParser.Table_sourceContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 270
        self.enterRecursionRule(localctx, 270, self.RULE_table_source, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2624
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,376,self._ctx)
            if la_ == 1:
                localctx = tsqlParser.Bracket_table_sourceContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2619
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2620
                self.table_source(0)
                self.state = 2621
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 2:
                localctx = tsqlParser.Table_source_item_joinContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2623
                self.table_source_item()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 2643
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,378,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 = 2641
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,377,self._ctx)
                    if la_ == 1:
                        localctx = tsqlParser.Cross_joinContext(self, tsqlParser.Table_sourceContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_table_source)
                        self.state = 2626
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 2627
                        localctx.op = self.match(tsqlParser.CROSS)
                        self.state = 2628
                        self.match(tsqlParser.JOIN)
                        self.state = 2629
                        localctx.right = self.table_source(4)
                        pass

                    elif la_ == 2:
                        localctx = tsqlParser.Apply_joinContext(self, tsqlParser.Table_sourceContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_table_source)
                        self.state = 2630
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 2631
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==tsqlParser.CROSS or _la==tsqlParser.OUTER):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2632
                        self.match(tsqlParser.APPLY)
                        self.state = 2633
                        localctx.right = self.table_source(3)
                        pass

                    elif la_ == 3:
                        localctx = tsqlParser.Standard_joinContext(self, tsqlParser.Table_sourceContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_table_source)
                        self.state = 2634
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 2635
                        self.join_type()
                        self.state = 2636
                        self.match(tsqlParser.JOIN)
                        self.state = 2637
                        localctx.right = self.table_source(0)
                        self.state = 2638
                        self.match(tsqlParser.ON)
                        self.state = 2639
                        self.search_condition(0)
                        pass

             
                self.state = 2645
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,378,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 Table_source_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return tsqlParser.RULE_table_source_item

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



    class Table_source_item_simpleContext(Table_source_itemContext):

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

        def rowset_function(self):
            return self.getTypedRuleContext(tsqlParser.Rowset_functionContext,0)

        def table_alias(self):
            return self.getTypedRuleContext(tsqlParser.Table_aliasContext,0)

        def change_table(self):
            return self.getTypedRuleContext(tsqlParser.Change_tableContext,0)

        def function_call(self):
            return self.getTypedRuleContext(tsqlParser.Function_callContext,0)

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)


    class Table_source_item_complexContext(Table_source_itemContext):

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

        def derived_table(self):
            return self.getTypedRuleContext(tsqlParser.Derived_tableContext,0)

        def table_alias(self):
            return self.getTypedRuleContext(tsqlParser.Table_aliasContext,0)

        def column_alias_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_alias_listContext,0)

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)
        def DOT(self):
            return self.getToken(tsqlParser.DOT, 0)
        def function_call(self):
            return self.getTypedRuleContext(tsqlParser.Function_callContext,0)



    class Table_source_item_nameContext(Table_source_itemContext):

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

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)

        def tablesample_clause(self):
            return self.getTypedRuleContext(tsqlParser.Tablesample_clauseContext,0)

        def table_alias(self):
            return self.getTypedRuleContext(tsqlParser.Table_aliasContext,0)

        def with_table_hints(self):
            return self.getTypedRuleContext(tsqlParser.With_table_hintsContext,0)




    def table_source_item(self):

        localctx = tsqlParser.Table_source_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_table_source_item)
        try:
            self.state = 2688
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,390,self._ctx)
            if la_ == 1:
                localctx = tsqlParser.Table_source_item_nameContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2646
                self.full_table_name()
                self.state = 2648
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,379,self._ctx)
                if la_ == 1:
                    self.state = 2647
                    self.tablesample_clause()


                self.state = 2651
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,380,self._ctx)
                if la_ == 1:
                    self.state = 2650
                    self.table_alias()


                self.state = 2654
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,381,self._ctx)
                if la_ == 1:
                    self.state = 2653
                    self.with_table_hints()


                pass

            elif la_ == 2:
                localctx = tsqlParser.Table_source_item_simpleContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2656
                self.rowset_function()
                self.state = 2658
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,382,self._ctx)
                if la_ == 1:
                    self.state = 2657
                    self.table_alias()


                pass

            elif la_ == 3:
                localctx = tsqlParser.Table_source_item_complexContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2660
                self.derived_table()
                self.state = 2665
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,384,self._ctx)
                if la_ == 1:
                    self.state = 2661
                    self.table_alias()
                    self.state = 2663
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,383,self._ctx)
                    if la_ == 1:
                        self.state = 2662
                        self.column_alias_list()




                pass

            elif la_ == 4:
                localctx = tsqlParser.Table_source_item_simpleContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2667
                self.change_table()
                self.state = 2669
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,385,self._ctx)
                if la_ == 1:
                    self.state = 2668
                    self.table_alias()


                pass

            elif la_ == 5:
                localctx = tsqlParser.Table_source_item_simpleContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2671
                self.function_call()
                self.state = 2673
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,386,self._ctx)
                if la_ == 1:
                    self.state = 2672
                    self.table_alias()


                pass

            elif la_ == 6:
                localctx = tsqlParser.Table_source_item_simpleContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 2675
                self.match(tsqlParser.LOCAL_ID)
                self.state = 2677
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,387,self._ctx)
                if la_ == 1:
                    self.state = 2676
                    self.table_alias()


                pass

            elif la_ == 7:
                localctx = tsqlParser.Table_source_item_complexContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 2679
                self.match(tsqlParser.LOCAL_ID)
                self.state = 2680
                self.match(tsqlParser.DOT)
                self.state = 2681
                self.function_call()
                self.state = 2686
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,389,self._ctx)
                if la_ == 1:
                    self.state = 2682
                    self.table_alias()
                    self.state = 2684
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,388,self._ctx)
                    if la_ == 1:
                        self.state = 2683
                        self.column_alias_list()




                pass


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


    class Tablesample_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TABLESAMPLE(self):
            return self.getToken(tsqlParser.TABLESAMPLE, 0)

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

        def sample_number(self):
            return self.getTypedRuleContext(tsqlParser.Sample_numberContext,0)


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

        def SYSTEM(self):
            return self.getToken(tsqlParser.SYSTEM, 0)

        def REPEATABLE(self):
            return self.getToken(tsqlParser.REPEATABLE, 0)

        def PERCENT(self):
            return self.getToken(tsqlParser.PERCENT, 0)

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

        def repeat_seed(self):
            return self.getTypedRuleContext(tsqlParser.Repeat_seedContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_tablesample_clause




    def tablesample_clause(self):

        localctx = tsqlParser.Tablesample_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_tablesample_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2690
            self.match(tsqlParser.TABLESAMPLE)
            self.state = 2692
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SYSTEM:
                self.state = 2691
                self.match(tsqlParser.SYSTEM)


            self.state = 2694
            self.match(tsqlParser.LR_BRACKET)
            self.state = 2695
            self.sample_number()
            self.state = 2697
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.PERCENT or _la==tsqlParser.ROWS:
                self.state = 2696
                _la = self._input.LA(1)
                if not(_la==tsqlParser.PERCENT or _la==tsqlParser.ROWS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2699
            self.match(tsqlParser.RR_BRACKET)
            self.state = 2702
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,393,self._ctx)
            if la_ == 1:
                self.state = 2700
                self.match(tsqlParser.REPEATABLE)

                self.state = 2701
                self.repeat_seed()


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


    class Sample_numberContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_sample_number




    def sample_number(self):

        localctx = tsqlParser.Sample_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_sample_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2704
            self.match(tsqlParser.DECIMAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Repeat_seedContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_repeat_seed




    def repeat_seed(self):

        localctx = tsqlParser.Repeat_seedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_repeat_seed)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2706
            self.match(tsqlParser.DECIMAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_aliasContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_table_alias




    def table_alias(self):

        localctx = tsqlParser.Table_aliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_table_alias)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2709
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.AS:
                self.state = 2708
                self.match(tsqlParser.AS)


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


    class Change_tableContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHANGETABLE(self):
            return self.getToken(tsqlParser.CHANGETABLE, 0)

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

        def CHANGES(self):
            return self.getToken(tsqlParser.CHANGES, 0)

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


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

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

        def NULL_(self):
            return self.getToken(tsqlParser.NULL_, 0)

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

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_change_table




    def change_table(self):

        localctx = tsqlParser.Change_tableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_change_table)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2713
            self.match(tsqlParser.CHANGETABLE)
            self.state = 2714
            self.match(tsqlParser.LR_BRACKET)
            self.state = 2715
            self.match(tsqlParser.CHANGES)
            self.state = 2716
            self.full_table_name()
            self.state = 2717
            self.match(tsqlParser.COMMA)
            self.state = 2718
            _la = self._input.LA(1)
            if not(_la==tsqlParser.NULL_ or _la==tsqlParser.LOCAL_ID or _la==tsqlParser.DECIMAL):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2719
            self.match(tsqlParser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Join_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

        def LOOP(self):
            return self.getToken(tsqlParser.LOOP, 0)

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

        def MERGE(self):
            return self.getToken(tsqlParser.MERGE, 0)

        def REMOTE(self):
            return self.getToken(tsqlParser.REMOTE, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_join_type




    def join_type(self):

        localctx = tsqlParser.Join_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_join_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2728
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.INNER, tsqlParser.JOIN, tsqlParser.MERGE, tsqlParser.HASH, tsqlParser.LOOP, tsqlParser.REMOTE]:
                self.state = 2722
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.INNER:
                    self.state = 2721
                    self.match(tsqlParser.INNER)


                pass
            elif token in [tsqlParser.FULL, tsqlParser.LEFT, tsqlParser.RIGHT]:
                self.state = 2724
                _la = self._input.LA(1)
                if not(_la==tsqlParser.FULL or _la==tsqlParser.LEFT or _la==tsqlParser.RIGHT):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2726
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.OUTER:
                    self.state = 2725
                    self.match(tsqlParser.OUTER)


                pass
            else:
                raise NoViableAltException(self)

            self.state = 2731
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.MERGE or _la==tsqlParser.HASH or _la==tsqlParser.LOOP or _la==tsqlParser.REMOTE:
                self.state = 2730
                localctx.join_hint = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==tsqlParser.MERGE or _la==tsqlParser.HASH or _la==tsqlParser.LOOP or _la==tsqlParser.REMOTE):
                    localctx.join_hint = 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 Table_name_with_hintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


        def with_table_hints(self):
            return self.getTypedRuleContext(tsqlParser.With_table_hintsContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_table_name_with_hint




    def table_name_with_hint(self):

        localctx = tsqlParser.Table_name_with_hintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_table_name_with_hint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2733
            self.full_table_name()
            self.state = 2735
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,399,self._ctx)
            if la_ == 1:
                self.state = 2734
                self.with_table_hints()


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


    class Rowset_functionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPENROWSET(self):
            return self.getToken(tsqlParser.OPENROWSET, 0)

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

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

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

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

        def BULK(self):
            return self.getToken(tsqlParser.BULK, 0)

        def bulk_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Bulk_optionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Bulk_optionContext,i)


        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_rowset_function




    def rowset_function(self):

        localctx = tsqlParser.Rowset_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_rowset_function)
        self._la = 0 # Token type
        try:
            self.state = 2763
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,402,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2737
                self.match(tsqlParser.OPENROWSET)
                self.state = 2738
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2739
                localctx.provider_name = self.match(tsqlParser.STRING)
                self.state = 2740
                self.match(tsqlParser.COMMA)
                self.state = 2741
                localctx.connectionString = self.match(tsqlParser.STRING)
                self.state = 2742
                self.match(tsqlParser.COMMA)
                self.state = 2743
                localctx.sql = self.match(tsqlParser.STRING)
                self.state = 2744
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2745
                self.match(tsqlParser.OPENROWSET)
                self.state = 2746
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2747
                self.match(tsqlParser.BULK)
                self.state = 2748
                localctx.data_file = self.match(tsqlParser.STRING)
                self.state = 2749
                self.match(tsqlParser.COMMA)
                self.state = 2759
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,401,self._ctx)
                if la_ == 1:
                    self.state = 2750
                    self.bulk_option()
                    self.state = 2755
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==tsqlParser.COMMA:
                        self.state = 2751
                        self.match(tsqlParser.COMMA)
                        self.state = 2752
                        self.bulk_option()
                        self.state = 2757
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass

                elif la_ == 2:
                    self.state = 2758
                    self.r_id()
                    pass


                self.state = 2761
                self.match(tsqlParser.RR_BRACKET)
                pass


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


    class Bulk_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_bulk_option




    def bulk_option(self):

        localctx = tsqlParser.Bulk_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_bulk_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2765
            self.r_id()
            self.state = 2766
            self.match(tsqlParser.EQUAL)
            self.state = 2767
            localctx.bulk_option_value = self._input.LT(1)
            _la = self._input.LA(1)
            if not(_la==tsqlParser.DECIMAL or _la==tsqlParser.STRING):
                localctx.bulk_option_value = 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 Derived_tableContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subquery(self):
            return self.getTypedRuleContext(tsqlParser.SubqueryContext,0)


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

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

        def table_value_constructor(self):
            return self.getTypedRuleContext(tsqlParser.Table_value_constructorContext,0)


        def table_alias(self):
            return self.getTypedRuleContext(tsqlParser.Table_aliasContext,0)


        def column_alias_list(self):
            return self.getTypedRuleContext(tsqlParser.Column_alias_listContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_derived_table




    def derived_table(self):

        localctx = tsqlParser.Derived_tableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_derived_table)
        try:
            self.state = 2780
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,403,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2769
                self.subquery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2770
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2771
                self.subquery()
                self.state = 2772
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2774
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2775
                self.table_value_constructor()
                self.state = 2776
                self.match(tsqlParser.RR_BRACKET)
                self.state = 2777
                self.table_alias()
                self.state = 2778
                self.column_alias_list()
                pass


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


    class Function_callContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return tsqlParser.RULE_function_call

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



    class Standard_callContext(Function_callContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Function_callContext
            super().__init__(parser)
            self.style = None # ExpressionContext
            self.seed = None # Token
            self.increment = None # Token
            self.copyFrom(ctx)

        def scalar_function_name(self):
            return self.getTypedRuleContext(tsqlParser.Scalar_function_nameContext,0)

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)
        def expression_list(self):
            return self.getTypedRuleContext(tsqlParser.Expression_listContext,0)

        def BINARY_CHECKSUM(self):
            return self.getToken(tsqlParser.BINARY_CHECKSUM, 0)
        def STAR(self):
            return self.getToken(tsqlParser.STAR, 0)
        def CONVERT(self):
            return self.getToken(tsqlParser.CONVERT, 0)
        def data_type(self):
            return self.getTypedRuleContext(tsqlParser.Data_typeContext,0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.ExpressionContext,i)

        def COALESCE(self):
            return self.getToken(tsqlParser.COALESCE, 0)
        def DATEADD(self):
            return self.getToken(tsqlParser.DATEADD, 0)
        def ID(self):
            return self.getToken(tsqlParser.ID, 0)
        def DATEDIFF(self):
            return self.getToken(tsqlParser.DATEDIFF, 0)
        def DATENAME(self):
            return self.getToken(tsqlParser.DATENAME, 0)
        def DATEPART(self):
            return self.getToken(tsqlParser.DATEPART, 0)
        def DATETIMEOFFSETFROMPARTS(self):
            return self.getToken(tsqlParser.DATETIMEOFFSETFROMPARTS, 0)
        def IDENTITY(self):
            return self.getToken(tsqlParser.IDENTITY, 0)
        def DECIMAL(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.DECIMAL)
            else:
                return self.getToken(tsqlParser.DECIMAL, i)
        def IIF(self):
            return self.getToken(tsqlParser.IIF, 0)
        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)

        def NULLIF(self):
            return self.getToken(tsqlParser.NULLIF, 0)
        def STRING_SPLIT(self):
            return self.getToken(tsqlParser.STRING_SPLIT, 0)
        def TRY_CONVERT(self):
            return self.getToken(tsqlParser.TRY_CONVERT, 0)


    class Aggregate_callContext(Function_callContext):

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

        def aggregate_windowed_function(self):
            return self.getTypedRuleContext(tsqlParser.Aggregate_windowed_functionContext,0)



    class Nvf_callContext(Function_callContext):

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

        def next_value_for_function(self):
            return self.getTypedRuleContext(tsqlParser.Next_value_for_functionContext,0)



    class Rank_callContext(Function_callContext):

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

        def ranking_windowed_function(self):
            return self.getTypedRuleContext(tsqlParser.Ranking_windowed_functionContext,0)



    class Expression_callContext(Function_callContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Function_callContext
            super().__init__(parser)
            self.left = None # ExpressionContext
            self.alias = None # Data_typeContext
            self.right = None # ExpressionContext
            self.copyFrom(ctx)

        def PARSE(self):
            return self.getToken(tsqlParser.PARSE, 0)
        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def AS(self):
            return self.getToken(tsqlParser.AS, 0)
        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.ExpressionContext,i)

        def data_type(self):
            return self.getTypedRuleContext(tsqlParser.Data_typeContext,0)

        def USING(self):
            return self.getToken(tsqlParser.USING, 0)
        def TRY_PARSE(self):
            return self.getToken(tsqlParser.TRY_PARSE, 0)


    class Simple_callContext(Function_callContext):

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

        def CHECKSUM(self):
            return self.getToken(tsqlParser.CHECKSUM, 0)
        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def STAR(self):
            return self.getToken(tsqlParser.STAR, 0)
        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)
        def CURRENT_TIMESTAMP(self):
            return self.getToken(tsqlParser.CURRENT_TIMESTAMP, 0)
        def CURRENT_USER(self):
            return self.getToken(tsqlParser.CURRENT_USER, 0)
        def MIN_ACTIVE_ROWVERSION(self):
            return self.getToken(tsqlParser.MIN_ACTIVE_ROWVERSION, 0)
        def SESSION_USER(self):
            return self.getToken(tsqlParser.SESSION_USER, 0)
        def SYSTEM_USER(self):
            return self.getToken(tsqlParser.SYSTEM_USER, 0)


    class Cast_callContext(Function_callContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a tsqlParser.Function_callContext
            super().__init__(parser)
            self.alias = None # Data_typeContext
            self.copyFrom(ctx)

        def CAST(self):
            return self.getToken(tsqlParser.CAST, 0)
        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)
        def expression(self):
            return self.getTypedRuleContext(tsqlParser.ExpressionContext,0)

        def AS(self):
            return self.getToken(tsqlParser.AS, 0)
        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)
        def data_type(self):
            return self.getTypedRuleContext(tsqlParser.Data_typeContext,0)

        def TRY_CAST(self):
            return self.getToken(tsqlParser.TRY_CAST, 0)



    def function_call(self):

        localctx = tsqlParser.Function_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_function_call)
        self._la = 0 # Token type
        try:
            self.state = 2955
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,410,self._ctx)
            if la_ == 1:
                localctx = tsqlParser.Rank_callContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2782
                self.ranking_windowed_function()
                pass

            elif la_ == 2:
                localctx = tsqlParser.Aggregate_callContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2783
                self.aggregate_windowed_function()
                pass

            elif la_ == 3:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2784
                self.scalar_function_name()
                self.state = 2785
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2787
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << tsqlParser.CASE) | (1 << tsqlParser.COALESCE) | (1 << tsqlParser.CONVERT) | (1 << tsqlParser.CURRENT_TIMESTAMP) | (1 << tsqlParser.CURRENT_USER) | (1 << tsqlParser.DEFAULT))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (tsqlParser.EXP - 66)) | (1 << (tsqlParser.FILLFACTOR - 66)) | (1 << (tsqlParser.FORCESEEK - 66)) | (1 << (tsqlParser.IDENTITY - 66)) | (1 << (tsqlParser.IIF - 66)) | (1 << (tsqlParser.LEFT - 66)) | (1 << (tsqlParser.LOG - 66)) | (1 << (tsqlParser.LOG10 - 66)) | (1 << (tsqlParser.NEXT - 66)) | (1 << (tsqlParser.NULL_ - 66)) | (1 << (tsqlParser.NULLIF - 66)) | (1 << (tsqlParser.NUMERIC - 66)) | (1 << (tsqlParser.OVER - 66)))) != 0) or ((((_la - 152)) & ~0x3f) == 0 and ((1 << (_la - 152)) & ((1 << (tsqlParser.RIGHT - 152)) | (1 << (tsqlParser.SESSION_USER - 152)) | (1 << (tsqlParser.SIGN - 152)) | (1 << (tsqlParser.SYSTEM_USER - 152)) | (1 << (tsqlParser.TRY_CAST - 152)) | (1 << (tsqlParser.TRY_CONVERT - 152)) | (1 << (tsqlParser.TRY_PARSE - 152)) | (1 << (tsqlParser.VALUE - 152)) | (1 << (tsqlParser.ABSOLUTE - 152)) | (1 << (tsqlParser.APPLY - 152)))) != 0) or ((((_la - 217)) & ~0x3f) == 0 and ((1 << (_la - 217)) & ((1 << (tsqlParser.AUTO - 217)) | (1 << (tsqlParser.AVG - 217)) | (1 << (tsqlParser.BASE64 - 217)) | (1 << (tsqlParser.BINARY_CHECKSUM - 217)) | (1 << (tsqlParser.CALLER - 217)) | (1 << (tsqlParser.CAST - 217)) | (1 << (tsqlParser.CATCH - 217)) | (1 << (tsqlParser.CEILING - 217)) | (1 << (tsqlParser.CHECKSUM - 217)) | (1 << (tsqlParser.CHECKSUM_AGG - 217)) | (1 << (tsqlParser.COMMITTED - 217)) | (1 << (tsqlParser.CONCAT - 217)) | (1 << (tsqlParser.CONTROL - 217)) | (1 << (tsqlParser.COOKIE - 217)) | (1 << (tsqlParser.COS - 217)) | (1 << (tsqlParser.COUNT - 217)) | (1 << (tsqlParser.COUNT_BIG - 217)) | (1 << (tsqlParser.DATE - 217)) | (1 << (tsqlParser.DATEADD - 217)) | (1 << (tsqlParser.DATEDIFF - 217)) | (1 << (tsqlParser.DATENAME - 217)) | (1 << (tsqlParser.DATEPART - 217)) | (1 << (tsqlParser.DATETIMEOFFSETFROMPARTS - 217)) | (1 << (tsqlParser.DELAY - 217)) | (1 << (tsqlParser.DELETED - 217)) | (1 << (tsqlParser.DENSE_RANK - 217)) | (1 << (tsqlParser.DISABLE - 217)) | (1 << (tsqlParser.DYNAMIC - 217)) | (1 << (tsqlParser.ENCRYPTION - 217)) | (1 << (tsqlParser.EXIST - 217)) | (1 << (tsqlParser.EXPAND - 217)) | (1 << (tsqlParser.FAST - 217)) | (1 << (tsqlParser.FAST_FORWARD - 217)))) != 0) or ((((_la - 281)) & ~0x3f) == 0 and ((1 << (_la - 281)) & ((1 << (tsqlParser.FIRST - 281)) | (1 << (tsqlParser.FIRST_VALUE - 281)) | (1 << (tsqlParser.FLOOR - 281)) | (1 << (tsqlParser.FOLLOWING - 281)) | (1 << (tsqlParser.FORCE - 281)) | (1 << (tsqlParser.FORCED - 281)) | (1 << (tsqlParser.FORWARD_ONLY - 281)) | (1 << (tsqlParser.FULLSCAN - 281)) | (1 << (tsqlParser.GLOBAL - 281)) | (1 << (tsqlParser.GROUPING - 281)) | (1 << (tsqlParser.GROUPING_ID - 281)) | (1 << (tsqlParser.HASH - 281)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 281)) | (1 << (tsqlParser.IMPERSONATE - 281)) | (1 << (tsqlParser.INSENSITIVE - 281)) | (1 << (tsqlParser.INSERTED - 281)) | (1 << (tsqlParser.ISOLATION - 281)) | (1 << (tsqlParser.IO - 281)) | (1 << (tsqlParser.KEEP - 281)) | (1 << (tsqlParser.KEEPFIXED - 281)) | (1 << (tsqlParser.KEYSET - 281)) | (1 << (tsqlParser.LAG - 281)) | (1 << (tsqlParser.LAST - 281)) | (1 << (tsqlParser.LAST_VALUE - 281)) | (1 << (tsqlParser.LEAD - 281)) | (1 << (tsqlParser.LEVEL - 281)) | (1 << (tsqlParser.LOCAL - 281)) | (1 << (tsqlParser.LOCK_ESCALATION - 281)) | (1 << (tsqlParser.LOGIN - 281)) | (1 << (tsqlParser.LOOP - 281)) | (1 << (tsqlParser.MARK - 281)) | (1 << (tsqlParser.MAX - 281)) | (1 << (tsqlParser.MAXDOP - 281)) | (1 << (tsqlParser.MAXRECURSION - 281)) | (1 << (tsqlParser.MIN - 281)) | (1 << (tsqlParser.MIN_ACTIVE_ROWVERSION - 281)) | (1 << (tsqlParser.MODIFY - 281)) | (1 << (tsqlParser.NAME - 281)) | (1 << (tsqlParser.NOCOUNT - 281)) | (1 << (tsqlParser.NODES - 281)) | (1 << (tsqlParser.NOEXPAND - 281)) | (1 << (tsqlParser.NORECOMPUTE - 281)) | (1 << (tsqlParser.NTILE - 281)) | (1 << (tsqlParser.NUMBER - 281)))) != 0) or ((((_la - 347)) & ~0x3f) == 0 and ((1 << (_la - 347)) & ((1 << (tsqlParser.OFFSET - 347)) | (1 << (tsqlParser.ONLINE - 347)) | (1 << (tsqlParser.ONLY - 347)) | (1 << (tsqlParser.OPTIMISTIC - 347)) | (1 << (tsqlParser.OPTIMIZE - 347)) | (1 << (tsqlParser.OUT - 347)) | (1 << (tsqlParser.OUTPUT - 347)) | (1 << (tsqlParser.OWNER - 347)) | (1 << (tsqlParser.PARAMETERIZATION - 347)) | (1 << (tsqlParser.PARSE - 347)) | (1 << (tsqlParser.PARTITION - 347)) | (1 << (tsqlParser.PATH - 347)) | (1 << (tsqlParser.PERCENTILE_CONT - 347)) | (1 << (tsqlParser.POWER - 347)) | (1 << (tsqlParser.PRECEDING - 347)) | (1 << (tsqlParser.PRIOR - 347)) | (1 << (tsqlParser.PRIVILEGES - 347)) | (1 << (tsqlParser.QUERY - 347)) | (1 << (tsqlParser.RANGE - 347)) | (1 << (tsqlParser.RANK - 347)) | (1 << (tsqlParser.READONLY - 347)) | (1 << (tsqlParser.READ_ONLY - 347)) | (1 << (tsqlParser.RECOMPILE - 347)) | (1 << (tsqlParser.RELATIVE - 347)) | (1 << (tsqlParser.REMOTE - 347)) | (1 << (tsqlParser.REPEATABLE - 347)) | (1 << (tsqlParser.ROBUST - 347)) | (1 << (tsqlParser.ROOT - 347)) | (1 << (tsqlParser.ROUND - 347)) | (1 << (tsqlParser.ROW - 347)) | (1 << (tsqlParser.ROWGUID - 347)) | (1 << (tsqlParser.ROWS - 347)) | (1 << (tsqlParser.ROW_NUMBER - 347)) | (1 << (tsqlParser.SAMPLE - 347)) | (1 << (tsqlParser.SCHEMABINDING - 347)) | (1 << (tsqlParser.SCROLL - 347)) | (1 << (tsqlParser.SCROLL_LOCKS - 347)) | (1 << (tsqlParser.SELF - 347)) | (1 << (tsqlParser.SERIALIZABLE - 347)) | (1 << (tsqlParser.SIMPLE - 347)) | (1 << (tsqlParser.SIN - 347)) | (1 << (tsqlParser.SIZE - 347)) | (1 << (tsqlParser.SNAPSHOT - 347)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 347)) | (1 << (tsqlParser.STATIC - 347)) | (1 << (tsqlParser.STATS_STREAM - 347)) | (1 << (tsqlParser.STDEV - 347)) | (1 << (tsqlParser.STDEVP - 347)) | (1 << (tsqlParser.STRING_AGG - 347)) | (1 << (tsqlParser.STRING_SPLIT - 347)) | (1 << (tsqlParser.SUM - 347)))) != 0) or ((((_la - 411)) & ~0x3f) == 0 and ((1 << (_la - 411)) & ((1 << (tsqlParser.SQRT - 411)) | (1 << (tsqlParser.SQUARE - 411)) | (1 << (tsqlParser.TAN - 411)) | (1 << (tsqlParser.TEXTIMAGE_ON - 411)) | (1 << (tsqlParser.THROW - 411)) | (1 << (tsqlParser.TIES - 411)) | (1 << (tsqlParser.TIME - 411)) | (1 << (tsqlParser.TRY - 411)) | (1 << (tsqlParser.TYPE - 411)) | (1 << (tsqlParser.TYPE_WARNING - 411)) | (1 << (tsqlParser.UNBOUNDED - 411)) | (1 << (tsqlParser.UNCOMMITTED - 411)) | (1 << (tsqlParser.UNKNOWN - 411)) | (1 << (tsqlParser.USING - 411)) | (1 << (tsqlParser.VAR - 411)) | (1 << (tsqlParser.VARP - 411)) | (1 << (tsqlParser.VIEWS - 411)) | (1 << (tsqlParser.VIEW_METADATA - 411)) | (1 << (tsqlParser.WORK - 411)) | (1 << (tsqlParser.XML - 411)) | (1 << (tsqlParser.XMLNAMESPACES - 411)) | (1 << (tsqlParser.ZONE - 411)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 411)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 411)) | (1 << (tsqlParser.LOCAL_ID - 411)) | (1 << (tsqlParser.DECIMAL - 411)) | (1 << (tsqlParser.ID - 411)) | (1 << (tsqlParser.STRING - 411)) | (1 << (tsqlParser.BINARY - 411)) | (1 << (tsqlParser.FLOAT - 411)) | (1 << (tsqlParser.REAL - 411)) | (1 << (tsqlParser.DOLLAR - 411)) | (1 << (tsqlParser.LR_BRACKET - 411)))) != 0) or ((((_la - 480)) & ~0x3f) == 0 and ((1 << (_la - 480)) & ((1 << (tsqlParser.PLUS - 480)) | (1 << (tsqlParser.MINUS - 480)) | (1 << (tsqlParser.BIT_NOT - 480)))) != 0):
                    self.state = 2786
                    self.expression_list()


                self.state = 2789
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 4:
                localctx = tsqlParser.Nvf_callContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2791
                self.next_value_for_function()
                pass

            elif la_ == 5:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2792
                self.match(tsqlParser.BINARY_CHECKSUM)
                self.state = 2793
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2794
                self.match(tsqlParser.STAR)
                self.state = 2795
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 6:
                localctx = tsqlParser.Cast_callContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 2796
                self.match(tsqlParser.CAST)
                self.state = 2797
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2798
                self.expression(0)
                self.state = 2799
                self.match(tsqlParser.AS)
                self.state = 2800
                localctx.alias = self.data_type()
                self.state = 2801
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 7:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 2803
                self.match(tsqlParser.CONVERT)
                self.state = 2804
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2805
                self.data_type()
                self.state = 2806
                self.match(tsqlParser.COMMA)
                self.state = 2807
                self.expression(0)
                self.state = 2810
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.COMMA:
                    self.state = 2808
                    self.match(tsqlParser.COMMA)
                    self.state = 2809
                    localctx.style = self.expression(0)


                self.state = 2812
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 8:
                localctx = tsqlParser.Simple_callContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 2814
                self.match(tsqlParser.CHECKSUM)
                self.state = 2815
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2816
                self.match(tsqlParser.STAR)
                self.state = 2817
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 9:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 2818
                self.match(tsqlParser.COALESCE)
                self.state = 2819
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2820
                self.expression_list()
                self.state = 2821
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 10:
                localctx = tsqlParser.Simple_callContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 2823
                self.match(tsqlParser.CURRENT_TIMESTAMP)
                pass

            elif la_ == 11:
                localctx = tsqlParser.Simple_callContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 2824
                self.match(tsqlParser.CURRENT_USER)
                pass

            elif la_ == 12:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 2825
                self.match(tsqlParser.DATEADD)
                self.state = 2826
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2827
                self.match(tsqlParser.ID)
                self.state = 2828
                self.match(tsqlParser.COMMA)
                self.state = 2829
                self.expression(0)
                self.state = 2830
                self.match(tsqlParser.COMMA)
                self.state = 2831
                self.expression(0)
                self.state = 2832
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 13:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 2834
                self.match(tsqlParser.DATEDIFF)
                self.state = 2835
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2836
                self.match(tsqlParser.ID)
                self.state = 2837
                self.match(tsqlParser.COMMA)
                self.state = 2838
                self.expression(0)
                self.state = 2839
                self.match(tsqlParser.COMMA)
                self.state = 2840
                self.expression(0)
                self.state = 2841
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 14:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 2843
                self.match(tsqlParser.DATENAME)
                self.state = 2844
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2845
                self.match(tsqlParser.ID)
                self.state = 2846
                self.match(tsqlParser.COMMA)
                self.state = 2847
                self.expression(0)
                self.state = 2848
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 15:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 2850
                self.match(tsqlParser.DATEPART)
                self.state = 2851
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2852
                self.match(tsqlParser.ID)
                self.state = 2853
                self.match(tsqlParser.COMMA)
                self.state = 2854
                self.expression(0)
                self.state = 2855
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 16:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 2857
                self.match(tsqlParser.DATETIMEOFFSETFROMPARTS)
                self.state = 2858
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2859
                self.expression(0)
                self.state = 2860
                self.match(tsqlParser.COMMA)
                self.state = 2861
                self.expression(0)
                self.state = 2862
                self.match(tsqlParser.COMMA)
                self.state = 2863
                self.expression(0)
                self.state = 2864
                self.match(tsqlParser.COMMA)
                self.state = 2865
                self.expression(0)
                self.state = 2866
                self.match(tsqlParser.COMMA)
                self.state = 2867
                self.expression(0)
                self.state = 2868
                self.match(tsqlParser.COMMA)
                self.state = 2869
                self.expression(0)
                self.state = 2870
                self.match(tsqlParser.COMMA)
                self.state = 2871
                self.expression(0)
                self.state = 2872
                self.match(tsqlParser.COMMA)
                self.state = 2873
                self.expression(0)
                self.state = 2874
                self.match(tsqlParser.COMMA)
                self.state = 2875
                self.expression(0)
                self.state = 2876
                self.match(tsqlParser.COMMA)
                self.state = 2877
                self.expression(0)
                self.state = 2878
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 17:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 2880
                self.match(tsqlParser.IDENTITY)
                self.state = 2881
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2882
                self.data_type()
                self.state = 2885
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,406,self._ctx)
                if la_ == 1:
                    self.state = 2883
                    self.match(tsqlParser.COMMA)
                    self.state = 2884
                    localctx.seed = self.match(tsqlParser.DECIMAL)


                self.state = 2889
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.COMMA:
                    self.state = 2887
                    self.match(tsqlParser.COMMA)
                    self.state = 2888
                    localctx.increment = self.match(tsqlParser.DECIMAL)


                self.state = 2891
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 18:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 2893
                self.match(tsqlParser.IIF)
                self.state = 2894
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2895
                self.search_condition(0)
                self.state = 2896
                self.match(tsqlParser.COMMA)
                self.state = 2897
                self.expression(0)
                self.state = 2898
                self.match(tsqlParser.COMMA)
                self.state = 2899
                self.expression(0)
                self.state = 2900
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 19:
                localctx = tsqlParser.Simple_callContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 2902
                self.match(tsqlParser.MIN_ACTIVE_ROWVERSION)
                pass

            elif la_ == 20:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 2903
                self.match(tsqlParser.NULLIF)
                self.state = 2904
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2905
                self.expression(0)
                self.state = 2906
                self.match(tsqlParser.COMMA)
                self.state = 2907
                self.expression(0)
                self.state = 2908
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 21:
                localctx = tsqlParser.Expression_callContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 2910
                self.match(tsqlParser.PARSE)
                self.state = 2911
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2912
                localctx.left = self.expression(0)
                self.state = 2913
                self.match(tsqlParser.AS)
                self.state = 2914
                localctx.alias = self.data_type()
                self.state = 2917
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.USING:
                    self.state = 2915
                    self.match(tsqlParser.USING)
                    self.state = 2916
                    localctx.right = self.expression(0)


                self.state = 2919
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 22:
                localctx = tsqlParser.Simple_callContext(self, localctx)
                self.enterOuterAlt(localctx, 22)
                self.state = 2921
                self.match(tsqlParser.SESSION_USER)
                pass

            elif la_ == 23:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 23)
                self.state = 2922
                self.match(tsqlParser.STRING_SPLIT)
                self.state = 2923
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2924
                self.expression(0)
                self.state = 2925
                self.match(tsqlParser.COMMA)
                self.state = 2926
                self.expression(0)
                self.state = 2927
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 24:
                localctx = tsqlParser.Simple_callContext(self, localctx)
                self.enterOuterAlt(localctx, 24)
                self.state = 2929
                self.match(tsqlParser.SYSTEM_USER)
                pass

            elif la_ == 25:
                localctx = tsqlParser.Standard_callContext(self, localctx)
                self.enterOuterAlt(localctx, 25)
                self.state = 2930
                self.match(tsqlParser.TRY_CONVERT)
                self.state = 2931
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2932
                self.data_type()
                self.state = 2933
                self.match(tsqlParser.COMMA)
                self.state = 2934
                self.expression(0)
                self.state = 2935
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 26:
                localctx = tsqlParser.Cast_callContext(self, localctx)
                self.enterOuterAlt(localctx, 26)
                self.state = 2937
                self.match(tsqlParser.TRY_CAST)
                self.state = 2938
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2939
                self.expression(0)
                self.state = 2940
                self.match(tsqlParser.AS)
                self.state = 2941
                localctx.alias = self.data_type()
                self.state = 2942
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 27:
                localctx = tsqlParser.Expression_callContext(self, localctx)
                self.enterOuterAlt(localctx, 27)
                self.state = 2944
                self.match(tsqlParser.TRY_PARSE)
                self.state = 2945
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2946
                localctx.left = self.expression(0)
                self.state = 2947
                self.match(tsqlParser.AS)
                self.state = 2948
                localctx.alias = self.data_type()
                self.state = 2951
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.USING:
                    self.state = 2949
                    self.match(tsqlParser.USING)
                    self.state = 2950
                    localctx.right = self.expression(0)


                self.state = 2953
                self.match(tsqlParser.RR_BRACKET)
                pass


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


    class Switch_sectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHEN(self):
            return self.getToken(tsqlParser.WHEN, 0)

        def THEN(self):
            return self.getToken(tsqlParser.THEN, 0)

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


        def getRuleIndex(self):
            return tsqlParser.RULE_switch_section




    def switch_section(self):

        localctx = tsqlParser.Switch_sectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_switch_section)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2957
            self.match(tsqlParser.WHEN)
            self.state = 2958
            localctx.whenExpr = self.expression(0)
            self.state = 2959
            self.match(tsqlParser.THEN)
            self.state = 2960
            localctx.thenExpr = self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Switch_search_condition_sectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHEN(self):
            return self.getToken(tsqlParser.WHEN, 0)

        def THEN(self):
            return self.getToken(tsqlParser.THEN, 0)

        def search_condition(self):
            return self.getTypedRuleContext(tsqlParser.Search_conditionContext,0)


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


        def getRuleIndex(self):
            return tsqlParser.RULE_switch_search_condition_section




    def switch_search_condition_section(self):

        localctx = tsqlParser.Switch_search_condition_sectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_switch_search_condition_section)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2962
            self.match(tsqlParser.WHEN)
            self.state = 2963
            localctx.whenExpr = self.search_condition(0)
            self.state = 2964
            self.match(tsqlParser.THEN)
            self.state = 2965
            localctx.thenExpr = self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class With_table_hintsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def table_hint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Table_hintContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Table_hintContext,i)


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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_with_table_hints




    def with_table_hints(self):

        localctx = tsqlParser.With_table_hintsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_with_table_hints)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2968
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 2967
                self.match(tsqlParser.WITH)


            self.state = 2970
            self.match(tsqlParser.LR_BRACKET)
            self.state = 2971
            self.table_hint()
            self.state = 2976
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 2972
                self.match(tsqlParser.COMMA)
                self.state = 2973
                self.table_hint()
                self.state = 2978
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Insert_with_table_hintsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def table_hint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Table_hintContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Table_hintContext,i)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_insert_with_table_hints




    def insert_with_table_hints(self):

        localctx = tsqlParser.Insert_with_table_hintsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_insert_with_table_hints)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2981
            self.match(tsqlParser.WITH)
            self.state = 2982
            self.match(tsqlParser.LR_BRACKET)
            self.state = 2983
            self.table_hint()
            self.state = 2988
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 2984
                self.match(tsqlParser.COMMA)
                self.state = 2985
                self.table_hint()
                self.state = 2990
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Table_hintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NOEXPAND(self):
            return self.getToken(tsqlParser.NOEXPAND, 0)

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

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

        def index_value(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Index_valueContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Index_valueContext,i)


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

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

        def FORCESEEK(self):
            return self.getToken(tsqlParser.FORCESEEK, 0)

        def SERIALIZABLE(self):
            return self.getToken(tsqlParser.SERIALIZABLE, 0)

        def SNAPSHOT(self):
            return self.getToken(tsqlParser.SNAPSHOT, 0)

        def SPATIAL_WINDOW_MAX_CELLS(self):
            return self.getToken(tsqlParser.SPATIAL_WINDOW_MAX_CELLS, 0)

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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_table_hint




    def table_hint(self):

        localctx = tsqlParser.Table_hintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_table_hint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2994
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.NOEXPAND:
                self.state = 2993
                self.match(tsqlParser.NOEXPAND)


            self.state = 3034
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,418,self._ctx)
            if la_ == 1:
                self.state = 2996
                self.match(tsqlParser.INDEX)
                self.state = 2997
                self.match(tsqlParser.LR_BRACKET)
                self.state = 2998
                self.index_value()
                self.state = 3003
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 2999
                    self.match(tsqlParser.COMMA)
                    self.state = 3000
                    self.index_value()
                    self.state = 3005
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 3006
                self.match(tsqlParser.RR_BRACKET)

            elif la_ == 2:
                self.state = 3008
                self.match(tsqlParser.INDEX)
                self.state = 3009
                self.match(tsqlParser.EQUAL)
                self.state = 3010
                self.index_value()

            elif la_ == 3:
                self.state = 3011
                self.match(tsqlParser.FORCESEEK)
                self.state = 3026
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.LR_BRACKET:
                    self.state = 3012
                    self.match(tsqlParser.LR_BRACKET)
                    self.state = 3013
                    self.index_value()
                    self.state = 3014
                    self.match(tsqlParser.LR_BRACKET)
                    self.state = 3015
                    self.match(tsqlParser.ID)
                    self.state = 3020
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==tsqlParser.COMMA:
                        self.state = 3016
                        self.match(tsqlParser.COMMA)
                        self.state = 3017
                        self.match(tsqlParser.ID)
                        self.state = 3022
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 3023
                    self.match(tsqlParser.RR_BRACKET)
                    self.state = 3024
                    self.match(tsqlParser.RR_BRACKET)



            elif la_ == 4:
                self.state = 3028
                self.match(tsqlParser.SERIALIZABLE)

            elif la_ == 5:
                self.state = 3029
                self.match(tsqlParser.SNAPSHOT)

            elif la_ == 6:
                self.state = 3030
                self.match(tsqlParser.SPATIAL_WINDOW_MAX_CELLS)
                self.state = 3031
                self.match(tsqlParser.EQUAL)
                self.state = 3032
                self.match(tsqlParser.DECIMAL)

            elif la_ == 7:
                self.state = 3033
                self.match(tsqlParser.ID)


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


    class Index_valueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_index_value




    def index_value(self):

        localctx = tsqlParser.Index_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_index_value)
        try:
            self.state = 3038
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3036
                self.r_id()
                pass
            elif token in [tsqlParser.DECIMAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3037
                self.match(tsqlParser.DECIMAL)
                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 Column_alias_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def column_alias(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Column_aliasContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Column_aliasContext,i)


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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_column_alias_list




    def column_alias_list(self):

        localctx = tsqlParser.Column_alias_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_column_alias_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3040
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3041
            self.column_alias()
            self.state = 3046
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 3042
                self.match(tsqlParser.COMMA)
                self.state = 3043
                self.column_alias()
                self.state = 3048
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Column_aliasContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_column_alias




    def column_alias(self):

        localctx = tsqlParser.Column_aliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_column_alias)
        try:
            self.state = 3053
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3051
                self.r_id()
                pass
            elif token in [tsqlParser.STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3052
                self.match(tsqlParser.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 A_starContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_a_star




    def a_star(self):

        localctx = tsqlParser.A_starContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_a_star)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3055
            self.match(tsqlParser.STAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_value_constructorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def value_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Value_listContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Value_listContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_table_value_constructor




    def table_value_constructor(self):

        localctx = tsqlParser.Table_value_constructorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_table_value_constructor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3057
            self.match(tsqlParser.VALUES)
            self.state = 3058
            self.value_list()
            self.state = 3063
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,422,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3059
                    self.match(tsqlParser.COMMA)
                    self.state = 3060
                    self.value_list() 
                self.state = 3065
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,422,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 Expression_listContext(ParserRuleContext):
        __slots__ = 'parser'

        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(tsqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_expression_list




    def expression_list(self):

        localctx = tsqlParser.Expression_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_expression_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3066
            self.expression(0)
            self.state = 3071
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 3067
                self.match(tsqlParser.COMMA)
                self.state = 3068
                self.expression(0)
                self.state = 3073
                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 Value_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def expression_list(self):
            return self.getTypedRuleContext(tsqlParser.Expression_listContext,0)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_value_list




    def value_list(self):

        localctx = tsqlParser.Value_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_value_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3074
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3075
            self.expression_list()
            self.state = 3076
            self.match(tsqlParser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Next_value_forContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NEXT(self):
            return self.getToken(tsqlParser.NEXT, 0)

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

        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_next_value_for




    def next_value_for(self):

        localctx = tsqlParser.Next_value_forContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_next_value_for)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3078
            self.match(tsqlParser.NEXT)
            self.state = 3079
            self.match(tsqlParser.VALUE)
            self.state = 3080
            self.match(tsqlParser.FOR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Next_value_for_functionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def next_value_for(self):
            return self.getTypedRuleContext(tsqlParser.Next_value_forContext,0)


        def over_clause(self):
            return self.getTypedRuleContext(tsqlParser.Over_clauseContext,0)


        def func_proc_name(self):
            return self.getTypedRuleContext(tsqlParser.Func_proc_nameContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_next_value_for_function




    def next_value_for_function(self):

        localctx = tsqlParser.Next_value_for_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_next_value_for_function)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3082
            self.next_value_for()
            self.state = 3083
            localctx.args = self.func_proc_name()
            self.state = 3084
            self.over_clause()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ranking_windowed_functionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def over_clause(self):
            return self.getTypedRuleContext(tsqlParser.Over_clauseContext,0)


        def RANK(self):
            return self.getToken(tsqlParser.RANK, 0)

        def DENSE_RANK(self):
            return self.getToken(tsqlParser.DENSE_RANK, 0)

        def ROW_NUMBER(self):
            return self.getToken(tsqlParser.ROW_NUMBER, 0)

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


        def NTILE(self):
            return self.getToken(tsqlParser.NTILE, 0)

        def FIRST_VALUE(self):
            return self.getToken(tsqlParser.FIRST_VALUE, 0)

        def LAST_VALUE(self):
            return self.getToken(tsqlParser.LAST_VALUE, 0)

        def LEAD(self):
            return self.getToken(tsqlParser.LEAD, 0)

        def LAG(self):
            return self.getToken(tsqlParser.LAG, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_ranking_windowed_function




    def ranking_windowed_function(self):

        localctx = tsqlParser.Ranking_windowed_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_ranking_windowed_function)
        self._la = 0 # Token type
        try:
            self.state = 3109
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.DENSE_RANK, tsqlParser.RANK, tsqlParser.ROW_NUMBER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3086
                _la = self._input.LA(1)
                if not(_la==tsqlParser.DENSE_RANK or _la==tsqlParser.RANK or _la==tsqlParser.ROW_NUMBER):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3087
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3088
                self.match(tsqlParser.RR_BRACKET)
                self.state = 3089
                self.over_clause()
                pass
            elif token in [tsqlParser.FIRST_VALUE, tsqlParser.LAST_VALUE, tsqlParser.NTILE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3090
                _la = self._input.LA(1)
                if not(((((_la - 282)) & ~0x3f) == 0 and ((1 << (_la - 282)) & ((1 << (tsqlParser.FIRST_VALUE - 282)) | (1 << (tsqlParser.LAST_VALUE - 282)) | (1 << (tsqlParser.NTILE - 282)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3091
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3092
                self.expression(0)
                self.state = 3093
                self.match(tsqlParser.RR_BRACKET)
                self.state = 3094
                self.over_clause()
                pass
            elif token in [tsqlParser.LAG, tsqlParser.LEAD]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3096
                _la = self._input.LA(1)
                if not(_la==tsqlParser.LAG or _la==tsqlParser.LEAD):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3097
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3098
                self.expression(0)
                self.state = 3103
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 3099
                    self.match(tsqlParser.COMMA)
                    self.state = 3100
                    self.expression(0)
                    self.state = 3105
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 3106
                self.match(tsqlParser.RR_BRACKET)
                self.state = 3107
                self.over_clause()
                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 Aggregate_windowed_functionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def AVG(self):
            return self.getToken(tsqlParser.AVG, 0)

        def MAX(self):
            return self.getToken(tsqlParser.MAX, 0)

        def MIN(self):
            return self.getToken(tsqlParser.MIN, 0)

        def SUM(self):
            return self.getToken(tsqlParser.SUM, 0)

        def STDEV(self):
            return self.getToken(tsqlParser.STDEV, 0)

        def STDEVP(self):
            return self.getToken(tsqlParser.STDEVP, 0)

        def VAR(self):
            return self.getToken(tsqlParser.VAR, 0)

        def VARP(self):
            return self.getToken(tsqlParser.VARP, 0)

        def all_distinct(self):
            return self.getTypedRuleContext(tsqlParser.All_distinctContext,0)


        def over_clause(self):
            return self.getTypedRuleContext(tsqlParser.Over_clauseContext,0)


        def COUNT(self):
            return self.getToken(tsqlParser.COUNT, 0)

        def COUNT_BIG(self):
            return self.getToken(tsqlParser.COUNT_BIG, 0)

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

        def CHECKSUM_AGG(self):
            return self.getToken(tsqlParser.CHECKSUM_AGG, 0)

        def GROUPING(self):
            return self.getToken(tsqlParser.GROUPING, 0)

        def GROUPING_ID(self):
            return self.getToken(tsqlParser.GROUPING_ID, 0)

        def expression_list(self):
            return self.getTypedRuleContext(tsqlParser.Expression_listContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_aggregate_windowed_function




    def aggregate_windowed_function(self):

        localctx = tsqlParser.Aggregate_windowed_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_aggregate_windowed_function)
        self._la = 0 # Token type
        try:
            self.state = 3152
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.AVG, tsqlParser.MAX, tsqlParser.MIN, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.VAR, tsqlParser.VARP]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3111
                _la = self._input.LA(1)
                if not(_la==tsqlParser.AVG or _la==tsqlParser.MAX or _la==tsqlParser.MIN or ((((_la - 406)) & ~0x3f) == 0 and ((1 << (_la - 406)) & ((1 << (tsqlParser.STDEV - 406)) | (1 << (tsqlParser.STDEVP - 406)) | (1 << (tsqlParser.SUM - 406)) | (1 << (tsqlParser.VAR - 406)) | (1 << (tsqlParser.VARP - 406)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3112
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3114
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ALL or _la==tsqlParser.DISTINCT:
                    self.state = 3113
                    self.all_distinct()


                self.state = 3116
                self.expression(0)
                self.state = 3117
                self.match(tsqlParser.RR_BRACKET)
                self.state = 3119
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,427,self._ctx)
                if la_ == 1:
                    self.state = 3118
                    self.over_clause()


                pass
            elif token in [tsqlParser.COUNT, tsqlParser.COUNT_BIG]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3121
                _la = self._input.LA(1)
                if not(_la==tsqlParser.COUNT or _la==tsqlParser.COUNT_BIG):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3122
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3128
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.STAR]:
                    self.state = 3123
                    localctx.args = self.match(tsqlParser.STAR)
                    pass
                elif token in [tsqlParser.ALL, tsqlParser.CASE, tsqlParser.COALESCE, tsqlParser.CONVERT, tsqlParser.CURRENT_TIMESTAMP, tsqlParser.CURRENT_USER, tsqlParser.DEFAULT, tsqlParser.DISTINCT, tsqlParser.EXP, tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.IDENTITY, tsqlParser.IIF, tsqlParser.LEFT, tsqlParser.LOG, tsqlParser.LOG10, tsqlParser.NEXT, tsqlParser.NULL_, tsqlParser.NULLIF, tsqlParser.NUMERIC, tsqlParser.OVER, tsqlParser.RIGHT, tsqlParser.SESSION_USER, tsqlParser.SIGN, tsqlParser.SYSTEM_USER, tsqlParser.TRY_CAST, tsqlParser.TRY_CONVERT, tsqlParser.TRY_PARSE, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.BINARY_CHECKSUM, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CEILING, tsqlParser.CHECKSUM, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COS, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DATEADD, tsqlParser.DATEDIFF, tsqlParser.DATENAME, tsqlParser.DATEPART, tsqlParser.DATETIMEOFFSETFROMPARTS, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FLOOR, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MIN_ACTIVE_ROWVERSION, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARSE, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PERCENTILE_CONT, tsqlParser.POWER, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROUND, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIN, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.STRING_AGG, tsqlParser.STRING_SPLIT, tsqlParser.SUM, tsqlParser.SQRT, tsqlParser.SQUARE, tsqlParser.TAN, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.LOCAL_ID, tsqlParser.DECIMAL, tsqlParser.ID, tsqlParser.STRING, tsqlParser.BINARY, tsqlParser.FLOAT, tsqlParser.REAL, tsqlParser.DOLLAR, tsqlParser.LR_BRACKET, tsqlParser.PLUS, tsqlParser.MINUS, tsqlParser.BIT_NOT]:
                    self.state = 3125
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.ALL or _la==tsqlParser.DISTINCT:
                        self.state = 3124
                        self.all_distinct()


                    self.state = 3127
                    self.expression(0)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 3130
                self.match(tsqlParser.RR_BRACKET)
                self.state = 3132
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,430,self._ctx)
                if la_ == 1:
                    self.state = 3131
                    self.over_clause()


                pass
            elif token in [tsqlParser.CHECKSUM_AGG]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3134
                self.match(tsqlParser.CHECKSUM_AGG)
                self.state = 3135
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3137
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.ALL or _la==tsqlParser.DISTINCT:
                    self.state = 3136
                    self.all_distinct()


                self.state = 3139
                self.expression(0)
                self.state = 3140
                self.match(tsqlParser.RR_BRACKET)
                pass
            elif token in [tsqlParser.GROUPING]:
                self.enterOuterAlt(localctx, 4)
                self.state = 3142
                self.match(tsqlParser.GROUPING)
                self.state = 3143
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3144
                self.expression(0)
                self.state = 3145
                self.match(tsqlParser.RR_BRACKET)
                pass
            elif token in [tsqlParser.GROUPING_ID]:
                self.enterOuterAlt(localctx, 5)
                self.state = 3147
                self.match(tsqlParser.GROUPING_ID)
                self.state = 3148
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3149
                self.expression_list()
                self.state = 3150
                self.match(tsqlParser.RR_BRACKET)
                pass
            else:
                raise NoViableAltException(self)

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


    class All_distinctContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def DISTINCT(self):
            return self.getToken(tsqlParser.DISTINCT, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_all_distinct




    def all_distinct(self):

        localctx = tsqlParser.All_distinctContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_all_distinct)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3154
            _la = self._input.LA(1)
            if not(_la==tsqlParser.ALL or _la==tsqlParser.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 Over_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OVER(self):
            return self.getToken(tsqlParser.OVER, 0)

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

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

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

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

        def expression_list(self):
            return self.getTypedRuleContext(tsqlParser.Expression_listContext,0)


        def order_by_clause(self):
            return self.getTypedRuleContext(tsqlParser.Order_by_clauseContext,0)


        def row_or_range_clause(self):
            return self.getTypedRuleContext(tsqlParser.Row_or_range_clauseContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_over_clause




    def over_clause(self):

        localctx = tsqlParser.Over_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_over_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3156
            self.match(tsqlParser.OVER)
            self.state = 3157
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3161
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.PARTITION:
                self.state = 3158
                self.match(tsqlParser.PARTITION)
                self.state = 3159
                self.match(tsqlParser.BY)
                self.state = 3160
                self.expression_list()


            self.state = 3164
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.ORDER:
                self.state = 3163
                self.order_by_clause()


            self.state = 3167
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.RANGE or _la==tsqlParser.ROWS:
                self.state = 3166
                self.row_or_range_clause()


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


    class Row_or_range_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def window_frame_extent(self):
            return self.getTypedRuleContext(tsqlParser.Window_frame_extentContext,0)


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

        def RANGE(self):
            return self.getToken(tsqlParser.RANGE, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_row_or_range_clause




    def row_or_range_clause(self):

        localctx = tsqlParser.Row_or_range_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_row_or_range_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3171
            _la = self._input.LA(1)
            if not(_la==tsqlParser.RANGE or _la==tsqlParser.ROWS):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 3172
            self.window_frame_extent()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Window_frame_extentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def window_frame_preceding(self):
            return self.getTypedRuleContext(tsqlParser.Window_frame_precedingContext,0)


        def BETWEEN(self):
            return self.getToken(tsqlParser.BETWEEN, 0)

        def window_frame_bound(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Window_frame_boundContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Window_frame_boundContext,i)


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

        def getRuleIndex(self):
            return tsqlParser.RULE_window_frame_extent




    def window_frame_extent(self):

        localctx = tsqlParser.Window_frame_extentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_window_frame_extent)
        try:
            self.state = 3180
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.CURRENT, tsqlParser.UNBOUNDED, tsqlParser.DECIMAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3174
                self.window_frame_preceding()
                pass
            elif token in [tsqlParser.BETWEEN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3175
                self.match(tsqlParser.BETWEEN)
                self.state = 3176
                self.window_frame_bound()
                self.state = 3177
                self.match(tsqlParser.AND)
                self.state = 3178
                self.window_frame_bound()
                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 Window_frame_boundContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def window_frame_preceding(self):
            return self.getTypedRuleContext(tsqlParser.Window_frame_precedingContext,0)


        def window_frame_following(self):
            return self.getTypedRuleContext(tsqlParser.Window_frame_followingContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_window_frame_bound




    def window_frame_bound(self):

        localctx = tsqlParser.Window_frame_boundContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_window_frame_bound)
        try:
            self.state = 3184
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,437,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3182
                self.window_frame_preceding()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3183
                self.window_frame_following()
                pass


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


    class Window_frame_precedingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNBOUNDED(self):
            return self.getToken(tsqlParser.UNBOUNDED, 0)

        def PRECEDING(self):
            return self.getToken(tsqlParser.PRECEDING, 0)

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

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

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

        def getRuleIndex(self):
            return tsqlParser.RULE_window_frame_preceding




    def window_frame_preceding(self):

        localctx = tsqlParser.Window_frame_precedingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_window_frame_preceding)
        try:
            self.state = 3192
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.UNBOUNDED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3186
                self.match(tsqlParser.UNBOUNDED)
                self.state = 3187
                self.match(tsqlParser.PRECEDING)
                pass
            elif token in [tsqlParser.DECIMAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3188
                self.match(tsqlParser.DECIMAL)
                self.state = 3189
                self.match(tsqlParser.PRECEDING)
                pass
            elif token in [tsqlParser.CURRENT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3190
                self.match(tsqlParser.CURRENT)
                self.state = 3191
                self.match(tsqlParser.ROW)
                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 Window_frame_followingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNBOUNDED(self):
            return self.getToken(tsqlParser.UNBOUNDED, 0)

        def FOLLOWING(self):
            return self.getToken(tsqlParser.FOLLOWING, 0)

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

        def getRuleIndex(self):
            return tsqlParser.RULE_window_frame_following




    def window_frame_following(self):

        localctx = tsqlParser.Window_frame_followingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_window_frame_following)
        try:
            self.state = 3198
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.UNBOUNDED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3194
                self.match(tsqlParser.UNBOUNDED)
                self.state = 3195
                self.match(tsqlParser.FOLLOWING)
                pass
            elif token in [tsqlParser.DECIMAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3196
                self.match(tsqlParser.DECIMAL)
                self.state = 3197
                self.match(tsqlParser.FOLLOWING)
                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 Create_database_optionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FILESTREAM(self):
            return self.getToken(tsqlParser.FILESTREAM, 0)

        def database_filestream_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Database_filestream_optionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Database_filestream_optionContext,i)


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

        def DEFAULT_LANGUAGE(self):
            return self.getToken(tsqlParser.DEFAULT_LANGUAGE, 0)

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

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


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

        def DEFAULT_FULLTEXT_LANGUAGE(self):
            return self.getToken(tsqlParser.DEFAULT_FULLTEXT_LANGUAGE, 0)

        def NESTED_TRIGGERS(self):
            return self.getToken(tsqlParser.NESTED_TRIGGERS, 0)

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

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

        def TRANSFORM_NOISE_WORDS(self):
            return self.getToken(tsqlParser.TRANSFORM_NOISE_WORDS, 0)

        def TWO_DIGIT_YEAR_CUTOFF(self):
            return self.getToken(tsqlParser.TWO_DIGIT_YEAR_CUTOFF, 0)

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

        def DB_CHAINING(self):
            return self.getToken(tsqlParser.DB_CHAINING, 0)

        def TRUSTWORTHY(self):
            return self.getToken(tsqlParser.TRUSTWORTHY, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_create_database_option




    def create_database_option(self):

        localctx = tsqlParser.Create_database_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 342, self.RULE_create_database_option)
        self._la = 0 # Token type
        try:
            self.state = 3234
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILESTREAM]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3200
                self.match(tsqlParser.FILESTREAM)

                self.state = 3201
                self.database_filestream_option()
                self.state = 3206
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,440,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 3202
                        self.match(tsqlParser.COMMA)
                        self.state = 3203
                        self.database_filestream_option() 
                    self.state = 3208
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,440,self._ctx)

                pass
            elif token in [tsqlParser.DEFAULT_LANGUAGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3209
                self.match(tsqlParser.DEFAULT_LANGUAGE)
                self.state = 3210
                self.match(tsqlParser.EQUAL)
                self.state = 3213
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                    self.state = 3211
                    self.r_id()
                    pass
                elif token in [tsqlParser.STRING]:
                    self.state = 3212
                    self.match(tsqlParser.STRING)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [tsqlParser.DEFAULT_FULLTEXT_LANGUAGE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3215
                self.match(tsqlParser.DEFAULT_FULLTEXT_LANGUAGE)
                self.state = 3216
                self.match(tsqlParser.EQUAL)
                self.state = 3219
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                    self.state = 3217
                    self.r_id()
                    pass
                elif token in [tsqlParser.STRING]:
                    self.state = 3218
                    self.match(tsqlParser.STRING)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [tsqlParser.NESTED_TRIGGERS]:
                self.enterOuterAlt(localctx, 4)
                self.state = 3221
                self.match(tsqlParser.NESTED_TRIGGERS)
                self.state = 3222
                self.match(tsqlParser.EQUAL)
                self.state = 3223
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.TRANSFORM_NOISE_WORDS]:
                self.enterOuterAlt(localctx, 5)
                self.state = 3224
                self.match(tsqlParser.TRANSFORM_NOISE_WORDS)
                self.state = 3225
                self.match(tsqlParser.EQUAL)
                self.state = 3226
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.TWO_DIGIT_YEAR_CUTOFF]:
                self.enterOuterAlt(localctx, 6)
                self.state = 3227
                self.match(tsqlParser.TWO_DIGIT_YEAR_CUTOFF)
                self.state = 3228
                self.match(tsqlParser.EQUAL)
                self.state = 3229
                self.match(tsqlParser.DECIMAL)
                pass
            elif token in [tsqlParser.DB_CHAINING]:
                self.enterOuterAlt(localctx, 7)
                self.state = 3230
                self.match(tsqlParser.DB_CHAINING)
                self.state = 3231
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.TRUSTWORTHY]:
                self.enterOuterAlt(localctx, 8)
                self.state = 3232
                self.match(tsqlParser.TRUSTWORTHY)
                self.state = 3233
                _la = self._input.LA(1)
                if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                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 Database_filestream_optionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)

        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)

        def NON_TRANSACTED_ACCESS(self):
            return self.getToken(tsqlParser.NON_TRANSACTED_ACCESS, 0)

        def EQUAL(self):
            return self.getToken(tsqlParser.EQUAL, 0)

        def DIRECTORY_NAME(self):
            return self.getToken(tsqlParser.DIRECTORY_NAME, 0)

        def STRING(self):
            return self.getToken(tsqlParser.STRING, 0)

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

        def READ_ONLY(self):
            return self.getToken(tsqlParser.READ_ONLY, 0)

        def FULL(self):
            return self.getToken(tsqlParser.FULL, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_database_filestream_option




    def database_filestream_option(self):

        localctx = tsqlParser.Database_filestream_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_database_filestream_option)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3236
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3243
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.NON_TRANSACTED_ACCESS]:
                self.state = 3237
                self.match(tsqlParser.NON_TRANSACTED_ACCESS)
                self.state = 3238
                self.match(tsqlParser.EQUAL)
                self.state = 3239
                _la = self._input.LA(1)
                if not(_la==tsqlParser.FULL or _la==tsqlParser.OFF or _la==tsqlParser.READ_ONLY):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [tsqlParser.DIRECTORY_NAME]:
                self.state = 3240
                self.match(tsqlParser.DIRECTORY_NAME)
                self.state = 3241
                self.match(tsqlParser.EQUAL)
                self.state = 3242
                self.match(tsqlParser.STRING)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 3245
            self.match(tsqlParser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Database_file_specContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def file_group(self):
            return self.getTypedRuleContext(tsqlParser.File_groupContext,0)


        def file_spec(self):
            return self.getTypedRuleContext(tsqlParser.File_specContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_database_file_spec




    def database_file_spec(self):

        localctx = tsqlParser.Database_file_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_database_file_spec)
        try:
            self.state = 3249
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILEGROUP]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3247
                self.file_group()
                pass
            elif token in [tsqlParser.LR_BRACKET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3248
                self.file_spec()
                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 File_groupContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FILEGROUP(self):
            return self.getToken(tsqlParser.FILEGROUP, 0)

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def file_spec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.File_specContext)
            else:
                return self.getTypedRuleContext(tsqlParser.File_specContext,i)


        def CONTAINS(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.CONTAINS)
            else:
                return self.getToken(tsqlParser.CONTAINS, i)

        def FILESTREAM(self):
            return self.getToken(tsqlParser.FILESTREAM, 0)

        def DEFAULT(self):
            return self.getToken(tsqlParser.DEFAULT, 0)

        def MEMORY_OPTIMIZED_DATA(self):
            return self.getToken(tsqlParser.MEMORY_OPTIMIZED_DATA, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)

        def getRuleIndex(self):
            return tsqlParser.RULE_file_group




    def file_group(self):

        localctx = tsqlParser.File_groupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_file_group)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3251
            self.match(tsqlParser.FILEGROUP)
            self.state = 3252
            self.r_id()
            self.state = 3255
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,446,self._ctx)
            if la_ == 1:
                self.state = 3253
                self.match(tsqlParser.CONTAINS)
                self.state = 3254
                self.match(tsqlParser.FILESTREAM)


            self.state = 3258
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.DEFAULT:
                self.state = 3257
                self.match(tsqlParser.DEFAULT)


            self.state = 3262
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.CONTAINS:
                self.state = 3260
                self.match(tsqlParser.CONTAINS)
                self.state = 3261
                self.match(tsqlParser.MEMORY_OPTIMIZED_DATA)


            self.state = 3264
            self.file_spec()
            self.state = 3269
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,449,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3265
                    self.match(tsqlParser.COMMA)
                    self.state = 3266
                    self.file_spec() 
                self.state = 3271
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,449,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 File_specContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.r_file = None # Token

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)

        def NAME(self):
            return self.getToken(tsqlParser.NAME, 0)

        def EQUAL(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.EQUAL)
            else:
                return self.getToken(tsqlParser.EQUAL, i)

        def FILENAME(self):
            return self.getToken(tsqlParser.FILENAME, 0)

        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)

        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.STRING)
            else:
                return self.getToken(tsqlParser.STRING, i)

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)

        def SIZE(self):
            return self.getToken(tsqlParser.SIZE, 0)

        def file_size(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.File_sizeContext)
            else:
                return self.getTypedRuleContext(tsqlParser.File_sizeContext,i)


        def MAXSIZE(self):
            return self.getToken(tsqlParser.MAXSIZE, 0)

        def FILEGROWTH(self):
            return self.getToken(tsqlParser.FILEGROWTH, 0)

        def UNLIMITED(self):
            return self.getToken(tsqlParser.UNLIMITED, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_file_spec




    def file_spec(self):

        localctx = tsqlParser.File_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_file_spec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3272
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3273
            self.match(tsqlParser.NAME)
            self.state = 3274
            self.match(tsqlParser.EQUAL)
            self.state = 3277
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.state = 3275
                self.r_id()
                pass
            elif token in [tsqlParser.STRING]:
                self.state = 3276
                self.match(tsqlParser.STRING)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 3280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.COMMA:
                self.state = 3279
                self.match(tsqlParser.COMMA)


            self.state = 3282
            self.match(tsqlParser.FILENAME)
            self.state = 3283
            self.match(tsqlParser.EQUAL)
            self.state = 3284
            localctx.r_file = self.match(tsqlParser.STRING)
            self.state = 3286
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.COMMA:
                self.state = 3285
                self.match(tsqlParser.COMMA)


            self.state = 3294
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SIZE:
                self.state = 3288
                self.match(tsqlParser.SIZE)
                self.state = 3289
                self.match(tsqlParser.EQUAL)
                self.state = 3290
                self.file_size()
                self.state = 3292
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.COMMA:
                    self.state = 3291
                    self.match(tsqlParser.COMMA)




            self.state = 3305
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.MAXSIZE:
                self.state = 3296
                self.match(tsqlParser.MAXSIZE)
                self.state = 3297
                self.match(tsqlParser.EQUAL)
                self.state = 3300
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [tsqlParser.DECIMAL]:
                    self.state = 3298
                    self.file_size()
                    pass
                elif token in [tsqlParser.UNLIMITED]:
                    self.state = 3299
                    self.match(tsqlParser.UNLIMITED)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 3303
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.COMMA:
                    self.state = 3302
                    self.match(tsqlParser.COMMA)




            self.state = 3313
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FILEGROWTH:
                self.state = 3307
                self.match(tsqlParser.FILEGROWTH)
                self.state = 3308
                self.match(tsqlParser.EQUAL)
                self.state = 3309
                self.file_size()
                self.state = 3311
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.COMMA:
                    self.state = 3310
                    self.match(tsqlParser.COMMA)




            self.state = 3315
            self.match(tsqlParser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Full_table_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.server = None # R_idContext
            self.database = None # R_idContext
            self.schema = None # R_idContext
            self.table = None # R_idContext

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.DOT)
            else:
                return self.getToken(tsqlParser.DOT, i)

        def getRuleIndex(self):
            return tsqlParser.RULE_full_table_name




    def full_table_name(self):

        localctx = tsqlParser.Full_table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_full_table_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3334
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,461,self._ctx)
            if la_ == 1:
                self.state = 3317
                localctx.server = self.r_id()
                self.state = 3318
                self.match(tsqlParser.DOT)
                self.state = 3319
                localctx.database = self.r_id()
                self.state = 3320
                self.match(tsqlParser.DOT)
                self.state = 3321
                localctx.schema = self.r_id()
                self.state = 3322
                self.match(tsqlParser.DOT)

            elif la_ == 2:
                self.state = 3324
                localctx.database = self.r_id()
                self.state = 3325
                self.match(tsqlParser.DOT)
                self.state = 3327
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (tsqlParser.FILLFACTOR - 71)) | (1 << (tsqlParser.FORCESEEK - 71)) | (1 << (tsqlParser.NEXT - 71)) | (1 << (tsqlParser.NUMERIC - 71)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (tsqlParser.VALUE - 196)) | (1 << (tsqlParser.ABSOLUTE - 196)) | (1 << (tsqlParser.APPLY - 196)) | (1 << (tsqlParser.AUTO - 196)) | (1 << (tsqlParser.AVG - 196)) | (1 << (tsqlParser.BASE64 - 196)) | (1 << (tsqlParser.CALLER - 196)) | (1 << (tsqlParser.CAST - 196)) | (1 << (tsqlParser.CATCH - 196)) | (1 << (tsqlParser.CHECKSUM_AGG - 196)) | (1 << (tsqlParser.COMMITTED - 196)) | (1 << (tsqlParser.CONCAT - 196)) | (1 << (tsqlParser.CONTROL - 196)) | (1 << (tsqlParser.COOKIE - 196)) | (1 << (tsqlParser.COUNT - 196)) | (1 << (tsqlParser.COUNT_BIG - 196)) | (1 << (tsqlParser.DATE - 196)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (tsqlParser.DELAY - 261)) | (1 << (tsqlParser.DELETED - 261)) | (1 << (tsqlParser.DENSE_RANK - 261)) | (1 << (tsqlParser.DISABLE - 261)) | (1 << (tsqlParser.DYNAMIC - 261)) | (1 << (tsqlParser.ENCRYPTION - 261)) | (1 << (tsqlParser.EXIST - 261)) | (1 << (tsqlParser.EXPAND - 261)) | (1 << (tsqlParser.FAST - 261)) | (1 << (tsqlParser.FAST_FORWARD - 261)) | (1 << (tsqlParser.FIRST - 261)) | (1 << (tsqlParser.FIRST_VALUE - 261)) | (1 << (tsqlParser.FOLLOWING - 261)) | (1 << (tsqlParser.FORCE - 261)) | (1 << (tsqlParser.FORCED - 261)) | (1 << (tsqlParser.FORWARD_ONLY - 261)) | (1 << (tsqlParser.FULLSCAN - 261)) | (1 << (tsqlParser.GLOBAL - 261)) | (1 << (tsqlParser.GROUPING - 261)) | (1 << (tsqlParser.GROUPING_ID - 261)) | (1 << (tsqlParser.HASH - 261)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 261)) | (1 << (tsqlParser.IMPERSONATE - 261)) | (1 << (tsqlParser.INSENSITIVE - 261)) | (1 << (tsqlParser.INSERTED - 261)) | (1 << (tsqlParser.ISOLATION - 261)) | (1 << (tsqlParser.IO - 261)) | (1 << (tsqlParser.KEEP - 261)) | (1 << (tsqlParser.KEEPFIXED - 261)) | (1 << (tsqlParser.KEYSET - 261)) | (1 << (tsqlParser.LAG - 261)) | (1 << (tsqlParser.LAST - 261)) | (1 << (tsqlParser.LAST_VALUE - 261)) | (1 << (tsqlParser.LEAD - 261)) | (1 << (tsqlParser.LEVEL - 261)) | (1 << (tsqlParser.LOCAL - 261)) | (1 << (tsqlParser.LOCK_ESCALATION - 261)) | (1 << (tsqlParser.LOGIN - 261)) | (1 << (tsqlParser.LOOP - 261)) | (1 << (tsqlParser.MARK - 261)) | (1 << (tsqlParser.MAX - 261)) | (1 << (tsqlParser.MAXDOP - 261)) | (1 << (tsqlParser.MAXRECURSION - 261)))) != 0) or ((((_la - 328)) & ~0x3f) == 0 and ((1 << (_la - 328)) & ((1 << (tsqlParser.MIN - 328)) | (1 << (tsqlParser.MODIFY - 328)) | (1 << (tsqlParser.NAME - 328)) | (1 << (tsqlParser.NOCOUNT - 328)) | (1 << (tsqlParser.NODES - 328)) | (1 << (tsqlParser.NOEXPAND - 328)) | (1 << (tsqlParser.NORECOMPUTE - 328)) | (1 << (tsqlParser.NTILE - 328)) | (1 << (tsqlParser.NUMBER - 328)) | (1 << (tsqlParser.OFFSET - 328)) | (1 << (tsqlParser.ONLINE - 328)) | (1 << (tsqlParser.ONLY - 328)) | (1 << (tsqlParser.OPTIMISTIC - 328)) | (1 << (tsqlParser.OPTIMIZE - 328)) | (1 << (tsqlParser.OUT - 328)) | (1 << (tsqlParser.OUTPUT - 328)) | (1 << (tsqlParser.OWNER - 328)) | (1 << (tsqlParser.PARAMETERIZATION - 328)) | (1 << (tsqlParser.PARTITION - 328)) | (1 << (tsqlParser.PATH - 328)) | (1 << (tsqlParser.PRECEDING - 328)) | (1 << (tsqlParser.PRIOR - 328)) | (1 << (tsqlParser.PRIVILEGES - 328)) | (1 << (tsqlParser.QUERY - 328)) | (1 << (tsqlParser.RANGE - 328)) | (1 << (tsqlParser.RANK - 328)) | (1 << (tsqlParser.READONLY - 328)) | (1 << (tsqlParser.READ_ONLY - 328)) | (1 << (tsqlParser.RECOMPILE - 328)) | (1 << (tsqlParser.RELATIVE - 328)) | (1 << (tsqlParser.REMOTE - 328)) | (1 << (tsqlParser.REPEATABLE - 328)) | (1 << (tsqlParser.ROBUST - 328)) | (1 << (tsqlParser.ROOT - 328)) | (1 << (tsqlParser.ROW - 328)) | (1 << (tsqlParser.ROWGUID - 328)) | (1 << (tsqlParser.ROWS - 328)) | (1 << (tsqlParser.ROW_NUMBER - 328)) | (1 << (tsqlParser.SAMPLE - 328)) | (1 << (tsqlParser.SCHEMABINDING - 328)) | (1 << (tsqlParser.SCROLL - 328)) | (1 << (tsqlParser.SCROLL_LOCKS - 328)))) != 0) or ((((_la - 393)) & ~0x3f) == 0 and ((1 << (_la - 393)) & ((1 << (tsqlParser.SELF - 393)) | (1 << (tsqlParser.SERIALIZABLE - 393)) | (1 << (tsqlParser.SIMPLE - 393)) | (1 << (tsqlParser.SIZE - 393)) | (1 << (tsqlParser.SNAPSHOT - 393)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 393)) | (1 << (tsqlParser.STATIC - 393)) | (1 << (tsqlParser.STATS_STREAM - 393)) | (1 << (tsqlParser.STDEV - 393)) | (1 << (tsqlParser.STDEVP - 393)) | (1 << (tsqlParser.SUM - 393)) | (1 << (tsqlParser.TEXTIMAGE_ON - 393)) | (1 << (tsqlParser.THROW - 393)) | (1 << (tsqlParser.TIES - 393)) | (1 << (tsqlParser.TIME - 393)) | (1 << (tsqlParser.TRY - 393)) | (1 << (tsqlParser.TYPE - 393)) | (1 << (tsqlParser.TYPE_WARNING - 393)) | (1 << (tsqlParser.UNBOUNDED - 393)) | (1 << (tsqlParser.UNCOMMITTED - 393)) | (1 << (tsqlParser.UNKNOWN - 393)) | (1 << (tsqlParser.USING - 393)) | (1 << (tsqlParser.VAR - 393)) | (1 << (tsqlParser.VARP - 393)) | (1 << (tsqlParser.VIEWS - 393)) | (1 << (tsqlParser.VIEW_METADATA - 393)) | (1 << (tsqlParser.WORK - 393)) | (1 << (tsqlParser.XML - 393)) | (1 << (tsqlParser.XMLNAMESPACES - 393)) | (1 << (tsqlParser.ZONE - 393)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 393)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 393)) | (1 << (tsqlParser.ID - 393)))) != 0):
                    self.state = 3326
                    localctx.schema = self.r_id()


                self.state = 3329
                self.match(tsqlParser.DOT)

            elif la_ == 3:
                self.state = 3331
                localctx.schema = self.r_id()
                self.state = 3332
                self.match(tsqlParser.DOT)


            self.state = 3336
            localctx.table = self.r_id()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simple_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.schema = None # R_idContext
            self.name = None # R_idContext

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def DOT(self):
            return self.getToken(tsqlParser.DOT, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_simple_name




    def simple_name(self):

        localctx = tsqlParser.Simple_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_simple_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3341
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,462,self._ctx)
            if la_ == 1:
                self.state = 3338
                localctx.schema = self.r_id()
                self.state = 3339
                self.match(tsqlParser.DOT)


            self.state = 3343
            localctx.name = self.r_id()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_proc_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.database = None # R_idContext
            self.schema = None # R_idContext
            self.procedure = None # R_idContext

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.DOT)
            else:
                return self.getToken(tsqlParser.DOT, i)

        def getRuleIndex(self):
            return tsqlParser.RULE_func_proc_name




    def func_proc_name(self):

        localctx = tsqlParser.Func_proc_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_func_proc_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3355
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,464,self._ctx)
            if la_ == 1:
                self.state = 3345
                localctx.database = self.r_id()
                self.state = 3346
                self.match(tsqlParser.DOT)
                self.state = 3348
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (tsqlParser.FILLFACTOR - 71)) | (1 << (tsqlParser.FORCESEEK - 71)) | (1 << (tsqlParser.NEXT - 71)) | (1 << (tsqlParser.NUMERIC - 71)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (tsqlParser.VALUE - 196)) | (1 << (tsqlParser.ABSOLUTE - 196)) | (1 << (tsqlParser.APPLY - 196)) | (1 << (tsqlParser.AUTO - 196)) | (1 << (tsqlParser.AVG - 196)) | (1 << (tsqlParser.BASE64 - 196)) | (1 << (tsqlParser.CALLER - 196)) | (1 << (tsqlParser.CAST - 196)) | (1 << (tsqlParser.CATCH - 196)) | (1 << (tsqlParser.CHECKSUM_AGG - 196)) | (1 << (tsqlParser.COMMITTED - 196)) | (1 << (tsqlParser.CONCAT - 196)) | (1 << (tsqlParser.CONTROL - 196)) | (1 << (tsqlParser.COOKIE - 196)) | (1 << (tsqlParser.COUNT - 196)) | (1 << (tsqlParser.COUNT_BIG - 196)) | (1 << (tsqlParser.DATE - 196)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (tsqlParser.DELAY - 261)) | (1 << (tsqlParser.DELETED - 261)) | (1 << (tsqlParser.DENSE_RANK - 261)) | (1 << (tsqlParser.DISABLE - 261)) | (1 << (tsqlParser.DYNAMIC - 261)) | (1 << (tsqlParser.ENCRYPTION - 261)) | (1 << (tsqlParser.EXIST - 261)) | (1 << (tsqlParser.EXPAND - 261)) | (1 << (tsqlParser.FAST - 261)) | (1 << (tsqlParser.FAST_FORWARD - 261)) | (1 << (tsqlParser.FIRST - 261)) | (1 << (tsqlParser.FIRST_VALUE - 261)) | (1 << (tsqlParser.FOLLOWING - 261)) | (1 << (tsqlParser.FORCE - 261)) | (1 << (tsqlParser.FORCED - 261)) | (1 << (tsqlParser.FORWARD_ONLY - 261)) | (1 << (tsqlParser.FULLSCAN - 261)) | (1 << (tsqlParser.GLOBAL - 261)) | (1 << (tsqlParser.GROUPING - 261)) | (1 << (tsqlParser.GROUPING_ID - 261)) | (1 << (tsqlParser.HASH - 261)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 261)) | (1 << (tsqlParser.IMPERSONATE - 261)) | (1 << (tsqlParser.INSENSITIVE - 261)) | (1 << (tsqlParser.INSERTED - 261)) | (1 << (tsqlParser.ISOLATION - 261)) | (1 << (tsqlParser.IO - 261)) | (1 << (tsqlParser.KEEP - 261)) | (1 << (tsqlParser.KEEPFIXED - 261)) | (1 << (tsqlParser.KEYSET - 261)) | (1 << (tsqlParser.LAG - 261)) | (1 << (tsqlParser.LAST - 261)) | (1 << (tsqlParser.LAST_VALUE - 261)) | (1 << (tsqlParser.LEAD - 261)) | (1 << (tsqlParser.LEVEL - 261)) | (1 << (tsqlParser.LOCAL - 261)) | (1 << (tsqlParser.LOCK_ESCALATION - 261)) | (1 << (tsqlParser.LOGIN - 261)) | (1 << (tsqlParser.LOOP - 261)) | (1 << (tsqlParser.MARK - 261)) | (1 << (tsqlParser.MAX - 261)) | (1 << (tsqlParser.MAXDOP - 261)) | (1 << (tsqlParser.MAXRECURSION - 261)))) != 0) or ((((_la - 328)) & ~0x3f) == 0 and ((1 << (_la - 328)) & ((1 << (tsqlParser.MIN - 328)) | (1 << (tsqlParser.MODIFY - 328)) | (1 << (tsqlParser.NAME - 328)) | (1 << (tsqlParser.NOCOUNT - 328)) | (1 << (tsqlParser.NODES - 328)) | (1 << (tsqlParser.NOEXPAND - 328)) | (1 << (tsqlParser.NORECOMPUTE - 328)) | (1 << (tsqlParser.NTILE - 328)) | (1 << (tsqlParser.NUMBER - 328)) | (1 << (tsqlParser.OFFSET - 328)) | (1 << (tsqlParser.ONLINE - 328)) | (1 << (tsqlParser.ONLY - 328)) | (1 << (tsqlParser.OPTIMISTIC - 328)) | (1 << (tsqlParser.OPTIMIZE - 328)) | (1 << (tsqlParser.OUT - 328)) | (1 << (tsqlParser.OUTPUT - 328)) | (1 << (tsqlParser.OWNER - 328)) | (1 << (tsqlParser.PARAMETERIZATION - 328)) | (1 << (tsqlParser.PARTITION - 328)) | (1 << (tsqlParser.PATH - 328)) | (1 << (tsqlParser.PRECEDING - 328)) | (1 << (tsqlParser.PRIOR - 328)) | (1 << (tsqlParser.PRIVILEGES - 328)) | (1 << (tsqlParser.QUERY - 328)) | (1 << (tsqlParser.RANGE - 328)) | (1 << (tsqlParser.RANK - 328)) | (1 << (tsqlParser.READONLY - 328)) | (1 << (tsqlParser.READ_ONLY - 328)) | (1 << (tsqlParser.RECOMPILE - 328)) | (1 << (tsqlParser.RELATIVE - 328)) | (1 << (tsqlParser.REMOTE - 328)) | (1 << (tsqlParser.REPEATABLE - 328)) | (1 << (tsqlParser.ROBUST - 328)) | (1 << (tsqlParser.ROOT - 328)) | (1 << (tsqlParser.ROW - 328)) | (1 << (tsqlParser.ROWGUID - 328)) | (1 << (tsqlParser.ROWS - 328)) | (1 << (tsqlParser.ROW_NUMBER - 328)) | (1 << (tsqlParser.SAMPLE - 328)) | (1 << (tsqlParser.SCHEMABINDING - 328)) | (1 << (tsqlParser.SCROLL - 328)) | (1 << (tsqlParser.SCROLL_LOCKS - 328)))) != 0) or ((((_la - 393)) & ~0x3f) == 0 and ((1 << (_la - 393)) & ((1 << (tsqlParser.SELF - 393)) | (1 << (tsqlParser.SERIALIZABLE - 393)) | (1 << (tsqlParser.SIMPLE - 393)) | (1 << (tsqlParser.SIZE - 393)) | (1 << (tsqlParser.SNAPSHOT - 393)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 393)) | (1 << (tsqlParser.STATIC - 393)) | (1 << (tsqlParser.STATS_STREAM - 393)) | (1 << (tsqlParser.STDEV - 393)) | (1 << (tsqlParser.STDEVP - 393)) | (1 << (tsqlParser.SUM - 393)) | (1 << (tsqlParser.TEXTIMAGE_ON - 393)) | (1 << (tsqlParser.THROW - 393)) | (1 << (tsqlParser.TIES - 393)) | (1 << (tsqlParser.TIME - 393)) | (1 << (tsqlParser.TRY - 393)) | (1 << (tsqlParser.TYPE - 393)) | (1 << (tsqlParser.TYPE_WARNING - 393)) | (1 << (tsqlParser.UNBOUNDED - 393)) | (1 << (tsqlParser.UNCOMMITTED - 393)) | (1 << (tsqlParser.UNKNOWN - 393)) | (1 << (tsqlParser.USING - 393)) | (1 << (tsqlParser.VAR - 393)) | (1 << (tsqlParser.VARP - 393)) | (1 << (tsqlParser.VIEWS - 393)) | (1 << (tsqlParser.VIEW_METADATA - 393)) | (1 << (tsqlParser.WORK - 393)) | (1 << (tsqlParser.XML - 393)) | (1 << (tsqlParser.XMLNAMESPACES - 393)) | (1 << (tsqlParser.ZONE - 393)) | (1 << (tsqlParser.DOUBLE_QUOTE_ID - 393)) | (1 << (tsqlParser.SQUARE_BRACKET_ID - 393)) | (1 << (tsqlParser.ID - 393)))) != 0):
                    self.state = 3347
                    localctx.schema = self.r_id()


                self.state = 3350
                self.match(tsqlParser.DOT)

            elif la_ == 2:
                self.state = 3352
                localctx.schema = self.r_id()
                self.state = 3353
                self.match(tsqlParser.DOT)


            self.state = 3357
            localctx.procedure = self.r_id()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ddl_objectContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_ddl_object




    def ddl_object(self):

        localctx = tsqlParser.Ddl_objectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_ddl_object)
        try:
            self.state = 3361
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3359
                self.full_table_name()
                pass
            elif token in [tsqlParser.LOCAL_ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3360
                self.match(tsqlParser.LOCAL_ID)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Full_column_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.table = None # Full_table_nameContext
            self.name = None # R_idContext

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def DOT(self):
            return self.getToken(tsqlParser.DOT, 0)

        def full_table_name(self):
            return self.getTypedRuleContext(tsqlParser.Full_table_nameContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_full_column_name




    def full_column_name(self):

        localctx = tsqlParser.Full_column_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_full_column_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3366
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,466,self._ctx)
            if la_ == 1:
                self.state = 3363
                localctx.table = self.full_table_name()
                self.state = 3364
                self.match(tsqlParser.DOT)


            self.state = 3368
            localctx.name = self.r_id()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Column_name_listContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def r_id(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.R_idContext)
            else:
                return self.getTypedRuleContext(tsqlParser.R_idContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)

        def getRuleIndex(self):
            return tsqlParser.RULE_column_name_list




    def column_name_list(self):

        localctx = tsqlParser.Column_name_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_column_name_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3370
            self.r_id()
            self.state = 3375
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==tsqlParser.COMMA:
                self.state = 3371
                self.match(tsqlParser.COMMA)
                self.state = 3372
                self.r_id()
                self.state = 3377
                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 Cursor_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_cursor_name




    def cursor_name(self):

        localctx = tsqlParser.Cursor_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_cursor_name)
        try:
            self.state = 3380
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3378
                self.r_id()
                pass
            elif token in [tsqlParser.LOCAL_ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3379
                self.match(tsqlParser.LOCAL_ID)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class On_offContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ON(self):
            return self.getToken(tsqlParser.ON, 0)

        def OFF(self):
            return self.getToken(tsqlParser.OFF, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_on_off




    def on_off(self):

        localctx = tsqlParser.On_offContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_on_off)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3382
            _la = self._input.LA(1)
            if not(_la==tsqlParser.OFF or _la==tsqlParser.ON):
                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 ClusteredContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CLUSTERED(self):
            return self.getToken(tsqlParser.CLUSTERED, 0)

        def NONCLUSTERED(self):
            return self.getToken(tsqlParser.NONCLUSTERED, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_clustered




    def clustered(self):

        localctx = tsqlParser.ClusteredContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_clustered)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3384
            _la = self._input.LA(1)
            if not(_la==tsqlParser.CLUSTERED or _la==tsqlParser.NONCLUSTERED):
                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 Null_notnullContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NULL_(self):
            return self.getToken(tsqlParser.NULL_, 0)

        def NOT(self):
            return self.getToken(tsqlParser.NOT, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_null_notnull




    def null_notnull(self):

        localctx = tsqlParser.Null_notnullContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_null_notnull)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.NOT:
                self.state = 3386
                self.match(tsqlParser.NOT)


            self.state = 3389
            self.match(tsqlParser.NULL_)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Scalar_function_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def func_proc_name(self):
            return self.getTypedRuleContext(tsqlParser.Func_proc_nameContext,0)


        def RIGHT(self):
            return self.getToken(tsqlParser.RIGHT, 0)

        def LEFT(self):
            return self.getToken(tsqlParser.LEFT, 0)

        def BINARY_CHECKSUM(self):
            return self.getToken(tsqlParser.BINARY_CHECKSUM, 0)

        def CHECKSUM(self):
            return self.getToken(tsqlParser.CHECKSUM, 0)

        def EXP(self):
            return self.getToken(tsqlParser.EXP, 0)

        def LOG(self):
            return self.getToken(tsqlParser.LOG, 0)

        def LOG10(self):
            return self.getToken(tsqlParser.LOG10, 0)

        def SQUARE(self):
            return self.getToken(tsqlParser.SQUARE, 0)

        def SQRT(self):
            return self.getToken(tsqlParser.SQRT, 0)

        def ROUND(self):
            return self.getToken(tsqlParser.ROUND, 0)

        def CEILING(self):
            return self.getToken(tsqlParser.CEILING, 0)

        def FLOOR(self):
            return self.getToken(tsqlParser.FLOOR, 0)

        def POWER(self):
            return self.getToken(tsqlParser.POWER, 0)

        def COS(self):
            return self.getToken(tsqlParser.COS, 0)

        def SIN(self):
            return self.getToken(tsqlParser.SIN, 0)

        def TAN(self):
            return self.getToken(tsqlParser.TAN, 0)

        def SIGN(self):
            return self.getToken(tsqlParser.SIGN, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_scalar_function_name




    def scalar_function_name(self):

        localctx = tsqlParser.Scalar_function_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_scalar_function_name)
        try:
            self.state = 3409
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.DOUBLE_QUOTE_ID, tsqlParser.SQUARE_BRACKET_ID, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3391
                self.func_proc_name()
                pass
            elif token in [tsqlParser.RIGHT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3392
                self.match(tsqlParser.RIGHT)
                pass
            elif token in [tsqlParser.LEFT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3393
                self.match(tsqlParser.LEFT)
                pass
            elif token in [tsqlParser.BINARY_CHECKSUM]:
                self.enterOuterAlt(localctx, 4)
                self.state = 3394
                self.match(tsqlParser.BINARY_CHECKSUM)
                pass
            elif token in [tsqlParser.CHECKSUM]:
                self.enterOuterAlt(localctx, 5)
                self.state = 3395
                self.match(tsqlParser.CHECKSUM)
                pass
            elif token in [tsqlParser.EXP]:
                self.enterOuterAlt(localctx, 6)
                self.state = 3396
                self.match(tsqlParser.EXP)
                pass
            elif token in [tsqlParser.LOG]:
                self.enterOuterAlt(localctx, 7)
                self.state = 3397
                self.match(tsqlParser.LOG)
                pass
            elif token in [tsqlParser.LOG10]:
                self.enterOuterAlt(localctx, 8)
                self.state = 3398
                self.match(tsqlParser.LOG10)
                pass
            elif token in [tsqlParser.SQUARE]:
                self.enterOuterAlt(localctx, 9)
                self.state = 3399
                self.match(tsqlParser.SQUARE)
                pass
            elif token in [tsqlParser.SQRT]:
                self.enterOuterAlt(localctx, 10)
                self.state = 3400
                self.match(tsqlParser.SQRT)
                pass
            elif token in [tsqlParser.ROUND]:
                self.enterOuterAlt(localctx, 11)
                self.state = 3401
                self.match(tsqlParser.ROUND)
                pass
            elif token in [tsqlParser.CEILING]:
                self.enterOuterAlt(localctx, 12)
                self.state = 3402
                self.match(tsqlParser.CEILING)
                pass
            elif token in [tsqlParser.FLOOR]:
                self.enterOuterAlt(localctx, 13)
                self.state = 3403
                self.match(tsqlParser.FLOOR)
                pass
            elif token in [tsqlParser.POWER]:
                self.enterOuterAlt(localctx, 14)
                self.state = 3404
                self.match(tsqlParser.POWER)
                pass
            elif token in [tsqlParser.COS]:
                self.enterOuterAlt(localctx, 15)
                self.state = 3405
                self.match(tsqlParser.COS)
                pass
            elif token in [tsqlParser.SIN]:
                self.enterOuterAlt(localctx, 16)
                self.state = 3406
                self.match(tsqlParser.SIN)
                pass
            elif token in [tsqlParser.TAN]:
                self.enterOuterAlt(localctx, 17)
                self.state = 3407
                self.match(tsqlParser.TAN)
                pass
            elif token in [tsqlParser.SIGN]:
                self.enterOuterAlt(localctx, 18)
                self.state = 3408
                self.match(tsqlParser.SIGN)
                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 Default_valueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NULL_(self):
            return self.getToken(tsqlParser.NULL_, 0)

        def constant(self):
            return self.getTypedRuleContext(tsqlParser.ConstantContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_default_value




    def default_value(self):

        localctx = tsqlParser.Default_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_default_value)
        try:
            self.state = 3413
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.NULL_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3411
                self.match(tsqlParser.NULL_)
                pass
            elif token in [tsqlParser.DECIMAL, tsqlParser.STRING, tsqlParser.BINARY, tsqlParser.FLOAT, tsqlParser.REAL, tsqlParser.DOLLAR, tsqlParser.PLUS, tsqlParser.MINUS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3412
                self.constant()
                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 ConstantContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.dollar = None # Token

        def STRING(self):
            return self.getToken(tsqlParser.STRING, 0)

        def BINARY(self):
            return self.getToken(tsqlParser.BINARY, 0)

        def DECIMAL(self):
            return self.getToken(tsqlParser.DECIMAL, 0)

        def sign(self):
            return self.getTypedRuleContext(tsqlParser.SignContext,0)


        def REAL(self):
            return self.getToken(tsqlParser.REAL, 0)

        def FLOAT(self):
            return self.getToken(tsqlParser.FLOAT, 0)

        def DOLLAR(self):
            return self.getToken(tsqlParser.DOLLAR, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_constant




    def constant(self):

        localctx = tsqlParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_constant)
        self._la = 0 # Token type
        try:
            self.state = 3430
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,475,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3415
                self.match(tsqlParser.STRING)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3416
                self.match(tsqlParser.BINARY)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3418
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.PLUS or _la==tsqlParser.MINUS:
                    self.state = 3417
                    self.sign()


                self.state = 3420
                self.match(tsqlParser.DECIMAL)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3422
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.PLUS or _la==tsqlParser.MINUS:
                    self.state = 3421
                    self.sign()


                self.state = 3424
                _la = self._input.LA(1)
                if not(_la==tsqlParser.FLOAT or _la==tsqlParser.REAL):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 3426
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.PLUS or _la==tsqlParser.MINUS:
                    self.state = 3425
                    self.sign()


                self.state = 3428
                localctx.dollar = self.match(tsqlParser.DOLLAR)
                self.state = 3429
                _la = self._input.LA(1)
                if not(_la==tsqlParser.DECIMAL or _la==tsqlParser.FLOAT):
                    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 SignContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PLUS(self):
            return self.getToken(tsqlParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(tsqlParser.MINUS, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_sign




    def sign(self):

        localctx = tsqlParser.SignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_sign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3432
            _la = self._input.LA(1)
            if not(_la==tsqlParser.PLUS or _la==tsqlParser.MINUS):
                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 R_idContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simple_id(self):
            return self.getTypedRuleContext(tsqlParser.Simple_idContext,0)


        def DOUBLE_QUOTE_ID(self):
            return self.getToken(tsqlParser.DOUBLE_QUOTE_ID, 0)

        def SQUARE_BRACKET_ID(self):
            return self.getToken(tsqlParser.SQUARE_BRACKET_ID, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_r_id




    def r_id(self):

        localctx = tsqlParser.R_idContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_r_id)
        try:
            self.state = 3437
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.FILLFACTOR, tsqlParser.FORCESEEK, tsqlParser.NEXT, tsqlParser.NUMERIC, tsqlParser.VALUE, tsqlParser.ABSOLUTE, tsqlParser.APPLY, tsqlParser.AUTO, tsqlParser.AVG, tsqlParser.BASE64, tsqlParser.CALLER, tsqlParser.CAST, tsqlParser.CATCH, tsqlParser.CHECKSUM_AGG, tsqlParser.COMMITTED, tsqlParser.CONCAT, tsqlParser.CONTROL, tsqlParser.COOKIE, tsqlParser.COUNT, tsqlParser.COUNT_BIG, tsqlParser.DATE, tsqlParser.DELAY, tsqlParser.DELETED, tsqlParser.DENSE_RANK, tsqlParser.DISABLE, tsqlParser.DYNAMIC, tsqlParser.ENCRYPTION, tsqlParser.EXIST, tsqlParser.EXPAND, tsqlParser.FAST, tsqlParser.FAST_FORWARD, tsqlParser.FIRST, tsqlParser.FIRST_VALUE, tsqlParser.FOLLOWING, tsqlParser.FORCE, tsqlParser.FORCED, tsqlParser.FORWARD_ONLY, tsqlParser.FULLSCAN, tsqlParser.GLOBAL, tsqlParser.GROUPING, tsqlParser.GROUPING_ID, tsqlParser.HASH, tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, tsqlParser.IMPERSONATE, tsqlParser.INSENSITIVE, tsqlParser.INSERTED, tsqlParser.ISOLATION, tsqlParser.IO, tsqlParser.KEEP, tsqlParser.KEEPFIXED, tsqlParser.KEYSET, tsqlParser.LAG, tsqlParser.LAST, tsqlParser.LAST_VALUE, tsqlParser.LEAD, tsqlParser.LEVEL, tsqlParser.LOCAL, tsqlParser.LOCK_ESCALATION, tsqlParser.LOGIN, tsqlParser.LOOP, tsqlParser.MARK, tsqlParser.MAX, tsqlParser.MAXDOP, tsqlParser.MAXRECURSION, tsqlParser.MIN, tsqlParser.MODIFY, tsqlParser.NAME, tsqlParser.NOCOUNT, tsqlParser.NODES, tsqlParser.NOEXPAND, tsqlParser.NORECOMPUTE, tsqlParser.NTILE, tsqlParser.NUMBER, tsqlParser.OFFSET, tsqlParser.ONLINE, tsqlParser.ONLY, tsqlParser.OPTIMISTIC, tsqlParser.OPTIMIZE, tsqlParser.OUT, tsqlParser.OUTPUT, tsqlParser.OWNER, tsqlParser.PARAMETERIZATION, tsqlParser.PARTITION, tsqlParser.PATH, tsqlParser.PRECEDING, tsqlParser.PRIOR, tsqlParser.PRIVILEGES, tsqlParser.QUERY, tsqlParser.RANGE, tsqlParser.RANK, tsqlParser.READONLY, tsqlParser.READ_ONLY, tsqlParser.RECOMPILE, tsqlParser.RELATIVE, tsqlParser.REMOTE, tsqlParser.REPEATABLE, tsqlParser.ROBUST, tsqlParser.ROOT, tsqlParser.ROW, tsqlParser.ROWGUID, tsqlParser.ROWS, tsqlParser.ROW_NUMBER, tsqlParser.SAMPLE, tsqlParser.SCHEMABINDING, tsqlParser.SCROLL, tsqlParser.SCROLL_LOCKS, tsqlParser.SELF, tsqlParser.SERIALIZABLE, tsqlParser.SIMPLE, tsqlParser.SIZE, tsqlParser.SNAPSHOT, tsqlParser.SPATIAL_WINDOW_MAX_CELLS, tsqlParser.STATIC, tsqlParser.STATS_STREAM, tsqlParser.STDEV, tsqlParser.STDEVP, tsqlParser.SUM, tsqlParser.TEXTIMAGE_ON, tsqlParser.THROW, tsqlParser.TIES, tsqlParser.TIME, tsqlParser.TRY, tsqlParser.TYPE, tsqlParser.TYPE_WARNING, tsqlParser.UNBOUNDED, tsqlParser.UNCOMMITTED, tsqlParser.UNKNOWN, tsqlParser.USING, tsqlParser.VAR, tsqlParser.VARP, tsqlParser.VIEWS, tsqlParser.VIEW_METADATA, tsqlParser.WORK, tsqlParser.XML, tsqlParser.XMLNAMESPACES, tsqlParser.ZONE, tsqlParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3434
                self.simple_id()
                pass
            elif token in [tsqlParser.DOUBLE_QUOTE_ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3435
                self.match(tsqlParser.DOUBLE_QUOTE_ID)
                pass
            elif token in [tsqlParser.SQUARE_BRACKET_ID]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3436
                self.match(tsqlParser.SQUARE_BRACKET_ID)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simple_idContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ID(self):
            return self.getToken(tsqlParser.ID, 0)

        def IO(self):
            return self.getToken(tsqlParser.IO, 0)

        def ABSOLUTE(self):
            return self.getToken(tsqlParser.ABSOLUTE, 0)

        def APPLY(self):
            return self.getToken(tsqlParser.APPLY, 0)

        def AUTO(self):
            return self.getToken(tsqlParser.AUTO, 0)

        def AVG(self):
            return self.getToken(tsqlParser.AVG, 0)

        def BASE64(self):
            return self.getToken(tsqlParser.BASE64, 0)

        def CALLER(self):
            return self.getToken(tsqlParser.CALLER, 0)

        def CAST(self):
            return self.getToken(tsqlParser.CAST, 0)

        def CATCH(self):
            return self.getToken(tsqlParser.CATCH, 0)

        def CHECKSUM_AGG(self):
            return self.getToken(tsqlParser.CHECKSUM_AGG, 0)

        def COMMITTED(self):
            return self.getToken(tsqlParser.COMMITTED, 0)

        def CONCAT(self):
            return self.getToken(tsqlParser.CONCAT, 0)

        def CONTROL(self):
            return self.getToken(tsqlParser.CONTROL, 0)

        def COOKIE(self):
            return self.getToken(tsqlParser.COOKIE, 0)

        def COUNT(self):
            return self.getToken(tsqlParser.COUNT, 0)

        def COUNT_BIG(self):
            return self.getToken(tsqlParser.COUNT_BIG, 0)

        def DATE(self):
            return self.getToken(tsqlParser.DATE, 0)

        def DELAY(self):
            return self.getToken(tsqlParser.DELAY, 0)

        def DELETED(self):
            return self.getToken(tsqlParser.DELETED, 0)

        def DENSE_RANK(self):
            return self.getToken(tsqlParser.DENSE_RANK, 0)

        def DISABLE(self):
            return self.getToken(tsqlParser.DISABLE, 0)

        def DYNAMIC(self):
            return self.getToken(tsqlParser.DYNAMIC, 0)

        def ENCRYPTION(self):
            return self.getToken(tsqlParser.ENCRYPTION, 0)

        def EXIST(self):
            return self.getToken(tsqlParser.EXIST, 0)

        def EXPAND(self):
            return self.getToken(tsqlParser.EXPAND, 0)

        def FAST(self):
            return self.getToken(tsqlParser.FAST, 0)

        def FAST_FORWARD(self):
            return self.getToken(tsqlParser.FAST_FORWARD, 0)

        def FILLFACTOR(self):
            return self.getToken(tsqlParser.FILLFACTOR, 0)

        def FIRST(self):
            return self.getToken(tsqlParser.FIRST, 0)

        def FIRST_VALUE(self):
            return self.getToken(tsqlParser.FIRST_VALUE, 0)

        def FOLLOWING(self):
            return self.getToken(tsqlParser.FOLLOWING, 0)

        def FORCE(self):
            return self.getToken(tsqlParser.FORCE, 0)

        def FORCESEEK(self):
            return self.getToken(tsqlParser.FORCESEEK, 0)

        def FORWARD_ONLY(self):
            return self.getToken(tsqlParser.FORWARD_ONLY, 0)

        def FULLSCAN(self):
            return self.getToken(tsqlParser.FULLSCAN, 0)

        def GLOBAL(self):
            return self.getToken(tsqlParser.GLOBAL, 0)

        def GROUPING(self):
            return self.getToken(tsqlParser.GROUPING, 0)

        def GROUPING_ID(self):
            return self.getToken(tsqlParser.GROUPING_ID, 0)

        def HASH(self):
            return self.getToken(tsqlParser.HASH, 0)

        def IMPERSONATE(self):
            return self.getToken(tsqlParser.IMPERSONATE, 0)

        def INSENSITIVE(self):
            return self.getToken(tsqlParser.INSENSITIVE, 0)

        def INSERTED(self):
            return self.getToken(tsqlParser.INSERTED, 0)

        def ISOLATION(self):
            return self.getToken(tsqlParser.ISOLATION, 0)

        def KEEP(self):
            return self.getToken(tsqlParser.KEEP, 0)

        def KEEPFIXED(self):
            return self.getToken(tsqlParser.KEEPFIXED, 0)

        def FORCED(self):
            return self.getToken(tsqlParser.FORCED, 0)

        def KEYSET(self):
            return self.getToken(tsqlParser.KEYSET, 0)

        def IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX(self):
            return self.getToken(tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, 0)

        def LAG(self):
            return self.getToken(tsqlParser.LAG, 0)

        def LAST(self):
            return self.getToken(tsqlParser.LAST, 0)

        def LAST_VALUE(self):
            return self.getToken(tsqlParser.LAST_VALUE, 0)

        def LEAD(self):
            return self.getToken(tsqlParser.LEAD, 0)

        def LEVEL(self):
            return self.getToken(tsqlParser.LEVEL, 0)

        def LOCAL(self):
            return self.getToken(tsqlParser.LOCAL, 0)

        def LOCK_ESCALATION(self):
            return self.getToken(tsqlParser.LOCK_ESCALATION, 0)

        def LOGIN(self):
            return self.getToken(tsqlParser.LOGIN, 0)

        def LOOP(self):
            return self.getToken(tsqlParser.LOOP, 0)

        def MARK(self):
            return self.getToken(tsqlParser.MARK, 0)

        def MAX(self):
            return self.getToken(tsqlParser.MAX, 0)

        def MAXDOP(self):
            return self.getToken(tsqlParser.MAXDOP, 0)

        def MAXRECURSION(self):
            return self.getToken(tsqlParser.MAXRECURSION, 0)

        def MIN(self):
            return self.getToken(tsqlParser.MIN, 0)

        def MODIFY(self):
            return self.getToken(tsqlParser.MODIFY, 0)

        def NAME(self):
            return self.getToken(tsqlParser.NAME, 0)

        def NEXT(self):
            return self.getToken(tsqlParser.NEXT, 0)

        def NOCOUNT(self):
            return self.getToken(tsqlParser.NOCOUNT, 0)

        def NODES(self):
            return self.getToken(tsqlParser.NODES, 0)

        def NOEXPAND(self):
            return self.getToken(tsqlParser.NOEXPAND, 0)

        def NORECOMPUTE(self):
            return self.getToken(tsqlParser.NORECOMPUTE, 0)

        def NTILE(self):
            return self.getToken(tsqlParser.NTILE, 0)

        def NUMBER(self):
            return self.getToken(tsqlParser.NUMBER, 0)

        def NUMERIC(self):
            return self.getToken(tsqlParser.NUMERIC, 0)

        def OFFSET(self):
            return self.getToken(tsqlParser.OFFSET, 0)

        def ONLINE(self):
            return self.getToken(tsqlParser.ONLINE, 0)

        def ONLY(self):
            return self.getToken(tsqlParser.ONLY, 0)

        def OPTIMISTIC(self):
            return self.getToken(tsqlParser.OPTIMISTIC, 0)

        def OPTIMIZE(self):
            return self.getToken(tsqlParser.OPTIMIZE, 0)

        def OUT(self):
            return self.getToken(tsqlParser.OUT, 0)

        def OUTPUT(self):
            return self.getToken(tsqlParser.OUTPUT, 0)

        def OWNER(self):
            return self.getToken(tsqlParser.OWNER, 0)

        def PARAMETERIZATION(self):
            return self.getToken(tsqlParser.PARAMETERIZATION, 0)

        def PARTITION(self):
            return self.getToken(tsqlParser.PARTITION, 0)

        def PATH(self):
            return self.getToken(tsqlParser.PATH, 0)

        def PRECEDING(self):
            return self.getToken(tsqlParser.PRECEDING, 0)

        def PRIOR(self):
            return self.getToken(tsqlParser.PRIOR, 0)

        def PRIVILEGES(self):
            return self.getToken(tsqlParser.PRIVILEGES, 0)

        def QUERY(self):
            return self.getToken(tsqlParser.QUERY, 0)

        def RANGE(self):
            return self.getToken(tsqlParser.RANGE, 0)

        def RANK(self):
            return self.getToken(tsqlParser.RANK, 0)

        def READONLY(self):
            return self.getToken(tsqlParser.READONLY, 0)

        def READ_ONLY(self):
            return self.getToken(tsqlParser.READ_ONLY, 0)

        def RECOMPILE(self):
            return self.getToken(tsqlParser.RECOMPILE, 0)

        def RELATIVE(self):
            return self.getToken(tsqlParser.RELATIVE, 0)

        def REMOTE(self):
            return self.getToken(tsqlParser.REMOTE, 0)

        def REPEATABLE(self):
            return self.getToken(tsqlParser.REPEATABLE, 0)

        def ROBUST(self):
            return self.getToken(tsqlParser.ROBUST, 0)

        def ROOT(self):
            return self.getToken(tsqlParser.ROOT, 0)

        def ROW(self):
            return self.getToken(tsqlParser.ROW, 0)

        def ROWGUID(self):
            return self.getToken(tsqlParser.ROWGUID, 0)

        def ROWS(self):
            return self.getToken(tsqlParser.ROWS, 0)

        def ROW_NUMBER(self):
            return self.getToken(tsqlParser.ROW_NUMBER, 0)

        def SAMPLE(self):
            return self.getToken(tsqlParser.SAMPLE, 0)

        def SCHEMABINDING(self):
            return self.getToken(tsqlParser.SCHEMABINDING, 0)

        def SCROLL(self):
            return self.getToken(tsqlParser.SCROLL, 0)

        def SCROLL_LOCKS(self):
            return self.getToken(tsqlParser.SCROLL_LOCKS, 0)

        def SELF(self):
            return self.getToken(tsqlParser.SELF, 0)

        def SERIALIZABLE(self):
            return self.getToken(tsqlParser.SERIALIZABLE, 0)

        def SIMPLE(self):
            return self.getToken(tsqlParser.SIMPLE, 0)

        def SIZE(self):
            return self.getToken(tsqlParser.SIZE, 0)

        def SNAPSHOT(self):
            return self.getToken(tsqlParser.SNAPSHOT, 0)

        def SPATIAL_WINDOW_MAX_CELLS(self):
            return self.getToken(tsqlParser.SPATIAL_WINDOW_MAX_CELLS, 0)

        def STATIC(self):
            return self.getToken(tsqlParser.STATIC, 0)

        def STATS_STREAM(self):
            return self.getToken(tsqlParser.STATS_STREAM, 0)

        def STDEV(self):
            return self.getToken(tsqlParser.STDEV, 0)

        def STDEVP(self):
            return self.getToken(tsqlParser.STDEVP, 0)

        def SUM(self):
            return self.getToken(tsqlParser.SUM, 0)

        def TEXTIMAGE_ON(self):
            return self.getToken(tsqlParser.TEXTIMAGE_ON, 0)

        def THROW(self):
            return self.getToken(tsqlParser.THROW, 0)

        def TIES(self):
            return self.getToken(tsqlParser.TIES, 0)

        def TIME(self):
            return self.getToken(tsqlParser.TIME, 0)

        def TRY(self):
            return self.getToken(tsqlParser.TRY, 0)

        def TYPE(self):
            return self.getToken(tsqlParser.TYPE, 0)

        def TYPE_WARNING(self):
            return self.getToken(tsqlParser.TYPE_WARNING, 0)

        def UNBOUNDED(self):
            return self.getToken(tsqlParser.UNBOUNDED, 0)

        def UNCOMMITTED(self):
            return self.getToken(tsqlParser.UNCOMMITTED, 0)

        def UNKNOWN(self):
            return self.getToken(tsqlParser.UNKNOWN, 0)

        def USING(self):
            return self.getToken(tsqlParser.USING, 0)

        def VAR(self):
            return self.getToken(tsqlParser.VAR, 0)

        def VARP(self):
            return self.getToken(tsqlParser.VARP, 0)

        def VALUE(self):
            return self.getToken(tsqlParser.VALUE, 0)

        def VIEW_METADATA(self):
            return self.getToken(tsqlParser.VIEW_METADATA, 0)

        def VIEWS(self):
            return self.getToken(tsqlParser.VIEWS, 0)

        def WORK(self):
            return self.getToken(tsqlParser.WORK, 0)

        def XML(self):
            return self.getToken(tsqlParser.XML, 0)

        def XMLNAMESPACES(self):
            return self.getToken(tsqlParser.XMLNAMESPACES, 0)

        def ZONE(self):
            return self.getToken(tsqlParser.ZONE, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_simple_id




    def simple_id(self):

        localctx = tsqlParser.Simple_idContext(self, self._ctx, self.state)
        self.enterRule(localctx, 382, self.RULE_simple_id)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3439
            _la = self._input.LA(1)
            if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (tsqlParser.FILLFACTOR - 71)) | (1 << (tsqlParser.FORCESEEK - 71)) | (1 << (tsqlParser.NEXT - 71)) | (1 << (tsqlParser.NUMERIC - 71)))) != 0) or ((((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & ((1 << (tsqlParser.VALUE - 196)) | (1 << (tsqlParser.ABSOLUTE - 196)) | (1 << (tsqlParser.APPLY - 196)) | (1 << (tsqlParser.AUTO - 196)) | (1 << (tsqlParser.AVG - 196)) | (1 << (tsqlParser.BASE64 - 196)) | (1 << (tsqlParser.CALLER - 196)) | (1 << (tsqlParser.CAST - 196)) | (1 << (tsqlParser.CATCH - 196)) | (1 << (tsqlParser.CHECKSUM_AGG - 196)) | (1 << (tsqlParser.COMMITTED - 196)) | (1 << (tsqlParser.CONCAT - 196)) | (1 << (tsqlParser.CONTROL - 196)) | (1 << (tsqlParser.COOKIE - 196)) | (1 << (tsqlParser.COUNT - 196)) | (1 << (tsqlParser.COUNT_BIG - 196)) | (1 << (tsqlParser.DATE - 196)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (tsqlParser.DELAY - 261)) | (1 << (tsqlParser.DELETED - 261)) | (1 << (tsqlParser.DENSE_RANK - 261)) | (1 << (tsqlParser.DISABLE - 261)) | (1 << (tsqlParser.DYNAMIC - 261)) | (1 << (tsqlParser.ENCRYPTION - 261)) | (1 << (tsqlParser.EXIST - 261)) | (1 << (tsqlParser.EXPAND - 261)) | (1 << (tsqlParser.FAST - 261)) | (1 << (tsqlParser.FAST_FORWARD - 261)) | (1 << (tsqlParser.FIRST - 261)) | (1 << (tsqlParser.FIRST_VALUE - 261)) | (1 << (tsqlParser.FOLLOWING - 261)) | (1 << (tsqlParser.FORCE - 261)) | (1 << (tsqlParser.FORCED - 261)) | (1 << (tsqlParser.FORWARD_ONLY - 261)) | (1 << (tsqlParser.FULLSCAN - 261)) | (1 << (tsqlParser.GLOBAL - 261)) | (1 << (tsqlParser.GROUPING - 261)) | (1 << (tsqlParser.GROUPING_ID - 261)) | (1 << (tsqlParser.HASH - 261)) | (1 << (tsqlParser.IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX - 261)) | (1 << (tsqlParser.IMPERSONATE - 261)) | (1 << (tsqlParser.INSENSITIVE - 261)) | (1 << (tsqlParser.INSERTED - 261)) | (1 << (tsqlParser.ISOLATION - 261)) | (1 << (tsqlParser.IO - 261)) | (1 << (tsqlParser.KEEP - 261)) | (1 << (tsqlParser.KEEPFIXED - 261)) | (1 << (tsqlParser.KEYSET - 261)) | (1 << (tsqlParser.LAG - 261)) | (1 << (tsqlParser.LAST - 261)) | (1 << (tsqlParser.LAST_VALUE - 261)) | (1 << (tsqlParser.LEAD - 261)) | (1 << (tsqlParser.LEVEL - 261)) | (1 << (tsqlParser.LOCAL - 261)) | (1 << (tsqlParser.LOCK_ESCALATION - 261)) | (1 << (tsqlParser.LOGIN - 261)) | (1 << (tsqlParser.LOOP - 261)) | (1 << (tsqlParser.MARK - 261)) | (1 << (tsqlParser.MAX - 261)) | (1 << (tsqlParser.MAXDOP - 261)) | (1 << (tsqlParser.MAXRECURSION - 261)))) != 0) or ((((_la - 328)) & ~0x3f) == 0 and ((1 << (_la - 328)) & ((1 << (tsqlParser.MIN - 328)) | (1 << (tsqlParser.MODIFY - 328)) | (1 << (tsqlParser.NAME - 328)) | (1 << (tsqlParser.NOCOUNT - 328)) | (1 << (tsqlParser.NODES - 328)) | (1 << (tsqlParser.NOEXPAND - 328)) | (1 << (tsqlParser.NORECOMPUTE - 328)) | (1 << (tsqlParser.NTILE - 328)) | (1 << (tsqlParser.NUMBER - 328)) | (1 << (tsqlParser.OFFSET - 328)) | (1 << (tsqlParser.ONLINE - 328)) | (1 << (tsqlParser.ONLY - 328)) | (1 << (tsqlParser.OPTIMISTIC - 328)) | (1 << (tsqlParser.OPTIMIZE - 328)) | (1 << (tsqlParser.OUT - 328)) | (1 << (tsqlParser.OUTPUT - 328)) | (1 << (tsqlParser.OWNER - 328)) | (1 << (tsqlParser.PARAMETERIZATION - 328)) | (1 << (tsqlParser.PARTITION - 328)) | (1 << (tsqlParser.PATH - 328)) | (1 << (tsqlParser.PRECEDING - 328)) | (1 << (tsqlParser.PRIOR - 328)) | (1 << (tsqlParser.PRIVILEGES - 328)) | (1 << (tsqlParser.QUERY - 328)) | (1 << (tsqlParser.RANGE - 328)) | (1 << (tsqlParser.RANK - 328)) | (1 << (tsqlParser.READONLY - 328)) | (1 << (tsqlParser.READ_ONLY - 328)) | (1 << (tsqlParser.RECOMPILE - 328)) | (1 << (tsqlParser.RELATIVE - 328)) | (1 << (tsqlParser.REMOTE - 328)) | (1 << (tsqlParser.REPEATABLE - 328)) | (1 << (tsqlParser.ROBUST - 328)) | (1 << (tsqlParser.ROOT - 328)) | (1 << (tsqlParser.ROW - 328)) | (1 << (tsqlParser.ROWGUID - 328)) | (1 << (tsqlParser.ROWS - 328)) | (1 << (tsqlParser.ROW_NUMBER - 328)) | (1 << (tsqlParser.SAMPLE - 328)) | (1 << (tsqlParser.SCHEMABINDING - 328)) | (1 << (tsqlParser.SCROLL - 328)) | (1 << (tsqlParser.SCROLL_LOCKS - 328)))) != 0) or ((((_la - 393)) & ~0x3f) == 0 and ((1 << (_la - 393)) & ((1 << (tsqlParser.SELF - 393)) | (1 << (tsqlParser.SERIALIZABLE - 393)) | (1 << (tsqlParser.SIMPLE - 393)) | (1 << (tsqlParser.SIZE - 393)) | (1 << (tsqlParser.SNAPSHOT - 393)) | (1 << (tsqlParser.SPATIAL_WINDOW_MAX_CELLS - 393)) | (1 << (tsqlParser.STATIC - 393)) | (1 << (tsqlParser.STATS_STREAM - 393)) | (1 << (tsqlParser.STDEV - 393)) | (1 << (tsqlParser.STDEVP - 393)) | (1 << (tsqlParser.SUM - 393)) | (1 << (tsqlParser.TEXTIMAGE_ON - 393)) | (1 << (tsqlParser.THROW - 393)) | (1 << (tsqlParser.TIES - 393)) | (1 << (tsqlParser.TIME - 393)) | (1 << (tsqlParser.TRY - 393)) | (1 << (tsqlParser.TYPE - 393)) | (1 << (tsqlParser.TYPE_WARNING - 393)) | (1 << (tsqlParser.UNBOUNDED - 393)) | (1 << (tsqlParser.UNCOMMITTED - 393)) | (1 << (tsqlParser.UNKNOWN - 393)) | (1 << (tsqlParser.USING - 393)) | (1 << (tsqlParser.VAR - 393)) | (1 << (tsqlParser.VARP - 393)) | (1 << (tsqlParser.VIEWS - 393)) | (1 << (tsqlParser.VIEW_METADATA - 393)) | (1 << (tsqlParser.WORK - 393)) | (1 << (tsqlParser.XML - 393)) | (1 << (tsqlParser.XMLNAMESPACES - 393)) | (1 << (tsqlParser.ZONE - 393)) | (1 << (tsqlParser.ID - 393)))) != 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 Comparison_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQUAL(self):
            return self.getToken(tsqlParser.EQUAL, 0)

        def GREATER(self):
            return self.getToken(tsqlParser.GREATER, 0)

        def LESS(self):
            return self.getToken(tsqlParser.LESS, 0)

        def EXCLAMATION(self):
            return self.getToken(tsqlParser.EXCLAMATION, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_comparison_operator




    def comparison_operator(self):

        localctx = tsqlParser.Comparison_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 384, self.RULE_comparison_operator)
        try:
            self.state = 3456
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,477,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3441
                self.match(tsqlParser.EQUAL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3442
                self.match(tsqlParser.GREATER)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3443
                self.match(tsqlParser.LESS)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3444
                self.match(tsqlParser.LESS)
                self.state = 3445
                self.match(tsqlParser.EQUAL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 3446
                self.match(tsqlParser.GREATER)
                self.state = 3447
                self.match(tsqlParser.EQUAL)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 3448
                self.match(tsqlParser.LESS)
                self.state = 3449
                self.match(tsqlParser.GREATER)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 3450
                self.match(tsqlParser.EXCLAMATION)
                self.state = 3451
                self.match(tsqlParser.EQUAL)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 3452
                self.match(tsqlParser.EXCLAMATION)
                self.state = 3453
                self.match(tsqlParser.GREATER)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 3454
                self.match(tsqlParser.EXCLAMATION)
                self.state = 3455
                self.match(tsqlParser.LESS)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Assignment_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PLUS_ASSIGN(self):
            return self.getToken(tsqlParser.PLUS_ASSIGN, 0)

        def MINUS_ASSIGN(self):
            return self.getToken(tsqlParser.MINUS_ASSIGN, 0)

        def MULT_ASSIGN(self):
            return self.getToken(tsqlParser.MULT_ASSIGN, 0)

        def DIV_ASSIGN(self):
            return self.getToken(tsqlParser.DIV_ASSIGN, 0)

        def MOD_ASSIGN(self):
            return self.getToken(tsqlParser.MOD_ASSIGN, 0)

        def AND_ASSIGN(self):
            return self.getToken(tsqlParser.AND_ASSIGN, 0)

        def XOR_ASSIGN(self):
            return self.getToken(tsqlParser.XOR_ASSIGN, 0)

        def OR_ASSIGN(self):
            return self.getToken(tsqlParser.OR_ASSIGN, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_assignment_operator




    def assignment_operator(self):

        localctx = tsqlParser.Assignment_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 386, self.RULE_assignment_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3458
            _la = self._input.LA(1)
            if not(((((_la - 459)) & ~0x3f) == 0 and ((1 << (_la - 459)) & ((1 << (tsqlParser.PLUS_ASSIGN - 459)) | (1 << (tsqlParser.MINUS_ASSIGN - 459)) | (1 << (tsqlParser.MULT_ASSIGN - 459)) | (1 << (tsqlParser.DIV_ASSIGN - 459)) | (1 << (tsqlParser.MOD_ASSIGN - 459)) | (1 << (tsqlParser.AND_ASSIGN - 459)) | (1 << (tsqlParser.XOR_ASSIGN - 459)) | (1 << (tsqlParser.OR_ASSIGN - 459)))) != 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 File_sizeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DECIMAL(self):
            return self.getToken(tsqlParser.DECIMAL, 0)

        def KB(self):
            return self.getToken(tsqlParser.KB, 0)

        def MB(self):
            return self.getToken(tsqlParser.MB, 0)

        def GB(self):
            return self.getToken(tsqlParser.GB, 0)

        def TB(self):
            return self.getToken(tsqlParser.TB, 0)

        def MODULE(self):
            return self.getToken(tsqlParser.MODULE, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_file_size




    def file_size(self):

        localctx = tsqlParser.File_sizeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 388, self.RULE_file_size)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3460
            self.match(tsqlParser.DECIMAL)
            self.state = 3462
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 289)) & ~0x3f) == 0 and ((1 << (_la - 289)) & ((1 << (tsqlParser.GB - 289)) | (1 << (tsqlParser.KB - 289)) | (1 << (tsqlParser.MB - 289)))) != 0) or _la==tsqlParser.TB or _la==tsqlParser.MODULE:
                self.state = 3461
                _la = self._input.LA(1)
                if not(((((_la - 289)) & ~0x3f) == 0 and ((1 << (_la - 289)) & ((1 << (tsqlParser.GB - 289)) | (1 << (tsqlParser.KB - 289)) | (1 << (tsqlParser.MB - 289)))) != 0) or _la==tsqlParser.TB or _la==tsqlParser.MODULE):
                    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 Create_or_alter_procedureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.proc = None # Token

        def func_proc_name(self):
            return self.getTypedRuleContext(tsqlParser.Func_proc_nameContext,0)


        def AS(self):
            return self.getToken(tsqlParser.AS, 0)

        def sql_clauses(self):
            return self.getTypedRuleContext(tsqlParser.Sql_clausesContext,0)


        def ALTER(self):
            return self.getToken(tsqlParser.ALTER, 0)

        def PROC(self):
            return self.getToken(tsqlParser.PROC, 0)

        def PROCEDURE(self):
            return self.getToken(tsqlParser.PROCEDURE, 0)

        def SEMI(self):
            return self.getToken(tsqlParser.SEMI, 0)

        def DECIMAL(self):
            return self.getToken(tsqlParser.DECIMAL, 0)

        def procedure_param(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Procedure_paramContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Procedure_paramContext,i)


        def WITH(self):
            return self.getToken(tsqlParser.WITH, 0)

        def procedure_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Procedure_optionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Procedure_optionContext,i)


        def FOR(self):
            return self.getToken(tsqlParser.FOR, 0)

        def REPLICATION(self):
            return self.getToken(tsqlParser.REPLICATION, 0)

        def CREATE(self):
            return self.getToken(tsqlParser.CREATE, 0)

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)

        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)

        def OR(self):
            return self.getToken(tsqlParser.OR, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_create_or_alter_procedure




    def create_or_alter_procedure(self):

        localctx = tsqlParser.Create_or_alter_procedureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 390, self.RULE_create_or_alter_procedure)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3470
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.CREATE]:
                self.state = 3464
                self.match(tsqlParser.CREATE)
                self.state = 3467
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.OR:
                    self.state = 3465
                    self.match(tsqlParser.OR)
                    self.state = 3466
                    self.match(tsqlParser.ALTER)


                pass
            elif token in [tsqlParser.ALTER]:
                self.state = 3469
                self.match(tsqlParser.ALTER)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 3472
            localctx.proc = self._input.LT(1)
            _la = self._input.LA(1)
            if not(_la==tsqlParser.PROC or _la==tsqlParser.PROCEDURE):
                localctx.proc = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 3473
            self.func_proc_name()
            self.state = 3476
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SEMI:
                self.state = 3474
                self.match(tsqlParser.SEMI)
                self.state = 3475
                self.match(tsqlParser.DECIMAL)


            self.state = 3492
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.LOCAL_ID or _la==tsqlParser.LR_BRACKET:
                self.state = 3479
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.LR_BRACKET:
                    self.state = 3478
                    self.match(tsqlParser.LR_BRACKET)


                self.state = 3481
                self.procedure_param()
                self.state = 3486
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 3482
                    self.match(tsqlParser.COMMA)
                    self.state = 3483
                    self.procedure_param()
                    self.state = 3488
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 3490
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.RR_BRACKET:
                    self.state = 3489
                    self.match(tsqlParser.RR_BRACKET)




            self.state = 3503
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 3494
                self.match(tsqlParser.WITH)
                self.state = 3495
                self.procedure_option()
                self.state = 3500
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 3496
                    self.match(tsqlParser.COMMA)
                    self.state = 3497
                    self.procedure_option()
                    self.state = 3502
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 3507
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.FOR:
                self.state = 3505
                self.match(tsqlParser.FOR)
                self.state = 3506
                self.match(tsqlParser.REPLICATION)


            self.state = 3509
            self.match(tsqlParser.AS)
            self.state = 3510
            self.sql_clauses()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Create_or_alter_functionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FUNCTION(self):
            return self.getToken(tsqlParser.FUNCTION, 0)

        def func_proc_name(self):
            return self.getTypedRuleContext(tsqlParser.Func_proc_nameContext,0)


        def ALTER(self):
            return self.getToken(tsqlParser.ALTER, 0)

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)

        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)

        def func_body_returns_select(self):
            return self.getTypedRuleContext(tsqlParser.Func_body_returns_selectContext,0)


        def func_body_returns_table(self):
            return self.getTypedRuleContext(tsqlParser.Func_body_returns_tableContext,0)


        def func_body_returns_scalar(self):
            return self.getTypedRuleContext(tsqlParser.Func_body_returns_scalarContext,0)


        def SEMI(self):
            return self.getToken(tsqlParser.SEMI, 0)

        def CREATE(self):
            return self.getToken(tsqlParser.CREATE, 0)

        def procedure_param(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Procedure_paramContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Procedure_paramContext,i)


        def OR(self):
            return self.getToken(tsqlParser.OR, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)

        def getRuleIndex(self):
            return tsqlParser.RULE_create_or_alter_function




    def create_or_alter_function(self):

        localctx = tsqlParser.Create_or_alter_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 392, self.RULE_create_or_alter_function)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3518
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.CREATE]:
                self.state = 3512
                self.match(tsqlParser.CREATE)
                self.state = 3515
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.OR:
                    self.state = 3513
                    self.match(tsqlParser.OR)
                    self.state = 3514
                    self.match(tsqlParser.ALTER)


                pass
            elif token in [tsqlParser.ALTER]:
                self.state = 3517
                self.match(tsqlParser.ALTER)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 3520
            self.match(tsqlParser.FUNCTION)
            self.state = 3521
            self.func_proc_name()
            self.state = 3535
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,492,self._ctx)
            if la_ == 1:
                self.state = 3522
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3523
                self.procedure_param()
                self.state = 3528
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 3524
                    self.match(tsqlParser.COMMA)
                    self.state = 3525
                    self.procedure_param()
                    self.state = 3530
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 3531
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 2:
                self.state = 3533
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3534
                self.match(tsqlParser.RR_BRACKET)
                pass


            self.state = 3540
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,493,self._ctx)
            if la_ == 1:
                self.state = 3537
                self.func_body_returns_select()
                pass

            elif la_ == 2:
                self.state = 3538
                self.func_body_returns_table()
                pass

            elif la_ == 3:
                self.state = 3539
                self.func_body_returns_scalar()
                pass


            self.state = 3543
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,494,self._ctx)
            if la_ == 1:
                self.state = 3542
                self.match(tsqlParser.SEMI)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_body_returns_selectContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RETURNS(self):
            return self.getToken(tsqlParser.RETURNS, 0)

        def TABLE(self):
            return self.getToken(tsqlParser.TABLE, 0)

        def RETURN(self):
            return self.getToken(tsqlParser.RETURN, 0)

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)

        def select_statement(self):
            return self.getTypedRuleContext(tsqlParser.Select_statementContext,0)


        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)

        def WITH(self):
            return self.getToken(tsqlParser.WITH, 0)

        def function_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Function_optionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Function_optionContext,i)


        def AS(self):
            return self.getToken(tsqlParser.AS, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)

        def getRuleIndex(self):
            return tsqlParser.RULE_func_body_returns_select




    def func_body_returns_select(self):

        localctx = tsqlParser.Func_body_returns_selectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 394, self.RULE_func_body_returns_select)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3545
            self.match(tsqlParser.RETURNS)
            self.state = 3546
            self.match(tsqlParser.TABLE)
            self.state = 3556
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 3547
                self.match(tsqlParser.WITH)
                self.state = 3548
                self.function_option()
                self.state = 3553
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 3549
                    self.match(tsqlParser.COMMA)
                    self.state = 3550
                    self.function_option()
                    self.state = 3555
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 3559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.AS:
                self.state = 3558
                self.match(tsqlParser.AS)


            self.state = 3561
            self.match(tsqlParser.RETURN)
            self.state = 3567
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,498,self._ctx)
            if la_ == 1:
                self.state = 3562
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3563
                self.select_statement()
                self.state = 3564
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 2:
                self.state = 3566
                self.select_statement()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_body_returns_tableContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RETURNS(self):
            return self.getToken(tsqlParser.RETURNS, 0)

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def table_type_definition(self):
            return self.getTypedRuleContext(tsqlParser.Table_type_definitionContext,0)


        def BEGIN(self):
            return self.getToken(tsqlParser.BEGIN, 0)

        def RETURN(self):
            return self.getToken(tsqlParser.RETURN, 0)

        def END(self):
            return self.getToken(tsqlParser.END, 0)

        def WITH(self):
            return self.getToken(tsqlParser.WITH, 0)

        def function_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Function_optionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Function_optionContext,i)


        def AS(self):
            return self.getToken(tsqlParser.AS, 0)

        def sql_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Sql_clauseContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Sql_clauseContext,i)


        def SEMI(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.SEMI)
            else:
                return self.getToken(tsqlParser.SEMI, i)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)

        def getRuleIndex(self):
            return tsqlParser.RULE_func_body_returns_table




    def func_body_returns_table(self):

        localctx = tsqlParser.Func_body_returns_tableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 396, self.RULE_func_body_returns_table)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3569
            self.match(tsqlParser.RETURNS)
            self.state = 3570
            self.match(tsqlParser.LOCAL_ID)
            self.state = 3571
            self.table_type_definition()
            self.state = 3581
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 3572
                self.match(tsqlParser.WITH)
                self.state = 3573
                self.function_option()
                self.state = 3578
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 3574
                    self.match(tsqlParser.COMMA)
                    self.state = 3575
                    self.function_option()
                    self.state = 3580
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 3584
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.AS:
                self.state = 3583
                self.match(tsqlParser.AS)


            self.state = 3586
            self.match(tsqlParser.BEGIN)
            self.state = 3590
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,502,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3587
                    self.sql_clause() 
                self.state = 3592
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,502,self._ctx)

            self.state = 3593
            self.match(tsqlParser.RETURN)
            self.state = 3595
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SEMI:
                self.state = 3594
                self.match(tsqlParser.SEMI)


            self.state = 3597
            self.match(tsqlParser.END)
            self.state = 3599
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,504,self._ctx)
            if la_ == 1:
                self.state = 3598
                self.match(tsqlParser.SEMI)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_body_returns_scalarContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.ret = None # ExpressionContext

        def RETURNS(self):
            return self.getToken(tsqlParser.RETURNS, 0)

        def data_type(self):
            return self.getTypedRuleContext(tsqlParser.Data_typeContext,0)


        def BEGIN(self):
            return self.getToken(tsqlParser.BEGIN, 0)

        def RETURN(self):
            return self.getToken(tsqlParser.RETURN, 0)

        def END(self):
            return self.getToken(tsqlParser.END, 0)

        def expression(self):
            return self.getTypedRuleContext(tsqlParser.ExpressionContext,0)


        def WITH(self):
            return self.getToken(tsqlParser.WITH, 0)

        def function_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Function_optionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Function_optionContext,i)


        def AS(self):
            return self.getToken(tsqlParser.AS, 0)

        def sql_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.Sql_clauseContext)
            else:
                return self.getTypedRuleContext(tsqlParser.Sql_clauseContext,i)


        def SEMI(self):
            return self.getToken(tsqlParser.SEMI, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.COMMA)
            else:
                return self.getToken(tsqlParser.COMMA, i)

        def getRuleIndex(self):
            return tsqlParser.RULE_func_body_returns_scalar




    def func_body_returns_scalar(self):

        localctx = tsqlParser.Func_body_returns_scalarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 398, self.RULE_func_body_returns_scalar)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3601
            self.match(tsqlParser.RETURNS)
            self.state = 3602
            self.data_type()
            self.state = 3612
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.WITH:
                self.state = 3603
                self.match(tsqlParser.WITH)
                self.state = 3604
                self.function_option()
                self.state = 3609
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==tsqlParser.COMMA:
                    self.state = 3605
                    self.match(tsqlParser.COMMA)
                    self.state = 3606
                    self.function_option()
                    self.state = 3611
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 3615
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.AS:
                self.state = 3614
                self.match(tsqlParser.AS)


            self.state = 3617
            self.match(tsqlParser.BEGIN)
            self.state = 3621
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,508,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3618
                    self.sql_clause() 
                self.state = 3623
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,508,self._ctx)

            self.state = 3624
            self.match(tsqlParser.RETURN)
            self.state = 3625
            localctx.ret = self.expression(0)
            self.state = 3627
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.SEMI:
                self.state = 3626
                self.match(tsqlParser.SEMI)


            self.state = 3629
            self.match(tsqlParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Procedure_paramContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.default_val = None # Default_valueContext

        def LOCAL_ID(self):
            return self.getToken(tsqlParser.LOCAL_ID, 0)

        def data_type(self):
            return self.getTypedRuleContext(tsqlParser.Data_typeContext,0)


        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def DOT(self):
            return self.getToken(tsqlParser.DOT, 0)

        def AS(self):
            return self.getToken(tsqlParser.AS, 0)

        def VARYING(self):
            return self.getToken(tsqlParser.VARYING, 0)

        def EQUAL(self):
            return self.getToken(tsqlParser.EQUAL, 0)

        def default_value(self):
            return self.getTypedRuleContext(tsqlParser.Default_valueContext,0)


        def OUT(self):
            return self.getToken(tsqlParser.OUT, 0)

        def OUTPUT(self):
            return self.getToken(tsqlParser.OUTPUT, 0)

        def READONLY(self):
            return self.getToken(tsqlParser.READONLY, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_procedure_param




    def procedure_param(self):

        localctx = tsqlParser.Procedure_paramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 400, self.RULE_procedure_param)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3631
            self.match(tsqlParser.LOCAL_ID)
            self.state = 3635
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,510,self._ctx)
            if la_ == 1:
                self.state = 3632
                self.r_id()
                self.state = 3633
                self.match(tsqlParser.DOT)


            self.state = 3638
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.AS:
                self.state = 3637
                self.match(tsqlParser.AS)


            self.state = 3640
            self.data_type()
            self.state = 3642
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.VARYING:
                self.state = 3641
                self.match(tsqlParser.VARYING)


            self.state = 3646
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==tsqlParser.EQUAL:
                self.state = 3644
                self.match(tsqlParser.EQUAL)
                self.state = 3645
                localctx.default_val = self.default_value()


            self.state = 3649
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 352)) & ~0x3f) == 0 and ((1 << (_la - 352)) & ((1 << (tsqlParser.OUT - 352)) | (1 << (tsqlParser.OUTPUT - 352)) | (1 << (tsqlParser.READONLY - 352)))) != 0):
                self.state = 3648
                _la = self._input.LA(1)
                if not(((((_la - 352)) & ~0x3f) == 0 and ((1 << (_la - 352)) & ((1 << (tsqlParser.OUT - 352)) | (1 << (tsqlParser.OUTPUT - 352)) | (1 << (tsqlParser.READONLY - 352)))) != 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 Procedure_optionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ENCRYPTION(self):
            return self.getToken(tsqlParser.ENCRYPTION, 0)

        def RECOMPILE(self):
            return self.getToken(tsqlParser.RECOMPILE, 0)

        def execute_clause(self):
            return self.getTypedRuleContext(tsqlParser.Execute_clauseContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_procedure_option




    def procedure_option(self):

        localctx = tsqlParser.Procedure_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 402, self.RULE_procedure_option)
        try:
            self.state = 3654
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.ENCRYPTION]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3651
                self.match(tsqlParser.ENCRYPTION)
                pass
            elif token in [tsqlParser.RECOMPILE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3652
                self.match(tsqlParser.RECOMPILE)
                pass
            elif token in [tsqlParser.EXECUTE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3653
                self.execute_clause()
                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 Function_optionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ENCRYPTION(self):
            return self.getToken(tsqlParser.ENCRYPTION, 0)

        def SCHEMABINDING(self):
            return self.getToken(tsqlParser.SCHEMABINDING, 0)

        def RETURNS(self):
            return self.getToken(tsqlParser.RETURNS, 0)

        def NULL_(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.NULL_)
            else:
                return self.getToken(tsqlParser.NULL_, i)

        def ON(self):
            return self.getToken(tsqlParser.ON, 0)

        def INPUT(self):
            return self.getToken(tsqlParser.INPUT, 0)

        def CALLED(self):
            return self.getToken(tsqlParser.CALLED, 0)

        def execute_clause(self):
            return self.getTypedRuleContext(tsqlParser.Execute_clauseContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_function_option




    def function_option(self):

        localctx = tsqlParser.Function_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 404, self.RULE_function_option)
        try:
            self.state = 3668
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [tsqlParser.ENCRYPTION]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3656
                self.match(tsqlParser.ENCRYPTION)
                pass
            elif token in [tsqlParser.SCHEMABINDING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3657
                self.match(tsqlParser.SCHEMABINDING)
                pass
            elif token in [tsqlParser.RETURNS]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3658
                self.match(tsqlParser.RETURNS)
                self.state = 3659
                self.match(tsqlParser.NULL_)
                self.state = 3660
                self.match(tsqlParser.ON)
                self.state = 3661
                self.match(tsqlParser.NULL_)
                self.state = 3662
                self.match(tsqlParser.INPUT)
                pass
            elif token in [tsqlParser.CALLED]:
                self.enterOuterAlt(localctx, 4)
                self.state = 3663
                self.match(tsqlParser.CALLED)
                self.state = 3664
                self.match(tsqlParser.ON)
                self.state = 3665
                self.match(tsqlParser.NULL_)
                self.state = 3666
                self.match(tsqlParser.INPUT)
                pass
            elif token in [tsqlParser.EXECUTE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 3667
                self.execute_clause()
                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 Percentile_contContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PERCENTILE_CONT(self):
            return self.getToken(tsqlParser.PERCENTILE_CONT, 0)

        def LR_BRACKET(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.LR_BRACKET)
            else:
                return self.getToken(tsqlParser.LR_BRACKET, i)

        def expression(self):
            return self.getTypedRuleContext(tsqlParser.ExpressionContext,0)


        def RR_BRACKET(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.RR_BRACKET)
            else:
                return self.getToken(tsqlParser.RR_BRACKET, i)

        def WITHIN(self):
            return self.getToken(tsqlParser.WITHIN, 0)

        def GROUP(self):
            return self.getToken(tsqlParser.GROUP, 0)

        def order_by_clause(self):
            return self.getTypedRuleContext(tsqlParser.Order_by_clauseContext,0)


        def over_clause(self):
            return self.getTypedRuleContext(tsqlParser.Over_clauseContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_percentile_cont




    def percentile_cont(self):

        localctx = tsqlParser.Percentile_contContext(self, self._ctx, self.state)
        self.enterRule(localctx, 406, self.RULE_percentile_cont)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3670
            self.match(tsqlParser.PERCENTILE_CONT)
            self.state = 3671
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3672
            self.expression(0)
            self.state = 3673
            self.match(tsqlParser.RR_BRACKET)
            self.state = 3674
            self.match(tsqlParser.WITHIN)
            self.state = 3675
            self.match(tsqlParser.GROUP)
            self.state = 3676
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3677
            self.order_by_clause()
            self.state = 3678
            self.match(tsqlParser.RR_BRACKET)
            self.state = 3679
            self.over_clause()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class String_aggContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRING_AGG(self):
            return self.getToken(tsqlParser.STRING_AGG, 0)

        def LR_BRACKET(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.LR_BRACKET)
            else:
                return self.getToken(tsqlParser.LR_BRACKET, i)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(tsqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(tsqlParser.ExpressionContext,i)


        def COMMA(self):
            return self.getToken(tsqlParser.COMMA, 0)

        def RR_BRACKET(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.RR_BRACKET)
            else:
                return self.getToken(tsqlParser.RR_BRACKET, i)

        def WITHIN(self):
            return self.getToken(tsqlParser.WITHIN, 0)

        def GROUP(self):
            return self.getToken(tsqlParser.GROUP, 0)

        def order_by_clause(self):
            return self.getTypedRuleContext(tsqlParser.Order_by_clauseContext,0)


        def getRuleIndex(self):
            return tsqlParser.RULE_string_agg




    def string_agg(self):

        localctx = tsqlParser.String_aggContext(self, self._ctx, self.state)
        self.enterRule(localctx, 408, self.RULE_string_agg)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3681
            self.match(tsqlParser.STRING_AGG)
            self.state = 3682
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3683
            self.expression(0)
            self.state = 3684
            self.match(tsqlParser.COMMA)
            self.state = 3685
            self.expression(0)
            self.state = 3686
            self.match(tsqlParser.RR_BRACKET)
            self.state = 3687
            self.match(tsqlParser.WITHIN)
            self.state = 3688
            self.match(tsqlParser.GROUP)
            self.state = 3689
            self.match(tsqlParser.LR_BRACKET)
            self.state = 3690
            self.order_by_clause()
            self.state = 3691
            self.match(tsqlParser.RR_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Data_typeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def r_id(self):
            return self.getTypedRuleContext(tsqlParser.R_idContext,0)


        def IDENTITY(self):
            return self.getToken(tsqlParser.IDENTITY, 0)

        def LR_BRACKET(self):
            return self.getToken(tsqlParser.LR_BRACKET, 0)

        def RR_BRACKET(self):
            return self.getToken(tsqlParser.RR_BRACKET, 0)

        def DECIMAL(self, i:int=None):
            if i is None:
                return self.getTokens(tsqlParser.DECIMAL)
            else:
                return self.getToken(tsqlParser.DECIMAL, i)

        def MAX(self):
            return self.getToken(tsqlParser.MAX, 0)

        def COMMA(self):
            return self.getToken(tsqlParser.COMMA, 0)

        def DATE(self):
            return self.getToken(tsqlParser.DATE, 0)

        def DATETIME2(self):
            return self.getToken(tsqlParser.DATETIME2, 0)

        def DOUBLE(self):
            return self.getToken(tsqlParser.DOUBLE, 0)

        def PRECISION(self):
            return self.getToken(tsqlParser.PRECISION, 0)

        def INT(self):
            return self.getToken(tsqlParser.INT, 0)

        def TINYINT(self):
            return self.getToken(tsqlParser.TINYINT, 0)

        def SMALLINT(self):
            return self.getToken(tsqlParser.SMALLINT, 0)

        def BIGINT(self):
            return self.getToken(tsqlParser.BIGINT, 0)

        def getRuleIndex(self):
            return tsqlParser.RULE_data_type




    def data_type(self):

        localctx = tsqlParser.Data_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 410, self.RULE_data_type)
        self._la = 0 # Token type
        try:
            self.state = 3719
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,521,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3693
                self.r_id()
                self.state = 3695
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,517,self._ctx)
                if la_ == 1:
                    self.state = 3694
                    self.match(tsqlParser.IDENTITY)


                self.state = 3704
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,519,self._ctx)
                if la_ == 1:
                    self.state = 3697
                    self.match(tsqlParser.LR_BRACKET)
                    self.state = 3698
                    _la = self._input.LA(1)
                    if not(_la==tsqlParser.MAX or _la==tsqlParser.DECIMAL):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 3701
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==tsqlParser.COMMA:
                        self.state = 3699
                        self.match(tsqlParser.COMMA)
                        self.state = 3700
                        self.match(tsqlParser.DECIMAL)


                    self.state = 3703
                    self.match(tsqlParser.RR_BRACKET)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3706
                self.match(tsqlParser.DATE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3707
                self.match(tsqlParser.DATETIME2)
                self.state = 3708
                self.match(tsqlParser.LR_BRACKET)
                self.state = 3709
                self.match(tsqlParser.DECIMAL)
                self.state = 3710
                self.match(tsqlParser.RR_BRACKET)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3711
                self.match(tsqlParser.DOUBLE)
                self.state = 3713
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==tsqlParser.PRECISION:
                    self.state = 3712
                    self.match(tsqlParser.PRECISION)


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 3715
                self.match(tsqlParser.INT)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 3716
                self.match(tsqlParser.TINYINT)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 3717
                self.match(tsqlParser.SMALLINT)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 3718
                self.match(tsqlParser.BIGINT)
                pass


        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[104] = self.expression_sempred
        self._predicates[113] = self.search_condition_sempred
        self._predicates[115] = self.query_expression_sempred
        self._predicates[135] = self.table_source_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 expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 15)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 16)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 1)
         

    def search_condition_sempred(self, localctx:Search_conditionContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 2)
         

    def query_expression_sempred(self, localctx:Query_expressionContext, predIndex:int):
            if predIndex == 8:
                return self.precpred(self._ctx, 2)
         

    def table_source_sempred(self, localctx:Table_sourceContext, predIndex:int):
            if predIndex == 9:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 4)
         




