# Generated from fugue_sql.g4 by ANTLR 4.11.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

def serializedATN():
    return [
        4,1,344,3872,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,
        2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,
        7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,
        2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,
        7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125,
        2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131,
        7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136,
        2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142,
        7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147,
        2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153,
        7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158,
        2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
        7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,
        2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,
        7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,
        2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,
        7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191,7,191,
        2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,2,196,7,196,2,197,
        7,197,2,198,7,198,2,199,7,199,2,200,7,200,2,201,7,201,2,202,7,202,
        2,203,7,203,2,204,7,204,2,205,7,205,2,206,7,206,2,207,7,207,2,208,
        7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,7,212,2,213,7,213,
        2,214,7,214,1,0,4,0,432,8,0,11,0,12,0,433,1,0,1,0,1,1,1,1,1,1,1,
        2,1,2,1,2,1,2,1,2,1,2,3,2,447,8,2,1,3,3,3,450,8,3,1,3,1,3,3,3,454,
        8,3,1,3,3,3,457,8,3,1,3,3,3,460,8,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,
        1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,476,8,4,1,5,1,5,3,5,480,8,5,1,5,
        3,5,483,8,5,1,5,1,5,1,5,3,5,488,8,5,1,6,1,6,3,6,492,8,6,1,6,3,6,
        495,8,6,1,6,1,6,1,7,1,7,1,7,1,7,3,7,503,8,7,1,7,3,7,506,8,7,1,7,
        1,7,3,7,510,8,7,1,7,3,7,513,8,7,1,7,1,7,3,7,517,8,7,1,8,1,8,1,8,
        1,8,1,8,3,8,524,8,8,1,9,1,9,1,9,1,9,1,9,3,9,531,8,9,1,10,1,10,1,
        10,1,10,1,10,3,10,538,8,10,1,10,1,10,3,10,542,8,10,1,11,1,11,1,11,
        1,11,1,11,1,11,1,11,3,11,551,8,11,1,11,1,11,3,11,555,8,11,1,12,1,
        12,1,12,1,12,1,12,3,12,562,8,12,1,13,1,13,3,13,566,8,13,1,13,1,13,
        1,13,3,13,571,8,13,1,13,1,13,3,13,575,8,13,1,13,1,13,1,13,3,13,580,
        8,13,1,14,1,14,1,14,3,14,585,8,14,1,14,1,14,3,14,589,8,14,1,14,1,
        14,1,14,3,14,594,8,14,1,14,1,14,3,14,598,8,14,1,15,1,15,1,15,3,15,
        603,8,15,1,15,1,15,3,15,607,8,15,1,15,1,15,3,15,611,8,15,1,16,1,
        16,1,16,1,17,1,17,3,17,618,8,17,1,17,1,17,1,17,1,17,1,18,1,18,3,
        18,626,8,18,1,18,1,18,3,18,630,8,18,1,18,3,18,633,8,18,1,18,1,18,
        3,18,637,8,18,1,19,1,19,3,19,641,8,19,1,19,3,19,644,8,19,1,19,1,
        19,1,19,3,19,649,8,19,1,20,1,20,1,20,1,20,1,20,3,20,656,8,20,1,20,
        3,20,659,8,20,1,20,1,20,3,20,663,8,20,1,20,1,20,3,20,667,8,20,1,
        20,3,20,670,8,20,1,20,1,20,3,20,674,8,20,3,20,676,8,20,1,21,1,21,
        3,21,680,8,21,1,21,3,21,683,8,21,1,21,1,21,3,21,687,8,21,1,21,3,
        21,690,8,21,1,21,1,21,3,21,694,8,21,1,22,1,22,3,22,698,8,22,1,22,
        3,22,701,8,22,1,22,1,22,1,22,3,22,706,8,22,1,22,1,22,3,22,710,8,
        22,1,23,3,23,713,8,23,1,23,1,23,3,23,717,8,23,1,23,1,23,1,23,3,23,
        722,8,23,1,24,1,24,1,24,3,24,727,8,24,1,25,1,25,1,26,1,26,3,26,733,
        8,26,1,27,1,27,1,28,1,28,1,29,1,29,1,30,1,30,1,30,1,30,5,30,745,
        8,30,10,30,12,30,748,9,30,1,30,1,30,1,31,3,31,753,8,31,1,31,1,31,
        1,31,3,31,758,8,31,1,31,3,31,761,8,31,1,31,3,31,764,8,31,1,31,3,
        31,767,8,31,1,31,1,31,3,31,771,8,31,1,31,3,31,774,8,31,1,31,3,31,
        777,8,31,1,31,3,31,780,8,31,1,31,1,31,1,31,3,31,785,8,31,1,31,3,
        31,788,8,31,1,31,3,31,791,8,31,1,31,3,31,794,8,31,3,31,796,8,31,
        1,32,1,32,1,33,1,33,1,33,1,33,3,33,804,8,33,1,33,1,33,3,33,808,8,
        33,1,33,1,33,1,33,3,33,813,8,33,3,33,815,8,33,1,34,1,34,1,35,1,35,
        1,35,5,35,822,8,35,10,35,12,35,825,9,35,1,35,1,35,1,35,5,35,830,
        8,35,10,35,12,35,833,9,35,3,35,835,8,35,1,36,1,36,1,36,1,36,1,37,
        1,37,3,37,843,8,37,1,37,1,37,1,37,1,37,3,37,849,8,37,1,38,1,38,1,
        38,3,38,854,8,38,1,38,1,38,1,39,1,39,1,39,1,40,1,40,1,41,1,41,1,
        41,3,41,866,8,41,1,41,1,41,3,41,870,8,41,1,42,1,42,1,42,3,42,875,
        8,42,1,42,1,42,3,42,879,8,42,1,43,1,43,1,43,3,43,884,8,43,1,43,1,
        43,1,43,5,43,889,8,43,10,43,12,43,892,9,43,1,44,1,44,1,44,3,44,897,
        8,44,1,44,1,44,3,44,901,8,44,1,45,1,45,1,45,1,45,1,45,1,45,1,45,
        1,45,3,45,911,8,45,1,46,3,46,914,8,46,1,46,1,46,1,46,1,46,3,46,920,
        8,46,1,46,1,46,3,46,924,8,46,1,46,3,46,927,8,46,1,46,1,46,1,46,1,
        46,1,46,3,46,934,8,46,3,46,936,8,46,1,47,1,47,1,48,1,48,1,48,1,48,
        1,48,1,48,3,48,946,8,48,1,48,1,48,1,48,5,48,951,8,48,10,48,12,48,
        954,9,48,1,49,3,49,957,8,49,1,49,1,49,3,49,961,8,49,1,49,1,49,1,
        49,3,49,966,8,49,1,50,1,50,1,50,3,50,971,8,50,1,50,3,50,974,8,50,
        1,51,1,51,1,51,5,51,979,8,51,10,51,12,51,982,9,51,1,52,1,52,1,52,
        5,52,987,8,52,10,52,12,52,990,9,52,1,53,1,53,3,53,994,8,53,1,54,
        1,54,1,55,1,55,1,55,5,55,1001,8,55,10,55,12,55,1004,9,55,1,56,1,
        56,1,56,5,56,1009,8,56,10,56,12,56,1012,9,56,1,56,5,56,1015,8,56,
        10,56,12,56,1018,9,56,1,57,1,57,3,57,1022,8,57,1,58,1,58,1,58,1,
        58,5,58,1028,8,58,10,58,12,58,1031,9,58,1,58,1,58,3,58,1035,8,58,
        1,59,1,59,1,59,5,59,1040,8,59,10,59,12,59,1043,9,59,1,60,1,60,1,
        60,1,60,1,61,1,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,
        62,1,62,1,62,1,62,1,62,1,62,3,62,1066,8,62,1,63,1,63,1,63,1,63,1,
        64,1,64,1,65,1,65,1,65,3,65,1077,8,65,1,65,1,65,1,65,1,65,1,65,1,
        65,1,65,3,65,1086,8,65,1,65,1,65,1,65,1,65,3,65,1092,8,65,1,66,1,
        66,1,66,5,66,1097,8,66,10,66,12,66,1100,9,66,1,67,1,67,1,67,1,67,
        1,68,1,68,3,68,1108,8,68,1,69,1,69,1,69,1,69,5,69,1114,8,69,10,69,
        12,69,1117,9,69,1,69,3,69,1120,8,69,1,69,1,69,1,69,1,69,3,69,1126,
        8,69,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1134,8,70,1,71,1,71,1,72,
        1,72,1,73,1,73,1,74,1,74,1,75,1,75,1,76,1,76,5,76,1148,8,76,10,76,
        12,76,1151,9,76,1,76,1,76,1,77,1,77,1,77,1,78,1,78,1,78,1,79,1,79,
        1,79,1,80,1,80,1,80,1,81,1,81,1,81,1,82,1,82,1,82,1,83,1,83,3,83,
        1175,8,83,1,83,1,83,1,83,3,83,1180,8,83,1,83,1,83,1,83,1,83,1,83,
        1,83,3,83,1188,8,83,1,83,1,83,1,83,1,83,1,83,1,83,5,83,1196,8,83,
        10,83,12,83,1199,9,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1218,8,83,1,83,1,
        83,3,83,1222,8,83,1,83,1,83,1,83,1,83,3,83,1228,8,83,1,83,3,83,1231,
        8,83,1,83,3,83,1234,8,83,1,83,1,83,1,83,1,83,1,83,3,83,1241,8,83,
        1,83,1,83,1,83,3,83,1246,8,83,1,83,3,83,1249,8,83,1,83,1,83,1,83,
        1,83,1,83,3,83,1256,8,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,
        1,83,1,83,3,83,1268,8,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,5,83,
        1277,8,83,10,83,12,83,1280,9,83,1,83,3,83,1283,8,83,1,83,3,83,1286,
        8,83,1,83,1,83,1,83,1,83,1,83,3,83,1293,8,83,1,83,1,83,1,83,1,83,
        1,83,1,83,1,83,1,83,1,83,5,83,1304,8,83,10,83,12,83,1307,9,83,1,
        83,1,83,1,83,1,83,1,83,3,83,1314,8,83,1,83,1,83,1,83,3,83,1319,8,
        83,1,83,3,83,1322,8,83,1,83,1,83,1,83,1,83,3,83,1328,8,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1339,8,83,1,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1403,8,83,1,83,1,83,1,
        83,1,83,1,83,1,83,1,83,3,83,1412,8,83,1,83,1,83,3,83,1416,8,83,1,
        83,1,83,1,83,1,83,3,83,1422,8,83,1,83,1,83,3,83,1426,8,83,1,83,1,
        83,1,83,3,83,1431,8,83,1,83,1,83,1,83,1,83,3,83,1437,8,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1449,8,83,1,83,1,
        83,1,83,1,83,1,83,1,83,3,83,1457,8,83,1,83,1,83,1,83,1,83,3,83,1463,
        8,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,
        1476,8,83,1,83,4,83,1479,8,83,11,83,12,83,1480,1,83,1,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1497,8,
        83,1,83,1,83,1,83,5,83,1502,8,83,10,83,12,83,1505,9,83,1,83,3,83,
        1508,8,83,1,83,1,83,1,83,1,83,3,83,1514,8,83,1,83,1,83,1,83,1,83,
        1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1529,8,83,1,83,
        1,83,3,83,1533,8,83,1,83,1,83,1,83,1,83,3,83,1539,8,83,1,83,1,83,
        1,83,1,83,3,83,1545,8,83,1,83,3,83,1548,8,83,1,83,3,83,1551,8,83,
        1,83,1,83,1,83,1,83,3,83,1557,8,83,1,83,1,83,3,83,1561,8,83,1,83,
        1,83,1,83,1,83,1,83,1,83,5,83,1569,8,83,10,83,12,83,1572,9,83,1,
        83,1,83,1,83,1,83,1,83,1,83,3,83,1580,8,83,1,83,3,83,1583,8,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1592,8,83,1,83,1,83,1,83,3,
        83,1597,8,83,1,83,1,83,1,83,1,83,3,83,1603,8,83,1,83,1,83,1,83,1,
        83,1,83,3,83,1610,8,83,1,83,3,83,1613,8,83,1,83,1,83,1,83,1,83,3,
        83,1619,8,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,5,83,1628,8,83,10,
        83,12,83,1631,9,83,3,83,1633,8,83,1,83,1,83,3,83,1637,8,83,1,83,
        1,83,1,83,3,83,1642,8,83,1,83,1,83,1,83,3,83,1647,8,83,1,83,1,83,
        1,83,1,83,1,83,3,83,1654,8,83,1,83,3,83,1657,8,83,1,83,3,83,1660,
        8,83,1,83,1,83,1,83,1,83,1,83,3,83,1667,8,83,1,83,1,83,1,83,3,83,
        1672,8,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1681,8,83,1,83,
        1,83,1,83,1,83,1,83,1,83,3,83,1689,8,83,1,83,1,83,1,83,1,83,3,83,
        1695,8,83,1,83,3,83,1698,8,83,1,83,3,83,1701,8,83,1,83,1,83,1,83,
        1,83,3,83,1707,8,83,1,83,1,83,3,83,1711,8,83,1,83,1,83,3,83,1715,
        8,83,1,83,1,83,3,83,1719,8,83,3,83,1721,8,83,1,83,1,83,1,83,1,83,
        1,83,1,83,3,83,1729,8,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1737,
        8,83,1,83,1,83,1,83,1,83,3,83,1743,8,83,1,83,1,83,1,83,1,83,3,83,
        1749,8,83,1,83,3,83,1752,8,83,1,83,1,83,3,83,1756,8,83,1,83,3,83,
        1759,8,83,1,83,1,83,3,83,1763,8,83,1,83,1,83,1,83,1,83,1,83,1,83,
        1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,
        1,83,1,83,5,83,1786,8,83,10,83,12,83,1789,9,83,3,83,1791,8,83,1,
        83,1,83,3,83,1795,8,83,1,83,1,83,1,83,1,83,3,83,1801,8,83,1,83,3,
        83,1804,8,83,1,83,3,83,1807,8,83,1,83,1,83,1,83,1,83,3,83,1813,8,
        83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1821,8,83,1,83,1,83,1,83,3,
        83,1826,8,83,1,83,1,83,1,83,1,83,3,83,1832,8,83,1,83,1,83,1,83,1,
        83,3,83,1838,8,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,5,83,1848,
        8,83,10,83,12,83,1851,9,83,3,83,1853,8,83,1,83,1,83,1,83,5,83,1858,
        8,83,10,83,12,83,1861,9,83,1,83,1,83,5,83,1865,8,83,10,83,12,83,
        1868,9,83,1,83,1,83,1,83,5,83,1873,8,83,10,83,12,83,1876,9,83,3,
        83,1878,8,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1886,8,84,1,84,1,
        84,3,84,1890,8,84,1,84,1,84,1,84,1,84,1,84,3,84,1897,8,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,2013,8,84,1,84,1,
        84,1,84,1,84,1,84,1,84,3,84,2021,8,84,1,84,1,84,1,84,1,84,1,84,1,
        84,3,84,2029,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,2038,8,
        84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,2048,8,84,1,85,1,
        85,3,85,2052,8,85,1,85,3,85,2055,8,85,1,85,1,85,1,85,1,85,3,85,2061,
        8,85,1,85,1,85,1,86,1,86,3,86,2067,8,86,1,86,1,86,1,86,1,86,1,87,
        1,87,1,87,1,87,1,87,1,87,3,87,2079,8,87,1,87,1,87,1,87,1,87,1,88,
        1,88,1,88,1,88,1,88,1,88,3,88,2091,8,88,1,88,1,88,1,88,3,88,2096,
        8,88,1,89,1,89,1,89,1,90,1,90,1,90,1,91,3,91,2105,8,91,1,91,3,91,
        2108,8,91,1,91,1,91,1,91,1,92,1,92,1,92,3,92,2116,8,92,1,92,1,92,
        1,92,1,92,1,92,3,92,2123,8,92,3,92,2125,8,92,1,92,1,92,1,92,3,92,
        2130,8,92,1,92,1,92,3,92,2134,8,92,1,92,1,92,1,92,3,92,2139,8,92,
        1,92,1,92,1,92,3,92,2144,8,92,1,92,1,92,1,92,3,92,2149,8,92,1,92,
        3,92,2152,8,92,1,92,1,92,1,92,3,92,2157,8,92,1,92,1,92,3,92,2161,
        8,92,1,92,1,92,1,92,3,92,2166,8,92,3,92,2168,8,92,1,93,1,93,3,93,
        2172,8,93,1,94,1,94,1,94,1,94,1,94,5,94,2179,8,94,10,94,12,94,2182,
        9,94,1,94,1,94,1,95,1,95,1,95,3,95,2189,8,95,1,96,1,96,1,97,1,97,
        1,97,1,97,1,97,3,97,2198,8,97,1,98,1,98,1,98,5,98,2203,8,98,10,98,
        12,98,2206,9,98,1,99,1,99,1,99,1,99,5,99,2212,8,99,10,99,12,99,2215,
        9,99,1,100,1,100,3,100,2219,8,100,1,100,3,100,2222,8,100,1,100,1,
        100,1,100,1,100,1,101,1,101,1,101,1,102,1,102,1,102,1,102,1,102,
        1,102,1,102,1,102,1,102,1,102,5,102,2241,8,102,10,102,12,102,2244,
        9,102,1,103,1,103,1,103,1,103,5,103,2250,8,103,10,103,12,103,2253,
        9,103,1,103,1,103,1,104,1,104,3,104,2259,8,104,1,104,3,104,2262,
        8,104,1,105,1,105,1,105,5,105,2267,8,105,10,105,12,105,2270,9,105,
        1,105,3,105,2273,8,105,1,106,1,106,1,106,1,106,3,106,2279,8,106,
        1,107,1,107,1,107,1,107,5,107,2285,8,107,10,107,12,107,2288,9,107,
        1,107,1,107,1,108,1,108,1,108,1,108,5,108,2296,8,108,10,108,12,108,
        2299,9,108,1,108,1,108,1,109,1,109,1,109,1,109,1,109,1,109,3,109,
        2309,8,109,1,110,1,110,1,110,1,110,1,110,3,110,2316,8,110,1,111,
        1,111,1,111,1,111,3,111,2322,8,111,1,112,1,112,1,112,1,113,1,113,
        1,113,1,113,1,113,1,113,4,113,2333,8,113,11,113,12,113,2334,1,113,
        1,113,1,113,1,113,1,113,3,113,2342,8,113,1,113,1,113,1,113,1,113,
        1,113,3,113,2349,8,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,
        1,113,1,113,1,113,3,113,2361,8,113,1,113,1,113,1,113,1,113,5,113,
        2367,8,113,10,113,12,113,2370,9,113,1,113,5,113,2373,8,113,10,113,
        12,113,2376,9,113,3,113,2378,8,113,1,114,1,114,1,114,1,114,1,114,
        5,114,2385,8,114,10,114,12,114,2388,9,114,3,114,2390,8,114,1,114,
        1,114,1,114,1,114,1,114,5,114,2397,8,114,10,114,12,114,2400,9,114,
        3,114,2402,8,114,1,114,1,114,1,114,1,114,1,114,5,114,2409,8,114,
        10,114,12,114,2412,9,114,3,114,2414,8,114,1,114,1,114,1,114,1,114,
        1,114,5,114,2421,8,114,10,114,12,114,2424,9,114,3,114,2426,8,114,
        1,114,3,114,2429,8,114,1,114,1,114,1,114,3,114,2434,8,114,3,114,
        2436,8,114,1,115,1,115,1,115,1,116,1,116,1,116,3,116,2444,8,116,
        1,116,1,116,1,116,3,116,2449,8,116,1,116,1,116,1,116,1,116,3,116,
        2455,8,116,1,116,1,116,1,116,1,116,3,116,2461,8,116,1,116,5,116,
        2464,8,116,10,116,12,116,2467,9,116,1,117,1,117,1,117,1,117,1,117,
        3,117,2474,8,117,1,118,1,118,3,118,2478,8,118,1,118,1,118,3,118,
        2482,8,118,1,119,1,119,4,119,2486,8,119,11,119,12,119,2487,1,120,
        1,120,3,120,2492,8,120,1,120,1,120,1,120,1,120,5,120,2498,8,120,
        10,120,12,120,2501,9,120,1,120,3,120,2504,8,120,1,120,3,120,2507,
        8,120,1,120,3,120,2510,8,120,1,120,3,120,2513,8,120,1,120,1,120,
        3,120,2517,8,120,1,121,1,121,1,121,3,121,2522,8,121,1,121,1,121,
        1,121,5,121,2527,8,121,10,121,12,121,2530,9,121,1,121,3,121,2533,
        8,121,1,121,3,121,2536,8,121,1,121,3,121,2539,8,121,1,121,3,121,
        2542,8,121,3,121,2544,8,121,1,122,3,122,2547,8,122,1,123,1,123,1,
        123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,3,123,2559,8,123,1,
        123,3,123,2562,8,123,1,123,1,123,3,123,2566,8,123,1,123,1,123,1,
        123,1,123,1,123,1,123,1,123,1,123,3,123,2576,8,123,1,123,1,123,3,
        123,2580,8,123,3,123,2582,8,123,1,123,3,123,2585,8,123,1,123,1,123,
        3,123,2589,8,123,1,124,1,124,5,124,2593,8,124,10,124,12,124,2596,
        9,124,1,124,3,124,2599,8,124,1,124,1,124,1,125,1,125,1,125,1,126,
        1,126,1,126,1,126,3,126,2610,8,126,1,126,1,126,1,126,1,127,1,127,
        1,127,1,127,1,127,3,127,2620,8,127,1,127,1,127,1,127,1,128,1,128,
        1,128,1,128,1,128,1,128,1,128,3,128,2632,8,128,1,129,1,129,1,129,
        1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2645,8,129,
        10,129,12,129,2648,9,129,1,129,1,129,3,129,2652,8,129,1,130,1,130,
        1,130,5,130,2657,8,130,10,130,12,130,2660,9,130,1,131,1,131,1,131,
        1,131,1,132,1,132,1,132,1,133,1,133,1,133,1,134,1,134,1,134,3,134,
        2675,8,134,1,134,5,134,2678,8,134,10,134,12,134,2681,9,134,1,134,
        1,134,1,135,1,135,1,135,1,135,1,135,1,135,5,135,2691,8,135,10,135,
        12,135,2694,9,135,1,135,1,135,3,135,2698,8,135,1,136,1,136,1,136,
        1,136,5,136,2704,8,136,10,136,12,136,2707,9,136,1,136,5,136,2710,
        8,136,10,136,12,136,2713,9,136,1,136,3,136,2716,8,136,1,137,1,137,
        1,137,1,137,1,137,5,137,2723,8,137,10,137,12,137,2726,9,137,1,137,
        1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,5,137,2738,
        8,137,10,137,12,137,2741,9,137,1,137,1,137,3,137,2745,8,137,1,137,
        1,137,1,137,1,137,1,137,1,137,1,137,1,137,5,137,2755,8,137,10,137,
        12,137,2758,9,137,1,137,1,137,3,137,2762,8,137,1,138,1,138,1,138,
        1,138,5,138,2768,8,138,10,138,12,138,2771,9,138,3,138,2773,8,138,
        1,138,1,138,3,138,2777,8,138,1,139,1,139,1,139,1,139,1,139,1,139,
        1,139,1,139,1,139,1,139,5,139,2789,8,139,10,139,12,139,2792,9,139,
        1,139,1,139,1,139,1,140,1,140,1,140,1,140,1,140,5,140,2802,8,140,
        10,140,12,140,2805,9,140,1,140,1,140,3,140,2809,8,140,1,141,1,141,
        3,141,2813,8,141,1,141,3,141,2816,8,141,1,142,1,142,1,142,3,142,
        2821,8,142,1,142,1,142,1,142,1,142,1,142,5,142,2828,8,142,10,142,
        12,142,2831,9,142,3,142,2833,8,142,1,142,1,142,1,142,3,142,2838,
        8,142,1,142,1,142,1,142,5,142,2843,8,142,10,142,12,142,2846,9,142,
        3,142,2848,8,142,1,143,1,143,1,144,1,144,5,144,2854,8,144,10,144,
        12,144,2857,9,144,1,145,1,145,1,145,1,145,3,145,2863,8,145,1,145,
        1,145,1,145,1,145,1,145,3,145,2870,8,145,1,146,3,146,2873,8,146,
        1,146,1,146,1,146,3,146,2878,8,146,1,146,3,146,2881,8,146,1,146,
        1,146,1,146,3,146,2886,8,146,1,146,1,146,3,146,2890,8,146,1,146,
        3,146,2893,8,146,1,146,3,146,2896,8,146,1,147,1,147,1,147,1,147,
        3,147,2902,8,147,1,148,1,148,3,148,2906,8,148,1,148,1,148,3,148,
        2910,8,148,1,148,1,148,1,149,3,149,2915,8,149,1,149,1,149,1,149,
        1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,
        1,149,1,149,3,149,2933,8,149,3,149,2935,8,149,1,149,3,149,2938,8,
        149,1,150,1,150,1,150,1,150,1,151,1,151,1,151,5,151,2947,8,151,10,
        151,12,151,2950,9,151,1,152,1,152,1,152,1,152,5,152,2956,8,152,10,
        152,12,152,2959,9,152,1,152,1,152,1,153,1,153,3,153,2965,8,153,1,
        154,1,154,1,154,1,154,5,154,2971,8,154,10,154,12,154,2974,9,154,
        1,154,1,154,1,155,1,155,3,155,2980,8,155,1,156,1,156,3,156,2984,
        8,156,1,156,3,156,2987,8,156,1,156,1,156,1,156,1,156,1,156,1,156,
        3,156,2995,8,156,1,156,1,156,1,156,1,156,1,156,1,156,3,156,3003,
        8,156,1,156,1,156,1,156,1,156,3,156,3009,8,156,1,157,1,157,1,157,
        1,157,5,157,3015,8,157,10,157,12,157,3018,9,157,1,157,1,157,1,158,
        1,158,1,158,1,158,1,158,5,158,3027,8,158,10,158,12,158,3030,9,158,
        3,158,3032,8,158,1,158,1,158,1,158,1,159,3,159,3038,8,159,1,159,
        1,159,3,159,3042,8,159,3,159,3044,8,159,1,160,1,160,1,160,1,160,
        1,160,1,160,1,160,3,160,3053,8,160,1,160,1,160,1,160,1,160,1,160,
        1,160,1,160,1,160,1,160,1,160,3,160,3065,8,160,3,160,3067,8,160,
        1,160,1,160,1,160,1,160,1,160,3,160,3074,8,160,1,160,1,160,1,160,
        1,160,1,160,3,160,3081,8,160,1,160,1,160,1,160,1,160,3,160,3087,
        8,160,1,160,1,160,1,160,1,160,3,160,3093,8,160,3,160,3095,8,160,
        1,161,1,161,1,161,5,161,3100,8,161,10,161,12,161,3103,9,161,1,162,
        1,162,1,162,5,162,3108,8,162,10,162,12,162,3111,9,162,1,163,1,163,
        1,163,3,163,3116,8,163,1,163,1,163,1,164,1,164,1,164,3,164,3123,
        8,164,1,164,1,164,1,165,1,165,3,165,3129,8,165,1,165,1,165,3,165,
        3133,8,165,3,165,3135,8,165,1,166,1,166,1,166,5,166,3140,8,166,10,
        166,12,166,3143,9,166,1,167,1,167,1,167,1,167,5,167,3149,8,167,10,
        167,12,167,3152,9,167,1,167,1,167,1,168,1,168,1,168,1,168,1,168,
        1,168,5,168,3162,8,168,10,168,12,168,3165,9,168,1,168,1,168,3,168,
        3169,8,168,1,169,1,169,3,169,3173,8,169,1,170,1,170,1,171,1,171,
        1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,3,171,3187,8,171,
        3,171,3189,8,171,1,171,1,171,1,171,1,171,1,171,1,171,5,171,3197,
        8,171,10,171,12,171,3200,9,171,1,172,3,172,3203,8,172,1,172,1,172,
        1,172,1,172,1,172,1,172,3,172,3211,8,172,1,172,1,172,1,172,1,172,
        1,172,5,172,3218,8,172,10,172,12,172,3221,9,172,1,172,1,172,1,172,
        3,172,3226,8,172,1,172,1,172,1,172,1,172,1,172,1,172,3,172,3234,
        8,172,1,172,1,172,1,172,3,172,3239,8,172,1,172,1,172,1,172,1,172,
        1,172,1,172,1,172,1,172,5,172,3249,8,172,10,172,12,172,3252,9,172,
        1,172,1,172,3,172,3256,8,172,1,172,3,172,3259,8,172,1,172,1,172,
        1,172,1,172,3,172,3265,8,172,1,172,1,172,3,172,3269,8,172,1,172,
        1,172,1,172,3,172,3274,8,172,1,172,1,172,1,172,3,172,3279,8,172,
        1,172,1,172,1,172,3,172,3284,8,172,1,173,1,173,1,173,1,173,3,173,
        3290,8,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,
        1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,5,173,
        3311,8,173,10,173,12,173,3314,9,173,1,174,1,174,1,174,1,174,4,174,
        3320,8,174,11,174,12,174,3321,1,174,1,174,3,174,3326,8,174,1,174,
        1,174,1,174,1,174,1,174,4,174,3333,8,174,11,174,12,174,3334,1,174,
        1,174,3,174,3339,8,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,
        1,174,1,174,1,174,1,174,1,174,1,174,1,174,5,174,3355,8,174,10,174,
        12,174,3358,9,174,3,174,3360,8,174,1,174,1,174,1,174,1,174,1,174,
        1,174,3,174,3368,8,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,
        3,174,3377,8,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,
        1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,
        4,174,3398,8,174,11,174,12,174,3399,1,174,1,174,1,174,1,174,1,174,
        1,174,1,174,1,174,1,174,3,174,3411,8,174,1,174,1,174,1,174,5,174,
        3416,8,174,10,174,12,174,3419,9,174,3,174,3421,8,174,1,174,1,174,
        1,174,1,174,1,174,1,174,1,174,3,174,3430,8,174,1,174,1,174,3,174,
        3434,8,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,4,174,
        3444,8,174,11,174,12,174,3445,1,174,1,174,1,174,1,174,1,174,1,174,
        1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,
        1,174,1,174,1,174,1,174,1,174,1,174,3,174,3471,8,174,1,174,1,174,
        1,174,1,174,1,174,3,174,3478,8,174,1,174,3,174,3481,8,174,1,174,
        1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,
        1,174,3,174,3496,8,174,1,174,1,174,3,174,3500,8,174,1,174,1,174,
        1,174,1,174,1,174,1,174,1,174,1,174,5,174,3510,8,174,10,174,12,174,
        3513,9,174,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,4,175,
        3523,8,175,11,175,12,175,3524,3,175,3527,8,175,1,176,1,176,1,176,
        1,176,1,176,1,176,1,176,1,176,3,176,3537,8,176,1,177,1,177,1,178,
        1,178,1,179,1,179,1,180,1,180,1,181,1,181,1,181,3,181,3550,8,181,
        1,182,1,182,3,182,3554,8,182,1,183,1,183,1,183,4,183,3559,8,183,
        11,183,12,183,3560,1,184,1,184,1,184,3,184,3566,8,184,1,185,1,185,
        1,185,1,185,1,185,1,186,3,186,3574,8,186,1,186,1,186,3,186,3578,
        8,186,1,187,1,187,1,187,1,187,1,187,1,187,1,187,3,187,3587,8,187,
        1,188,1,188,1,188,3,188,3592,8,188,1,189,1,189,1,189,1,189,1,189,
        1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,3,189,
        3609,8,189,1,189,1,189,3,189,3613,8,189,1,189,1,189,1,189,1,189,
        1,189,5,189,3620,8,189,10,189,12,189,3623,9,189,1,189,3,189,3626,
        8,189,3,189,3628,8,189,1,190,1,190,1,190,5,190,3633,8,190,10,190,
        12,190,3636,9,190,1,191,1,191,1,191,1,191,3,191,3642,8,191,1,191,
        3,191,3645,8,191,1,191,3,191,3648,8,191,1,192,1,192,1,192,5,192,
        3653,8,192,10,192,12,192,3656,9,192,1,193,1,193,1,193,1,193,3,193,
        3662,8,193,1,193,3,193,3665,8,193,1,194,1,194,1,194,5,194,3670,8,
        194,10,194,12,194,3673,9,194,1,195,1,195,1,195,1,195,1,195,3,195,
        3680,8,195,1,195,3,195,3683,8,195,1,196,1,196,1,196,1,196,1,196,
        1,197,1,197,1,197,1,197,5,197,3694,8,197,10,197,12,197,3697,9,197,
        1,198,1,198,1,198,1,198,1,199,1,199,1,199,1,199,1,199,1,199,1,199,
        1,199,1,199,1,199,1,199,5,199,3714,8,199,10,199,12,199,3717,9,199,
        1,199,1,199,1,199,1,199,1,199,5,199,3724,8,199,10,199,12,199,3727,
        9,199,3,199,3729,8,199,1,199,1,199,1,199,1,199,1,199,5,199,3736,
        8,199,10,199,12,199,3739,9,199,3,199,3741,8,199,3,199,3743,8,199,
        1,199,3,199,3746,8,199,1,199,3,199,3749,8,199,1,200,1,200,1,200,
        1,200,1,200,1,200,1,200,1,200,1,200,1,200,1,200,1,200,1,200,1,200,
        1,200,1,200,3,200,3767,8,200,1,201,1,201,1,201,1,201,1,201,1,201,
        1,201,3,201,3776,8,201,1,202,1,202,1,202,5,202,3781,8,202,10,202,
        12,202,3784,9,202,1,203,1,203,1,203,1,203,3,203,3790,8,203,1,204,
        1,204,1,204,5,204,3795,8,204,10,204,12,204,3798,9,204,1,205,1,205,
        1,206,1,206,4,206,3804,8,206,11,206,12,206,3805,1,207,1,207,3,207,
        3810,8,207,1,208,1,208,1,208,3,208,3815,8,208,1,209,1,209,1,210,
        3,210,3820,8,210,1,210,1,210,3,210,3824,8,210,1,210,1,210,3,210,
        3828,8,210,1,210,1,210,3,210,3832,8,210,1,210,1,210,3,210,3836,8,
        210,1,210,1,210,3,210,3840,8,210,1,210,1,210,3,210,3844,8,210,1,
        210,1,210,3,210,3848,8,210,1,210,1,210,3,210,3852,8,210,1,210,3,
        210,3855,8,210,1,211,1,211,1,211,1,211,1,211,1,211,1,211,3,211,3864,
        8,211,1,212,1,212,1,213,1,213,1,214,1,214,1,214,5,1787,1849,1859,
        1866,1874,5,96,232,342,346,348,215,0,2,4,6,8,10,12,14,16,18,20,22,
        24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,
        68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,
        108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,
        140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,
        172,174,176,178,180,182,184,186,188,190,192,194,196,198,200,202,
        204,206,208,210,212,214,216,218,220,222,224,226,228,230,232,234,
        236,238,240,242,244,246,248,250,252,254,256,258,260,262,264,266,
        268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,
        300,302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,
        332,334,336,338,340,342,344,346,348,350,352,354,356,358,360,362,
        364,366,368,370,372,374,376,378,380,382,384,386,388,390,392,394,
        396,398,400,402,404,406,408,410,412,414,416,418,420,422,424,426,
        428,0,56,2,0,60,60,65,65,1,0,200,201,1,0,248,249,2,0,140,140,173,
        173,3,0,37,37,215,215,280,280,1,0,38,40,3,0,57,57,273,273,303,303,
        2,0,4,4,310,310,2,0,334,334,336,336,2,0,219,219,323,323,1,0,19,22,
        1,0,319,322,2,0,69,69,115,115,2,0,320,320,325,325,3,0,10,11,135,
        135,287,287,2,0,12,12,200,200,2,0,111,111,226,226,2,0,78,78,240,
        240,2,0,109,109,196,196,2,0,146,146,159,159,1,0,89,90,2,0,273,273,
        303,303,2,0,61,61,81,81,5,0,86,86,98,98,132,132,145,145,187,187,
        1,0,115,116,2,0,132,132,145,145,2,0,200,200,330,330,2,0,58,58,181,
        181,3,0,108,108,195,195,250,250,4,0,127,127,166,166,259,259,293,
        293,3,0,127,127,259,259,293,293,2,0,60,60,120,120,1,0,51,53,3,0,
        60,60,65,65,263,263,3,0,135,135,287,287,295,295,2,0,319,320,325,
        325,1,0,321,324,2,0,319,320,328,328,2,0,103,103,105,105,1,0,271,
        272,2,0,2,2,146,146,2,0,2,2,142,142,3,0,73,73,176,176,282,282,1,
        0,310,311,1,0,319,329,4,0,63,63,159,159,199,199,207,207,2,0,135,
        135,287,287,1,0,319,320,2,0,121,121,216,216,2,0,208,208,264,264,
        2,0,141,141,223,223,1,0,335,336,2,0,122,122,258,258,51,0,58,59,61,
        62,66,67,69,70,72,72,74,78,81,81,83,86,88,88,90,96,98,98,101,102,
        107,109,111,119,121,122,126,126,128,134,137,137,139,141,144,145,
        148,150,153,153,156,158,160,161,163,165,167,167,170,170,172,175,
        178,191,194,196,198,198,201,202,205,206,209,209,211,212,214,223,
        225,233,235,241,243,250,254,256,258,258,260,262,264,272,274,278,
        281,281,283,288,290,292,296,299,302,304,307,307,324,324,15,0,64,
        64,100,100,127,127,147,147,162,162,166,166,171,171,177,177,197,197,
        203,203,242,242,253,253,259,259,293,293,301,301,17,0,58,63,65,99,
        101,126,128,146,148,161,163,165,167,170,172,176,178,196,198,202,
        204,241,243,252,254,258,260,292,294,300,302,309,324,324,4430,0,431,
        1,0,0,0,2,437,1,0,0,0,4,446,1,0,0,0,6,449,1,0,0,0,8,475,1,0,0,0,
        10,477,1,0,0,0,12,489,1,0,0,0,14,498,1,0,0,0,16,518,1,0,0,0,18,525,
        1,0,0,0,20,532,1,0,0,0,22,543,1,0,0,0,24,556,1,0,0,0,26,563,1,0,
        0,0,28,581,1,0,0,0,30,599,1,0,0,0,32,612,1,0,0,0,34,615,1,0,0,0,
        36,623,1,0,0,0,38,638,1,0,0,0,40,675,1,0,0,0,42,677,1,0,0,0,44,695,
        1,0,0,0,46,712,1,0,0,0,48,723,1,0,0,0,50,728,1,0,0,0,52,732,1,0,
        0,0,54,734,1,0,0,0,56,736,1,0,0,0,58,738,1,0,0,0,60,740,1,0,0,0,
        62,795,1,0,0,0,64,797,1,0,0,0,66,814,1,0,0,0,68,816,1,0,0,0,70,834,
        1,0,0,0,72,836,1,0,0,0,74,848,1,0,0,0,76,850,1,0,0,0,78,857,1,0,
        0,0,80,860,1,0,0,0,82,862,1,0,0,0,84,871,1,0,0,0,86,883,1,0,0,0,
        88,900,1,0,0,0,90,910,1,0,0,0,92,935,1,0,0,0,94,937,1,0,0,0,96,945,
        1,0,0,0,98,965,1,0,0,0,100,973,1,0,0,0,102,975,1,0,0,0,104,983,1,
        0,0,0,106,991,1,0,0,0,108,995,1,0,0,0,110,997,1,0,0,0,112,1005,1,
        0,0,0,114,1021,1,0,0,0,116,1034,1,0,0,0,118,1036,1,0,0,0,120,1044,
        1,0,0,0,122,1048,1,0,0,0,124,1065,1,0,0,0,126,1067,1,0,0,0,128,1071,
        1,0,0,0,130,1091,1,0,0,0,132,1093,1,0,0,0,134,1101,1,0,0,0,136,1107,
        1,0,0,0,138,1125,1,0,0,0,140,1133,1,0,0,0,142,1135,1,0,0,0,144,1137,
        1,0,0,0,146,1139,1,0,0,0,148,1141,1,0,0,0,150,1143,1,0,0,0,152,1145,
        1,0,0,0,154,1154,1,0,0,0,156,1157,1,0,0,0,158,1160,1,0,0,0,160,1163,
        1,0,0,0,162,1166,1,0,0,0,164,1169,1,0,0,0,166,1877,1,0,0,0,168,2047,
        1,0,0,0,170,2049,1,0,0,0,172,2066,1,0,0,0,174,2072,1,0,0,0,176,2084,
        1,0,0,0,178,2097,1,0,0,0,180,2100,1,0,0,0,182,2104,1,0,0,0,184,2167,
        1,0,0,0,186,2169,1,0,0,0,188,2173,1,0,0,0,190,2185,1,0,0,0,192,2190,
        1,0,0,0,194,2197,1,0,0,0,196,2199,1,0,0,0,198,2207,1,0,0,0,200,2216,
        1,0,0,0,202,2227,1,0,0,0,204,2242,1,0,0,0,206,2245,1,0,0,0,208,2256,
        1,0,0,0,210,2272,1,0,0,0,212,2278,1,0,0,0,214,2280,1,0,0,0,216,2291,
        1,0,0,0,218,2308,1,0,0,0,220,2315,1,0,0,0,222,2317,1,0,0,0,224,2323,
        1,0,0,0,226,2377,1,0,0,0,228,2389,1,0,0,0,230,2437,1,0,0,0,232,2443,
        1,0,0,0,234,2473,1,0,0,0,236,2475,1,0,0,0,238,2483,1,0,0,0,240,2516,
        1,0,0,0,242,2543,1,0,0,0,244,2546,1,0,0,0,246,2558,1,0,0,0,248,2590,
        1,0,0,0,250,2602,1,0,0,0,252,2605,1,0,0,0,254,2614,1,0,0,0,256,2631,
        1,0,0,0,258,2651,1,0,0,0,260,2653,1,0,0,0,262,2661,1,0,0,0,264,2665,
        1,0,0,0,266,2668,1,0,0,0,268,2671,1,0,0,0,270,2697,1,0,0,0,272,2699,
        1,0,0,0,274,2761,1,0,0,0,276,2776,1,0,0,0,278,2778,1,0,0,0,280,2808,
        1,0,0,0,282,2810,1,0,0,0,284,2817,1,0,0,0,286,2849,1,0,0,0,288,2851,
        1,0,0,0,290,2869,1,0,0,0,292,2895,1,0,0,0,294,2901,1,0,0,0,296,2903,
        1,0,0,0,298,2937,1,0,0,0,300,2939,1,0,0,0,302,2943,1,0,0,0,304,2951,
        1,0,0,0,306,2962,1,0,0,0,308,2966,1,0,0,0,310,2977,1,0,0,0,312,3008,
        1,0,0,0,314,3010,1,0,0,0,316,3021,1,0,0,0,318,3043,1,0,0,0,320,3094,
        1,0,0,0,322,3096,1,0,0,0,324,3104,1,0,0,0,326,3115,1,0,0,0,328,3122,
        1,0,0,0,330,3126,1,0,0,0,332,3136,1,0,0,0,334,3144,1,0,0,0,336,3168,
        1,0,0,0,338,3172,1,0,0,0,340,3174,1,0,0,0,342,3188,1,0,0,0,344,3283,
        1,0,0,0,346,3289,1,0,0,0,348,3499,1,0,0,0,350,3526,1,0,0,0,352,3536,
        1,0,0,0,354,3538,1,0,0,0,356,3540,1,0,0,0,358,3542,1,0,0,0,360,3544,
        1,0,0,0,362,3546,1,0,0,0,364,3551,1,0,0,0,366,3558,1,0,0,0,368,3562,
        1,0,0,0,370,3567,1,0,0,0,372,3577,1,0,0,0,374,3586,1,0,0,0,376,3591,
        1,0,0,0,378,3627,1,0,0,0,380,3629,1,0,0,0,382,3637,1,0,0,0,384,3649,
        1,0,0,0,386,3657,1,0,0,0,388,3666,1,0,0,0,390,3674,1,0,0,0,392,3684,
        1,0,0,0,394,3689,1,0,0,0,396,3698,1,0,0,0,398,3748,1,0,0,0,400,3766,
        1,0,0,0,402,3775,1,0,0,0,404,3777,1,0,0,0,406,3789,1,0,0,0,408,3791,
        1,0,0,0,410,3799,1,0,0,0,412,3803,1,0,0,0,414,3809,1,0,0,0,416,3814,
        1,0,0,0,418,3816,1,0,0,0,420,3854,1,0,0,0,422,3863,1,0,0,0,424,3865,
        1,0,0,0,426,3867,1,0,0,0,428,3869,1,0,0,0,430,432,3,4,2,0,431,430,
        1,0,0,0,432,433,1,0,0,0,433,431,1,0,0,0,433,434,1,0,0,0,434,435,
        1,0,0,0,435,436,5,0,0,1,436,1,1,0,0,0,437,438,3,4,2,0,438,439,5,
        0,0,1,439,3,1,0,0,0,440,447,3,6,3,0,441,447,3,44,22,0,442,447,3,
        38,19,0,443,447,3,40,20,0,444,447,3,42,21,0,445,447,3,46,23,0,446,
        440,1,0,0,0,446,441,1,0,0,0,446,442,1,0,0,0,446,443,1,0,0,0,446,
        444,1,0,0,0,446,445,1,0,0,0,447,5,1,0,0,0,448,450,3,78,39,0,449,
        448,1,0,0,0,449,450,1,0,0,0,450,451,1,0,0,0,451,453,3,182,91,0,452,
        454,3,62,31,0,453,452,1,0,0,0,453,454,1,0,0,0,454,456,1,0,0,0,455,
        457,3,68,34,0,456,455,1,0,0,0,456,457,1,0,0,0,457,459,1,0,0,0,458,
        460,3,66,33,0,459,458,1,0,0,0,459,460,1,0,0,0,460,7,1,0,0,0,461,
        476,3,10,5,0,462,476,3,12,6,0,463,476,3,30,15,0,464,476,3,32,16,
        0,465,476,3,34,17,0,466,476,3,36,18,0,467,476,3,14,7,0,468,476,3,
        16,8,0,469,476,3,18,9,0,470,476,3,20,10,0,471,476,3,22,11,0,472,
        476,3,24,12,0,473,476,3,26,13,0,474,476,3,28,14,0,475,461,1,0,0,
        0,475,462,1,0,0,0,475,463,1,0,0,0,475,464,1,0,0,0,475,465,1,0,0,
        0,475,466,1,0,0,0,475,467,1,0,0,0,475,468,1,0,0,0,475,469,1,0,0,
        0,475,470,1,0,0,0,475,471,1,0,0,0,475,472,1,0,0,0,475,473,1,0,0,
        0,475,474,1,0,0,0,476,9,1,0,0,0,477,479,5,285,0,0,478,480,3,70,35,
        0,479,478,1,0,0,0,479,480,1,0,0,0,480,482,1,0,0,0,481,483,3,92,46,
        0,482,481,1,0,0,0,482,483,1,0,0,0,483,484,1,0,0,0,484,487,3,82,41,
        0,485,486,5,55,0,0,486,488,3,86,43,0,487,485,1,0,0,0,487,488,1,0,
        0,0,488,11,1,0,0,0,489,491,5,27,0,0,490,492,3,70,35,0,491,490,1,
        0,0,0,491,492,1,0,0,0,492,494,1,0,0,0,493,495,3,92,46,0,494,493,
        1,0,0,0,494,495,1,0,0,0,495,496,1,0,0,0,496,497,3,84,42,0,497,13,
        1,0,0,0,498,499,5,36,0,0,499,500,5,63,0,0,500,502,5,299,0,0,501,
        503,3,74,37,0,502,501,1,0,0,0,502,503,1,0,0,0,503,505,1,0,0,0,504,
        506,3,92,46,0,505,504,1,0,0,0,505,506,1,0,0,0,506,507,1,0,0,0,507,
        509,3,54,27,0,508,510,3,50,25,0,509,508,1,0,0,0,509,510,1,0,0,0,
        510,512,1,0,0,0,511,513,3,56,28,0,512,511,1,0,0,0,512,513,1,0,0,
        0,513,514,1,0,0,0,514,516,3,58,29,0,515,517,3,100,50,0,516,515,1,
        0,0,0,516,517,1,0,0,0,517,15,1,0,0,0,518,519,5,236,0,0,519,520,5,
        90,0,0,520,523,3,110,55,0,521,522,5,146,0,0,522,524,3,74,37,0,523,
        521,1,0,0,0,523,524,1,0,0,0,524,17,1,0,0,0,525,526,5,61,0,0,526,
        527,5,90,0,0,527,530,3,118,59,0,528,529,5,146,0,0,529,531,3,74,37,
        0,530,528,1,0,0,0,530,531,1,0,0,0,531,19,1,0,0,0,532,533,5,122,0,
        0,533,534,5,90,0,0,534,537,3,102,51,0,535,536,5,156,0,0,536,538,
        5,129,0,0,537,535,1,0,0,0,537,538,1,0,0,0,538,541,1,0,0,0,539,540,
        5,146,0,0,540,542,3,74,37,0,541,539,1,0,0,0,541,542,1,0,0,0,542,
        21,1,0,0,0,543,544,5,122,0,0,544,545,5,249,0,0,545,546,5,156,0,0,
        546,547,7,0,0,0,547,550,7,1,0,0,548,549,5,203,0,0,549,551,3,102,
        51,0,550,548,1,0,0,0,550,551,1,0,0,0,551,554,1,0,0,0,552,553,5,146,
        0,0,553,555,3,74,37,0,554,552,1,0,0,0,554,555,1,0,0,0,555,23,1,0,
        0,0,556,557,5,17,0,0,557,558,7,1,0,0,558,561,3,100,50,0,559,560,
        5,146,0,0,560,562,3,74,37,0,561,559,1,0,0,0,561,562,1,0,0,0,562,
        25,1,0,0,0,563,565,5,48,0,0,564,566,5,238,0,0,565,564,1,0,0,0,565,
        566,1,0,0,0,566,567,1,0,0,0,567,570,3,88,44,0,568,569,5,49,0,0,569,
        571,5,334,0,0,570,568,1,0,0,0,570,571,1,0,0,0,571,574,1,0,0,0,572,
        573,5,146,0,0,573,575,3,74,37,0,574,572,1,0,0,0,574,575,1,0,0,0,
        575,579,1,0,0,0,576,577,5,32,0,0,577,578,5,76,0,0,578,580,3,102,
        51,0,579,576,1,0,0,0,579,580,1,0,0,0,580,27,1,0,0,0,581,584,5,18,
        0,0,582,583,5,334,0,0,583,585,7,2,0,0,584,582,1,0,0,0,584,585,1,
        0,0,0,585,588,1,0,0,0,586,587,5,146,0,0,587,589,3,74,37,0,588,586,
        1,0,0,0,588,589,1,0,0,0,589,593,1,0,0,0,590,594,3,92,46,0,591,592,
        5,23,0,0,592,594,3,104,52,0,593,590,1,0,0,0,593,591,1,0,0,0,593,
        594,1,0,0,0,594,597,1,0,0,0,595,596,7,1,0,0,596,598,7,3,0,0,597,
        595,1,0,0,0,597,598,1,0,0,0,598,29,1,0,0,0,599,600,5,33,0,0,600,
        602,3,70,35,0,601,603,3,90,45,0,602,601,1,0,0,0,602,603,1,0,0,0,
        603,606,1,0,0,0,604,605,5,76,0,0,605,607,3,102,51,0,606,604,1,0,
        0,0,606,607,1,0,0,0,607,610,1,0,0,0,608,609,5,23,0,0,609,611,3,104,
        52,0,610,608,1,0,0,0,610,611,1,0,0,0,611,31,1,0,0,0,612,613,5,99,
        0,0,613,614,3,84,42,0,614,33,1,0,0,0,615,617,5,99,0,0,616,618,5,
        107,0,0,617,616,1,0,0,0,617,618,1,0,0,0,618,619,1,0,0,0,619,620,
        3,138,69,0,620,621,5,250,0,0,621,622,3,118,59,0,622,35,1,0,0,0,623,
        625,5,182,0,0,624,626,3,56,28,0,625,624,1,0,0,0,625,626,1,0,0,0,
        626,629,1,0,0,0,627,630,3,58,29,0,628,630,3,60,30,0,629,627,1,0,
        0,0,629,628,1,0,0,0,630,632,1,0,0,0,631,633,3,100,50,0,632,631,1,
        0,0,0,632,633,1,0,0,0,633,636,1,0,0,0,634,635,5,90,0,0,635,637,3,
        52,26,0,636,634,1,0,0,0,636,637,1,0,0,0,637,37,1,0,0,0,638,640,5,
        28,0,0,639,641,3,70,35,0,640,639,1,0,0,0,640,641,1,0,0,0,641,643,
        1,0,0,0,642,644,3,92,46,0,643,642,1,0,0,0,643,644,1,0,0,0,644,645,
        1,0,0,0,645,646,5,301,0,0,646,648,3,86,43,0,647,649,3,100,50,0,648,
        647,1,0,0,0,648,649,1,0,0,0,649,39,1,0,0,0,650,651,5,34,0,0,651,
        652,5,334,0,0,652,655,7,2,0,0,653,654,5,146,0,0,654,656,3,70,35,
        0,655,653,1,0,0,0,655,656,1,0,0,0,656,658,1,0,0,0,657,659,5,30,0,
        0,658,657,1,0,0,0,658,659,1,0,0,0,659,662,1,0,0,0,660,661,5,35,0,
        0,661,663,5,330,0,0,662,660,1,0,0,0,662,663,1,0,0,0,663,676,1,0,
        0,0,664,666,5,34,0,0,665,667,3,70,35,0,666,665,1,0,0,0,666,667,1,
        0,0,0,667,669,1,0,0,0,668,670,5,30,0,0,669,668,1,0,0,0,669,670,1,
        0,0,0,670,673,1,0,0,0,671,672,5,35,0,0,672,674,5,330,0,0,673,671,
        1,0,0,0,673,674,1,0,0,0,674,676,1,0,0,0,675,650,1,0,0,0,675,664,
        1,0,0,0,676,41,1,0,0,0,677,679,5,36,0,0,678,680,3,74,37,0,679,678,
        1,0,0,0,679,680,1,0,0,0,680,682,1,0,0,0,681,683,3,92,46,0,682,681,
        1,0,0,0,682,683,1,0,0,0,683,684,1,0,0,0,684,686,3,54,27,0,685,687,
        3,50,25,0,686,685,1,0,0,0,686,687,1,0,0,0,687,689,1,0,0,0,688,690,
        3,56,28,0,689,688,1,0,0,0,689,690,1,0,0,0,690,691,1,0,0,0,691,693,
        3,58,29,0,692,694,3,100,50,0,693,692,1,0,0,0,693,694,1,0,0,0,694,
        43,1,0,0,0,695,697,5,29,0,0,696,698,3,70,35,0,697,696,1,0,0,0,697,
        698,1,0,0,0,698,700,1,0,0,0,699,701,3,92,46,0,700,699,1,0,0,0,700,
        701,1,0,0,0,701,702,1,0,0,0,702,703,5,301,0,0,703,705,3,86,43,0,
        704,706,3,100,50,0,705,704,1,0,0,0,705,706,1,0,0,0,706,709,1,0,0,
        0,707,708,5,55,0,0,708,710,3,86,43,0,709,707,1,0,0,0,709,710,1,0,
        0,0,710,45,1,0,0,0,711,713,3,78,39,0,712,711,1,0,0,0,712,713,1,0,
        0,0,713,714,1,0,0,0,714,716,5,54,0,0,715,717,3,70,35,0,716,715,1,
        0,0,0,716,717,1,0,0,0,717,718,1,0,0,0,718,719,5,301,0,0,719,721,
        3,86,43,0,720,722,3,100,50,0,721,720,1,0,0,0,721,722,1,0,0,0,722,
        47,1,0,0,0,723,724,5,47,0,0,724,726,3,86,43,0,725,727,3,100,50,0,
        726,725,1,0,0,0,726,727,1,0,0,0,727,49,1,0,0,0,728,729,5,41,0,0,
        729,51,1,0,0,0,730,733,3,118,59,0,731,733,3,102,51,0,732,730,1,0,
        0,0,732,731,1,0,0,0,733,53,1,0,0,0,734,735,7,4,0,0,735,55,1,0,0,
        0,736,737,7,5,0,0,737,57,1,0,0,0,738,739,5,330,0,0,739,59,1,0,0,
        0,740,741,5,1,0,0,741,746,3,58,29,0,742,743,5,2,0,0,743,745,3,58,
        29,0,744,742,1,0,0,0,745,748,1,0,0,0,746,744,1,0,0,0,746,747,1,0,
        0,0,747,749,1,0,0,0,748,746,1,0,0,0,749,750,5,3,0,0,750,61,1,0,0,
        0,751,753,5,175,0,0,752,751,1,0,0,0,752,753,1,0,0,0,753,757,1,0,
        0,0,754,758,5,24,0,0,755,756,5,43,0,0,756,758,5,42,0,0,757,754,1,
        0,0,0,757,755,1,0,0,0,758,760,1,0,0,0,759,761,3,100,50,0,760,759,
        1,0,0,0,760,761,1,0,0,0,761,796,1,0,0,0,762,764,5,175,0,0,763,762,
        1,0,0,0,763,764,1,0,0,0,764,766,1,0,0,0,765,767,5,44,0,0,766,765,
        1,0,0,0,766,767,1,0,0,0,767,768,1,0,0,0,768,770,5,42,0,0,769,771,
        3,92,46,0,770,769,1,0,0,0,770,771,1,0,0,0,771,773,1,0,0,0,772,774,
        3,50,25,0,773,772,1,0,0,0,773,774,1,0,0,0,774,776,1,0,0,0,775,777,
        3,100,50,0,776,775,1,0,0,0,776,777,1,0,0,0,777,796,1,0,0,0,778,780,
        5,175,0,0,779,778,1,0,0,0,779,780,1,0,0,0,780,781,1,0,0,0,781,782,
        5,45,0,0,782,784,5,42,0,0,783,785,3,64,32,0,784,783,1,0,0,0,784,
        785,1,0,0,0,785,787,1,0,0,0,786,788,3,92,46,0,787,786,1,0,0,0,787,
        788,1,0,0,0,788,790,1,0,0,0,789,791,3,50,25,0,790,789,1,0,0,0,790,
        791,1,0,0,0,791,793,1,0,0,0,792,794,3,100,50,0,793,792,1,0,0,0,793,
        794,1,0,0,0,794,796,1,0,0,0,795,752,1,0,0,0,795,763,1,0,0,0,795,
        779,1,0,0,0,796,63,1,0,0,0,797,798,5,330,0,0,798,65,1,0,0,0,799,
        800,5,46,0,0,800,803,7,6,0,0,801,802,5,68,0,0,802,804,3,150,75,0,
        803,801,1,0,0,0,803,804,1,0,0,0,804,815,1,0,0,0,805,807,5,46,0,0,
        806,808,5,183,0,0,807,806,1,0,0,0,807,808,1,0,0,0,808,809,1,0,0,
        0,809,812,5,56,0,0,810,811,5,68,0,0,811,813,3,150,75,0,812,810,1,
        0,0,0,812,813,1,0,0,0,813,815,1,0,0,0,814,799,1,0,0,0,814,805,1,
        0,0,0,815,67,1,0,0,0,816,817,5,25,0,0,817,69,1,0,0,0,818,823,3,74,
        37,0,819,820,5,2,0,0,820,822,3,74,37,0,821,819,1,0,0,0,822,825,1,
        0,0,0,823,821,1,0,0,0,823,824,1,0,0,0,824,835,1,0,0,0,825,823,1,
        0,0,0,826,831,3,72,36,0,827,828,5,2,0,0,828,830,3,72,36,0,829,827,
        1,0,0,0,830,833,1,0,0,0,831,829,1,0,0,0,831,832,1,0,0,0,832,835,
        1,0,0,0,833,831,1,0,0,0,834,818,1,0,0,0,834,826,1,0,0,0,835,71,1,
        0,0,0,836,837,3,150,75,0,837,838,7,7,0,0,838,839,3,74,37,0,839,73,
        1,0,0,0,840,842,3,150,75,0,841,843,3,76,38,0,842,841,1,0,0,0,842,
        843,1,0,0,0,843,849,1,0,0,0,844,845,5,5,0,0,845,846,3,6,3,0,846,
        847,5,6,0,0,847,849,1,0,0,0,848,840,1,0,0,0,848,844,1,0,0,0,849,
        75,1,0,0,0,850,853,5,1,0,0,851,854,5,334,0,0,852,854,3,150,75,0,
        853,851,1,0,0,0,853,852,1,0,0,0,854,855,1,0,0,0,855,856,5,3,0,0,
        856,77,1,0,0,0,857,858,3,150,75,0,858,859,3,80,40,0,859,79,1,0,0,
        0,860,861,5,310,0,0,861,81,1,0,0,0,862,863,5,301,0,0,863,865,3,86,
        43,0,864,866,3,100,50,0,865,864,1,0,0,0,865,866,1,0,0,0,866,869,
        1,0,0,0,867,868,5,250,0,0,868,870,3,112,56,0,869,867,1,0,0,0,869,
        870,1,0,0,0,870,83,1,0,0,0,871,872,5,301,0,0,872,874,3,86,43,0,873,
        875,3,100,50,0,874,873,1,0,0,0,874,875,1,0,0,0,875,878,1,0,0,0,876,
        877,5,250,0,0,877,879,3,118,59,0,878,876,1,0,0,0,878,879,1,0,0,0,
        879,85,1,0,0,0,880,881,3,150,75,0,881,882,5,4,0,0,882,884,1,0,0,
        0,883,880,1,0,0,0,883,884,1,0,0,0,884,885,1,0,0,0,885,890,3,150,
        75,0,886,887,5,7,0,0,887,889,3,150,75,0,888,886,1,0,0,0,889,892,
        1,0,0,0,890,888,1,0,0,0,890,891,1,0,0,0,891,87,1,0,0,0,892,890,1,
        0,0,0,893,894,7,8,0,0,894,901,7,9,0,0,895,897,5,50,0,0,896,895,1,
        0,0,0,896,897,1,0,0,0,897,898,1,0,0,0,898,899,5,334,0,0,899,901,
        5,249,0,0,900,893,1,0,0,0,900,896,1,0,0,0,901,89,1,0,0,0,902,911,
        5,100,0,0,903,911,5,162,0,0,904,905,5,177,0,0,905,911,5,210,0,0,
        906,907,5,242,0,0,907,911,5,210,0,0,908,909,5,147,0,0,909,911,5,
        210,0,0,910,902,1,0,0,0,910,903,1,0,0,0,910,904,1,0,0,0,910,906,
        1,0,0,0,910,908,1,0,0,0,911,91,1,0,0,0,912,914,3,94,47,0,913,912,
        1,0,0,0,913,914,1,0,0,0,914,915,1,0,0,0,915,916,5,32,0,0,916,919,
        3,96,48,0,917,918,5,76,0,0,918,920,3,102,51,0,919,917,1,0,0,0,919,
        920,1,0,0,0,920,923,1,0,0,0,921,922,5,23,0,0,922,924,3,104,52,0,
        923,921,1,0,0,0,923,924,1,0,0,0,924,936,1,0,0,0,925,927,3,94,47,
        0,926,925,1,0,0,0,926,927,1,0,0,0,927,928,1,0,0,0,928,929,5,32,0,
        0,929,930,5,76,0,0,930,933,3,102,51,0,931,932,5,23,0,0,932,934,3,
        104,52,0,933,931,1,0,0,0,933,934,1,0,0,0,934,936,1,0,0,0,935,913,
        1,0,0,0,935,926,1,0,0,0,936,93,1,0,0,0,937,938,7,10,0,0,938,95,1,
        0,0,0,939,940,6,48,-1,0,940,946,3,98,49,0,941,942,5,5,0,0,942,943,
        3,96,48,0,943,944,5,6,0,0,944,946,1,0,0,0,945,939,1,0,0,0,945,941,
        1,0,0,0,946,952,1,0,0,0,947,948,10,1,0,0,948,949,7,11,0,0,949,951,
        3,96,48,2,950,947,1,0,0,0,951,954,1,0,0,0,952,950,1,0,0,0,952,953,
        1,0,0,0,953,97,1,0,0,0,954,952,1,0,0,0,955,957,5,320,0,0,956,955,
        1,0,0,0,956,957,1,0,0,0,957,958,1,0,0,0,958,966,5,336,0,0,959,961,
        5,320,0,0,960,959,1,0,0,0,960,961,1,0,0,0,961,962,1,0,0,0,962,966,
        5,334,0,0,963,966,5,30,0,0,964,966,5,31,0,0,965,956,1,0,0,0,965,
        960,1,0,0,0,965,963,1,0,0,0,965,964,1,0,0,0,966,99,1,0,0,0,967,968,
        5,26,0,0,968,974,3,132,66,0,969,971,5,26,0,0,970,969,1,0,0,0,970,
        971,1,0,0,0,971,972,1,0,0,0,972,974,3,130,65,0,973,967,1,0,0,0,973,
        970,1,0,0,0,974,101,1,0,0,0,975,980,3,108,54,0,976,977,5,2,0,0,977,
        979,3,108,54,0,978,976,1,0,0,0,979,982,1,0,0,0,980,978,1,0,0,0,980,
        981,1,0,0,0,981,103,1,0,0,0,982,980,1,0,0,0,983,988,3,106,53,0,984,
        985,5,2,0,0,985,987,3,106,53,0,986,984,1,0,0,0,987,990,1,0,0,0,988,
        986,1,0,0,0,988,989,1,0,0,0,989,105,1,0,0,0,990,988,1,0,0,0,991,
        993,3,108,54,0,992,994,7,12,0,0,993,992,1,0,0,0,993,994,1,0,0,0,
        994,107,1,0,0,0,995,996,3,150,75,0,996,109,1,0,0,0,997,1002,3,126,
        63,0,998,999,5,2,0,0,999,1001,3,126,63,0,1000,998,1,0,0,0,1001,1004,
        1,0,0,0,1002,1000,1,0,0,0,1002,1003,1,0,0,0,1003,111,1,0,0,0,1004,
        1002,1,0,0,0,1005,1010,3,114,57,0,1006,1007,5,2,0,0,1007,1009,3,
        114,57,0,1008,1006,1,0,0,0,1009,1012,1,0,0,0,1010,1008,1,0,0,0,1010,
        1011,1,0,0,0,1011,1016,1,0,0,0,1012,1010,1,0,0,0,1013,1015,3,116,
        58,0,1014,1013,1,0,0,0,1015,1018,1,0,0,0,1016,1014,1,0,0,0,1016,
        1017,1,0,0,0,1017,113,1,0,0,0,1018,1016,1,0,0,0,1019,1022,3,120,
        60,0,1020,1022,5,321,0,0,1021,1019,1,0,0,0,1021,1020,1,0,0,0,1022,
        115,1,0,0,0,1023,1024,7,13,0,0,1024,1029,3,122,61,0,1025,1026,5,
        2,0,0,1026,1028,3,122,61,0,1027,1025,1,0,0,0,1028,1031,1,0,0,0,1029,
        1027,1,0,0,0,1029,1030,1,0,0,0,1030,1035,1,0,0,0,1031,1029,1,0,0,
        0,1032,1033,5,319,0,0,1033,1035,3,118,59,0,1034,1023,1,0,0,0,1034,
        1032,1,0,0,0,1035,117,1,0,0,0,1036,1041,3,120,60,0,1037,1038,5,2,
        0,0,1038,1040,3,120,60,0,1039,1037,1,0,0,0,1040,1043,1,0,0,0,1041,
        1039,1,0,0,0,1041,1042,1,0,0,0,1042,119,1,0,0,0,1043,1041,1,0,0,
        0,1044,1045,3,122,61,0,1045,1046,5,4,0,0,1046,1047,3,124,62,0,1047,
        121,1,0,0,0,1048,1049,3,150,75,0,1049,123,1,0,0,0,1050,1066,3,150,
        75,0,1051,1052,5,1,0,0,1052,1053,3,124,62,0,1053,1054,5,3,0,0,1054,
        1066,1,0,0,0,1055,1056,5,8,0,0,1056,1057,3,118,59,0,1057,1058,5,
        9,0,0,1058,1066,1,0,0,0,1059,1060,5,315,0,0,1060,1061,3,124,62,0,
        1061,1062,5,2,0,0,1062,1063,3,124,62,0,1063,1064,5,317,0,0,1064,
        1066,1,0,0,0,1065,1050,1,0,0,0,1065,1051,1,0,0,0,1065,1055,1,0,0,
        0,1065,1059,1,0,0,0,1066,125,1,0,0,0,1067,1068,3,122,61,0,1068,1069,
        5,4,0,0,1069,1070,3,122,61,0,1070,127,1,0,0,0,1071,1072,3,140,70,
        0,1072,129,1,0,0,0,1073,1074,5,8,0,0,1074,1076,3,132,66,0,1075,1077,
        5,2,0,0,1076,1075,1,0,0,0,1076,1077,1,0,0,0,1077,1078,1,0,0,0,1078,
        1079,5,9,0,0,1079,1092,1,0,0,0,1080,1081,5,8,0,0,1081,1092,5,9,0,
        0,1082,1083,5,5,0,0,1083,1085,3,132,66,0,1084,1086,5,2,0,0,1085,
        1084,1,0,0,0,1085,1086,1,0,0,0,1086,1087,1,0,0,0,1087,1088,5,6,0,
        0,1088,1092,1,0,0,0,1089,1090,5,5,0,0,1090,1092,5,6,0,0,1091,1073,
        1,0,0,0,1091,1080,1,0,0,0,1091,1082,1,0,0,0,1091,1089,1,0,0,0,1092,
        131,1,0,0,0,1093,1098,3,134,67,0,1094,1095,5,2,0,0,1095,1097,3,134,
        67,0,1096,1094,1,0,0,0,1097,1100,1,0,0,0,1098,1096,1,0,0,0,1098,
        1099,1,0,0,0,1099,133,1,0,0,0,1100,1098,1,0,0,0,1101,1102,3,136,
        68,0,1102,1103,7,7,0,0,1103,1104,3,140,70,0,1104,135,1,0,0,0,1105,
        1108,3,150,75,0,1106,1108,3,144,72,0,1107,1105,1,0,0,0,1107,1106,
        1,0,0,0,1108,137,1,0,0,0,1109,1110,5,1,0,0,1110,1115,3,140,70,0,
        1111,1112,5,2,0,0,1112,1114,3,140,70,0,1113,1111,1,0,0,0,1114,1117,
        1,0,0,0,1115,1113,1,0,0,0,1115,1116,1,0,0,0,1116,1119,1,0,0,0,1117,
        1115,1,0,0,0,1118,1120,5,2,0,0,1119,1118,1,0,0,0,1119,1120,1,0,0,
        0,1120,1121,1,0,0,0,1121,1122,5,3,0,0,1122,1126,1,0,0,0,1123,1124,
        5,1,0,0,1124,1126,5,3,0,0,1125,1109,1,0,0,0,1125,1123,1,0,0,0,1126,
        139,1,0,0,0,1127,1134,3,144,72,0,1128,1134,3,142,71,0,1129,1134,
        3,130,65,0,1130,1134,3,138,69,0,1131,1134,3,146,73,0,1132,1134,3,
        148,74,0,1133,1127,1,0,0,0,1133,1128,1,0,0,0,1133,1129,1,0,0,0,1133,
        1130,1,0,0,0,1133,1131,1,0,0,0,1133,1132,1,0,0,0,1134,141,1,0,0,
        0,1135,1136,3,420,210,0,1136,143,1,0,0,0,1137,1138,5,330,0,0,1138,
        145,1,0,0,0,1139,1140,7,14,0,0,1140,147,1,0,0,0,1141,1142,7,15,0,
        0,1142,149,1,0,0,0,1143,1144,3,414,207,0,1144,151,1,0,0,0,1145,1149,
        3,166,83,0,1146,1148,5,13,0,0,1147,1146,1,0,0,0,1148,1151,1,0,0,
        0,1149,1147,1,0,0,0,1149,1150,1,0,0,0,1150,1152,1,0,0,0,1151,1149,
        1,0,0,0,1152,1153,5,0,0,1,1153,153,1,0,0,0,1154,1155,3,330,165,0,
        1155,1156,5,0,0,1,1156,155,1,0,0,0,1157,1158,3,326,163,0,1158,1159,
        5,0,0,1,1159,157,1,0,0,0,1160,1161,3,324,162,0,1161,1162,5,0,0,1,
        1162,159,1,0,0,0,1163,1164,3,328,164,0,1164,1165,5,0,0,1,1165,161,
        1,0,0,0,1166,1167,3,378,189,0,1167,1168,5,0,0,1,1168,163,1,0,0,0,
        1169,1170,3,384,192,0,1170,1171,5,0,0,1,1171,165,1,0,0,0,1172,1878,
        3,182,91,0,1173,1175,3,198,99,0,1174,1173,1,0,0,0,1174,1175,1,0,
        0,0,1175,1176,1,0,0,0,1176,1878,3,226,113,0,1177,1179,5,299,0,0,
        1178,1180,5,195,0,0,1179,1178,1,0,0,0,1179,1180,1,0,0,0,1180,1181,
        1,0,0,0,1181,1878,3,324,162,0,1182,1183,5,99,0,0,1183,1187,3,192,
        96,0,1184,1185,5,156,0,0,1185,1186,5,199,0,0,1186,1188,5,129,0,0,
        1187,1184,1,0,0,0,1187,1188,1,0,0,0,1188,1189,1,0,0,0,1189,1197,
        3,324,162,0,1190,1196,3,180,90,0,1191,1196,3,178,89,0,1192,1193,
        5,308,0,0,1193,1194,7,16,0,0,1194,1196,3,206,103,0,1195,1190,1,0,
        0,0,1195,1191,1,0,0,0,1195,1192,1,0,0,0,1196,1199,1,0,0,0,1197,1195,
        1,0,0,0,1197,1198,1,0,0,0,1198,1878,1,0,0,0,1199,1197,1,0,0,0,1200,
        1201,5,61,0,0,1201,1202,3,192,96,0,1202,1203,3,324,162,0,1203,1204,
        5,258,0,0,1204,1205,7,16,0,0,1205,1206,3,206,103,0,1206,1878,1,0,
        0,0,1207,1208,5,61,0,0,1208,1209,3,192,96,0,1209,1210,3,324,162,
        0,1210,1211,5,258,0,0,1211,1212,3,178,89,0,1212,1878,1,0,0,0,1213,
        1214,5,122,0,0,1214,1217,3,192,96,0,1215,1216,5,156,0,0,1216,1218,
        5,129,0,0,1217,1215,1,0,0,0,1217,1218,1,0,0,0,1218,1219,1,0,0,0,
        1219,1221,3,324,162,0,1220,1222,7,17,0,0,1221,1220,1,0,0,0,1221,
        1222,1,0,0,0,1222,1878,1,0,0,0,1223,1224,5,261,0,0,1224,1227,7,18,
        0,0,1225,1226,7,19,0,0,1226,1228,3,324,162,0,1227,1225,1,0,0,0,1227,
        1228,1,0,0,0,1228,1233,1,0,0,0,1229,1231,5,178,0,0,1230,1229,1,0,
        0,0,1230,1231,1,0,0,0,1231,1232,1,0,0,0,1232,1234,5,330,0,0,1233,
        1230,1,0,0,0,1233,1234,1,0,0,0,1234,1878,1,0,0,0,1235,1240,3,170,
        85,0,1236,1237,5,5,0,0,1237,1238,3,384,192,0,1238,1239,5,6,0,0,1239,
        1241,1,0,0,0,1240,1236,1,0,0,0,1240,1241,1,0,0,0,1241,1242,1,0,0,
        0,1242,1243,3,202,101,0,1243,1248,3,204,102,0,1244,1246,5,68,0,0,
        1245,1244,1,0,0,0,1245,1246,1,0,0,0,1246,1247,1,0,0,0,1247,1249,
        3,182,91,0,1248,1245,1,0,0,0,1248,1249,1,0,0,0,1249,1878,1,0,0,0,
        1250,1255,3,170,85,0,1251,1252,5,5,0,0,1252,1253,3,384,192,0,1253,
        1254,5,6,0,0,1254,1256,1,0,0,0,1255,1251,1,0,0,0,1255,1256,1,0,0,
        0,1256,1278,1,0,0,0,1257,1277,3,180,90,0,1258,1259,5,217,0,0,1259,
        1260,5,76,0,0,1260,1261,5,5,0,0,1261,1262,3,384,192,0,1262,1263,
        5,6,0,0,1263,1268,1,0,0,0,1264,1265,5,217,0,0,1265,1266,5,76,0,0,
        1266,1268,3,300,150,0,1267,1258,1,0,0,0,1267,1264,1,0,0,0,1268,1277,
        1,0,0,0,1269,1277,3,174,87,0,1270,1277,3,176,88,0,1271,1277,3,320,
        160,0,1272,1277,3,218,109,0,1273,1277,3,178,89,0,1274,1275,5,276,
        0,0,1275,1277,3,206,103,0,1276,1257,1,0,0,0,1276,1267,1,0,0,0,1276,
        1269,1,0,0,0,1276,1270,1,0,0,0,1276,1271,1,0,0,0,1276,1272,1,0,0,
        0,1276,1273,1,0,0,0,1276,1274,1,0,0,0,1277,1280,1,0,0,0,1278,1276,
        1,0,0,0,1278,1279,1,0,0,0,1279,1285,1,0,0,0,1280,1278,1,0,0,0,1281,
        1283,5,68,0,0,1282,1281,1,0,0,0,1282,1283,1,0,0,0,1283,1284,1,0,
        0,0,1284,1286,3,182,91,0,1285,1282,1,0,0,0,1285,1286,1,0,0,0,1286,
        1878,1,0,0,0,1287,1288,5,99,0,0,1288,1292,5,273,0,0,1289,1290,5,
        156,0,0,1290,1291,5,199,0,0,1291,1293,5,129,0,0,1292,1289,1,0,0,
        0,1292,1293,1,0,0,0,1293,1294,1,0,0,0,1294,1295,3,326,163,0,1295,
        1296,5,178,0,0,1296,1305,3,326,163,0,1297,1304,3,202,101,0,1298,
        1304,3,320,160,0,1299,1304,3,218,109,0,1300,1304,3,178,89,0,1301,
        1302,5,276,0,0,1302,1304,3,206,103,0,1303,1297,1,0,0,0,1303,1298,
        1,0,0,0,1303,1299,1,0,0,0,1303,1300,1,0,0,0,1303,1301,1,0,0,0,1304,
        1307,1,0,0,0,1305,1303,1,0,0,0,1305,1306,1,0,0,0,1306,1878,1,0,0,
        0,1307,1305,1,0,0,0,1308,1313,3,172,86,0,1309,1310,5,5,0,0,1310,
        1311,3,384,192,0,1311,1312,5,6,0,0,1312,1314,1,0,0,0,1313,1309,1,
        0,0,0,1313,1314,1,0,0,0,1314,1315,1,0,0,0,1315,1316,3,202,101,0,
        1316,1321,3,204,102,0,1317,1319,5,68,0,0,1318,1317,1,0,0,0,1318,
        1319,1,0,0,0,1319,1320,1,0,0,0,1320,1322,3,182,91,0,1321,1318,1,
        0,0,0,1321,1322,1,0,0,0,1322,1878,1,0,0,0,1323,1324,5,62,0,0,1324,
        1325,5,273,0,0,1325,1327,3,324,162,0,1326,1328,3,188,94,0,1327,1326,
        1,0,0,0,1327,1328,1,0,0,0,1328,1329,1,0,0,0,1329,1330,5,95,0,0,1330,
        1338,5,267,0,0,1331,1339,3,414,207,0,1332,1333,5,142,0,0,1333,1334,
        5,90,0,0,1334,1339,3,302,151,0,1335,1336,5,142,0,0,1336,1337,5,60,
        0,0,1337,1339,5,90,0,0,1338,1331,1,0,0,0,1338,1332,1,0,0,0,1338,
        1335,1,0,0,0,1338,1339,1,0,0,0,1339,1878,1,0,0,0,1340,1341,5,61,
        0,0,1341,1342,5,273,0,0,1342,1343,3,324,162,0,1343,1344,5,58,0,0,
        1344,1345,7,20,0,0,1345,1346,3,380,190,0,1346,1878,1,0,0,0,1347,
        1348,5,61,0,0,1348,1349,5,273,0,0,1349,1350,3,324,162,0,1350,1351,
        5,58,0,0,1351,1352,7,20,0,0,1352,1353,5,5,0,0,1353,1354,3,380,190,
        0,1354,1355,5,6,0,0,1355,1878,1,0,0,0,1356,1357,5,61,0,0,1357,1358,
        5,273,0,0,1358,1359,3,324,162,0,1359,1360,5,236,0,0,1360,1361,5,
        89,0,0,1361,1362,3,324,162,0,1362,1363,5,280,0,0,1363,1364,3,410,
        205,0,1364,1878,1,0,0,0,1365,1366,5,61,0,0,1366,1367,5,273,0,0,1367,
        1368,3,324,162,0,1368,1369,5,122,0,0,1369,1370,7,20,0,0,1370,1371,
        5,5,0,0,1371,1372,3,322,161,0,1372,1373,5,6,0,0,1373,1878,1,0,0,
        0,1374,1375,5,61,0,0,1375,1376,5,273,0,0,1376,1377,3,324,162,0,1377,
        1378,5,122,0,0,1378,1379,7,20,0,0,1379,1380,3,322,161,0,1380,1878,
        1,0,0,0,1381,1382,5,61,0,0,1382,1383,7,21,0,0,1383,1384,3,324,162,
        0,1384,1385,5,236,0,0,1385,1386,5,280,0,0,1386,1387,3,324,162,0,
        1387,1878,1,0,0,0,1388,1389,5,61,0,0,1389,1390,7,21,0,0,1390,1391,
        3,324,162,0,1391,1392,5,258,0,0,1392,1393,5,276,0,0,1393,1394,3,
        206,103,0,1394,1878,1,0,0,0,1395,1396,5,61,0,0,1396,1397,7,21,0,
        0,1397,1398,3,324,162,0,1398,1399,5,297,0,0,1399,1402,5,276,0,0,
        1400,1401,5,156,0,0,1401,1403,5,129,0,0,1402,1400,1,0,0,0,1402,1403,
        1,0,0,0,1403,1404,1,0,0,0,1404,1405,3,206,103,0,1405,1878,1,0,0,
        0,1406,1407,5,61,0,0,1407,1408,5,273,0,0,1408,1409,3,324,162,0,1409,
        1411,7,22,0,0,1410,1412,5,89,0,0,1411,1410,1,0,0,0,1411,1412,1,0,
        0,0,1412,1413,1,0,0,0,1413,1415,3,324,162,0,1414,1416,3,422,211,
        0,1415,1414,1,0,0,0,1415,1416,1,0,0,0,1416,1878,1,0,0,0,1417,1418,
        5,61,0,0,1418,1419,5,273,0,0,1419,1421,3,324,162,0,1420,1422,3,188,
        94,0,1421,1420,1,0,0,0,1421,1422,1,0,0,0,1422,1423,1,0,0,0,1423,
        1425,5,81,0,0,1424,1426,5,89,0,0,1425,1424,1,0,0,0,1425,1426,1,0,
        0,0,1426,1427,1,0,0,0,1427,1428,3,324,162,0,1428,1430,3,386,193,
        0,1429,1431,3,376,188,0,1430,1429,1,0,0,0,1430,1431,1,0,0,0,1431,
        1878,1,0,0,0,1432,1433,5,61,0,0,1433,1434,5,273,0,0,1434,1436,3,
        324,162,0,1435,1437,3,188,94,0,1436,1435,1,0,0,0,1436,1437,1,0,0,
        0,1437,1438,1,0,0,0,1438,1439,5,238,0,0,1439,1440,5,90,0,0,1440,
        1441,5,5,0,0,1441,1442,3,380,190,0,1442,1443,5,6,0,0,1443,1878,1,
        0,0,0,1444,1445,5,61,0,0,1445,1446,5,273,0,0,1446,1448,3,324,162,
        0,1447,1449,3,188,94,0,1448,1447,1,0,0,0,1448,1449,1,0,0,0,1449,
        1450,1,0,0,0,1450,1451,5,258,0,0,1451,1452,5,255,0,0,1452,1456,5,
        330,0,0,1453,1454,5,308,0,0,1454,1455,5,256,0,0,1455,1457,3,206,
        103,0,1456,1453,1,0,0,0,1456,1457,1,0,0,0,1457,1878,1,0,0,0,1458,
        1459,5,61,0,0,1459,1460,5,273,0,0,1460,1462,3,324,162,0,1461,1463,
        3,188,94,0,1462,1461,1,0,0,0,1462,1463,1,0,0,0,1463,1464,1,0,0,0,
        1464,1465,5,258,0,0,1465,1466,5,256,0,0,1466,1467,3,206,103,0,1467,
        1878,1,0,0,0,1468,1469,5,61,0,0,1469,1470,7,21,0,0,1470,1471,3,324,
        162,0,1471,1475,5,58,0,0,1472,1473,5,156,0,0,1473,1474,5,199,0,0,
        1474,1476,5,129,0,0,1475,1472,1,0,0,0,1475,1476,1,0,0,0,1476,1478,
        1,0,0,0,1477,1479,3,186,93,0,1478,1477,1,0,0,0,1479,1480,1,0,0,0,
        1480,1478,1,0,0,0,1480,1481,1,0,0,0,1481,1878,1,0,0,0,1482,1483,
        5,61,0,0,1483,1484,5,273,0,0,1484,1485,3,324,162,0,1485,1486,3,188,
        94,0,1486,1487,5,236,0,0,1487,1488,5,280,0,0,1488,1489,3,188,94,
        0,1489,1878,1,0,0,0,1490,1491,5,61,0,0,1491,1492,7,21,0,0,1492,1493,
        3,324,162,0,1493,1496,5,122,0,0,1494,1495,5,156,0,0,1495,1497,5,
        129,0,0,1496,1494,1,0,0,0,1496,1497,1,0,0,0,1497,1498,1,0,0,0,1498,
        1503,3,188,94,0,1499,1500,5,2,0,0,1500,1502,3,188,94,0,1501,1499,
        1,0,0,0,1502,1505,1,0,0,0,1503,1501,1,0,0,0,1503,1504,1,0,0,0,1504,
        1507,1,0,0,0,1505,1503,1,0,0,0,1506,1508,5,227,0,0,1507,1506,1,0,
        0,0,1507,1508,1,0,0,0,1508,1878,1,0,0,0,1509,1510,5,61,0,0,1510,
        1511,5,273,0,0,1511,1513,3,324,162,0,1512,1514,3,188,94,0,1513,1512,
        1,0,0,0,1513,1514,1,0,0,0,1514,1515,1,0,0,0,1515,1516,5,258,0,0,
        1516,1517,3,178,89,0,1517,1878,1,0,0,0,1518,1519,5,61,0,0,1519,1520,
        5,273,0,0,1520,1521,3,324,162,0,1521,1522,5,232,0,0,1522,1523,5,
        218,0,0,1523,1878,1,0,0,0,1524,1525,5,122,0,0,1525,1528,5,273,0,
        0,1526,1527,5,156,0,0,1527,1529,5,129,0,0,1528,1526,1,0,0,0,1528,
        1529,1,0,0,0,1529,1530,1,0,0,0,1530,1532,3,324,162,0,1531,1533,5,
        227,0,0,1532,1531,1,0,0,0,1532,1533,1,0,0,0,1533,1878,1,0,0,0,1534,
        1535,5,122,0,0,1535,1538,5,303,0,0,1536,1537,5,156,0,0,1537,1539,
        5,129,0,0,1538,1536,1,0,0,0,1538,1539,1,0,0,0,1539,1540,1,0,0,0,
        1540,1878,3,324,162,0,1541,1544,5,99,0,0,1542,1543,5,207,0,0,1543,
        1545,5,238,0,0,1544,1542,1,0,0,0,1544,1545,1,0,0,0,1545,1550,1,0,
        0,0,1546,1548,5,150,0,0,1547,1546,1,0,0,0,1547,1548,1,0,0,0,1548,
        1549,1,0,0,0,1549,1551,5,277,0,0,1550,1547,1,0,0,0,1550,1551,1,0,
        0,0,1551,1552,1,0,0,0,1552,1556,5,303,0,0,1553,1554,5,156,0,0,1554,
        1555,5,199,0,0,1555,1557,5,129,0,0,1556,1553,1,0,0,0,1556,1557,1,
        0,0,0,1557,1558,1,0,0,0,1558,1560,3,324,162,0,1559,1561,3,308,154,
        0,1560,1559,1,0,0,0,1560,1561,1,0,0,0,1561,1570,1,0,0,0,1562,1569,
        3,180,90,0,1563,1564,5,217,0,0,1564,1565,5,203,0,0,1565,1569,3,300,
        150,0,1566,1567,5,276,0,0,1567,1569,3,206,103,0,1568,1562,1,0,0,
        0,1568,1563,1,0,0,0,1568,1566,1,0,0,0,1569,1572,1,0,0,0,1570,1568,
        1,0,0,0,1570,1571,1,0,0,0,1571,1573,1,0,0,0,1572,1570,1,0,0,0,1573,
        1574,5,68,0,0,1574,1575,3,182,91,0,1575,1878,1,0,0,0,1576,1579,5,
        99,0,0,1577,1578,5,207,0,0,1578,1580,5,238,0,0,1579,1577,1,0,0,0,
        1579,1580,1,0,0,0,1580,1582,1,0,0,0,1581,1583,5,150,0,0,1582,1581,
        1,0,0,0,1582,1583,1,0,0,0,1583,1584,1,0,0,0,1584,1585,5,277,0,0,
        1585,1586,5,303,0,0,1586,1591,3,326,163,0,1587,1588,5,5,0,0,1588,
        1589,3,384,192,0,1589,1590,5,6,0,0,1590,1592,1,0,0,0,1591,1587,1,
        0,0,0,1591,1592,1,0,0,0,1592,1593,1,0,0,0,1593,1596,3,202,101,0,
        1594,1595,5,206,0,0,1595,1597,3,206,103,0,1596,1594,1,0,0,0,1596,
        1597,1,0,0,0,1597,1878,1,0,0,0,1598,1599,5,61,0,0,1599,1600,5,303,
        0,0,1600,1602,3,324,162,0,1601,1603,5,68,0,0,1602,1601,1,0,0,0,1602,
        1603,1,0,0,0,1603,1604,1,0,0,0,1604,1605,3,182,91,0,1605,1878,1,
        0,0,0,1606,1609,5,99,0,0,1607,1608,5,207,0,0,1608,1610,5,238,0,0,
        1609,1607,1,0,0,0,1609,1610,1,0,0,0,1610,1612,1,0,0,0,1611,1613,
        5,277,0,0,1612,1611,1,0,0,0,1612,1613,1,0,0,0,1613,1614,1,0,0,0,
        1614,1618,5,148,0,0,1615,1616,5,156,0,0,1616,1617,5,199,0,0,1617,
        1619,5,129,0,0,1618,1615,1,0,0,0,1618,1619,1,0,0,0,1619,1620,1,0,
        0,0,1620,1621,3,324,162,0,1621,1622,5,68,0,0,1622,1632,5,330,0,0,
        1623,1624,5,301,0,0,1624,1629,3,224,112,0,1625,1626,5,2,0,0,1626,
        1628,3,224,112,0,1627,1625,1,0,0,0,1628,1631,1,0,0,0,1629,1627,1,
        0,0,0,1629,1630,1,0,0,0,1630,1633,1,0,0,0,1631,1629,1,0,0,0,1632,
        1623,1,0,0,0,1632,1633,1,0,0,0,1633,1878,1,0,0,0,1634,1636,5,122,
        0,0,1635,1637,5,277,0,0,1636,1635,1,0,0,0,1636,1637,1,0,0,0,1637,
        1638,1,0,0,0,1638,1641,5,148,0,0,1639,1640,5,156,0,0,1640,1642,5,
        129,0,0,1641,1639,1,0,0,0,1641,1642,1,0,0,0,1642,1643,1,0,0,0,1643,
        1878,3,324,162,0,1644,1646,5,130,0,0,1645,1647,7,23,0,0,1646,1645,
        1,0,0,0,1646,1647,1,0,0,0,1647,1648,1,0,0,0,1648,1878,3,166,83,0,
        1649,1650,5,261,0,0,1650,1653,5,274,0,0,1651,1652,7,19,0,0,1652,
        1654,3,324,162,0,1653,1651,1,0,0,0,1653,1654,1,0,0,0,1654,1659,1,
        0,0,0,1655,1657,5,178,0,0,1656,1655,1,0,0,0,1656,1657,1,0,0,0,1657,
        1658,1,0,0,0,1658,1660,5,330,0,0,1659,1656,1,0,0,0,1659,1660,1,0,
        0,0,1660,1878,1,0,0,0,1661,1662,5,261,0,0,1662,1663,5,273,0,0,1663,
        1666,5,132,0,0,1664,1665,7,19,0,0,1665,1667,3,324,162,0,1666,1664,
        1,0,0,0,1666,1667,1,0,0,0,1667,1668,1,0,0,0,1668,1669,5,178,0,0,
        1669,1671,5,330,0,0,1670,1672,3,188,94,0,1671,1670,1,0,0,0,1671,
        1672,1,0,0,0,1672,1878,1,0,0,0,1673,1674,5,261,0,0,1674,1675,5,276,
        0,0,1675,1680,3,324,162,0,1676,1677,5,5,0,0,1677,1678,3,210,105,
        0,1678,1679,5,6,0,0,1679,1681,1,0,0,0,1680,1676,1,0,0,0,1680,1681,
        1,0,0,0,1681,1878,1,0,0,0,1682,1683,5,261,0,0,1683,1684,5,90,0,0,
        1684,1685,7,19,0,0,1685,1688,3,324,162,0,1686,1687,7,19,0,0,1687,
        1689,3,324,162,0,1688,1686,1,0,0,0,1688,1689,1,0,0,0,1689,1878,1,
        0,0,0,1690,1691,5,261,0,0,1691,1694,5,304,0,0,1692,1693,7,19,0,0,
        1693,1695,3,324,162,0,1694,1692,1,0,0,0,1694,1695,1,0,0,0,1695,1700,
        1,0,0,0,1696,1698,5,178,0,0,1697,1696,1,0,0,0,1697,1698,1,0,0,0,
        1698,1699,1,0,0,0,1699,1701,5,330,0,0,1700,1697,1,0,0,0,1700,1701,
        1,0,0,0,1701,1878,1,0,0,0,1702,1703,5,261,0,0,1703,1704,5,218,0,
        0,1704,1706,3,324,162,0,1705,1707,3,188,94,0,1706,1705,1,0,0,0,1706,
        1707,1,0,0,0,1707,1878,1,0,0,0,1708,1710,5,261,0,0,1709,1711,3,414,
        207,0,1710,1709,1,0,0,0,1710,1711,1,0,0,0,1711,1712,1,0,0,0,1712,
        1720,5,149,0,0,1713,1715,5,178,0,0,1714,1713,1,0,0,0,1714,1715,1,
        0,0,0,1715,1718,1,0,0,0,1716,1719,3,324,162,0,1717,1719,5,330,0,
        0,1718,1716,1,0,0,0,1718,1717,1,0,0,0,1719,1721,1,0,0,0,1720,1714,
        1,0,0,0,1720,1721,1,0,0,0,1721,1878,1,0,0,0,1722,1723,5,261,0,0,
        1723,1724,5,99,0,0,1724,1725,5,273,0,0,1725,1728,3,324,162,0,1726,
        1727,5,68,0,0,1727,1729,5,255,0,0,1728,1726,1,0,0,0,1728,1729,1,
        0,0,0,1729,1878,1,0,0,0,1730,1731,5,261,0,0,1731,1732,5,102,0,0,
        1732,1878,5,195,0,0,1733,1734,7,24,0,0,1734,1736,5,148,0,0,1735,
        1737,5,132,0,0,1736,1735,1,0,0,0,1736,1737,1,0,0,0,1737,1738,1,0,
        0,0,1738,1878,3,194,97,0,1739,1740,7,24,0,0,1740,1742,3,192,96,0,
        1741,1743,5,132,0,0,1742,1741,1,0,0,0,1742,1743,1,0,0,0,1743,1744,
        1,0,0,0,1744,1745,3,324,162,0,1745,1878,1,0,0,0,1746,1748,7,24,0,
        0,1747,1749,5,273,0,0,1748,1747,1,0,0,0,1748,1749,1,0,0,0,1749,1751,
        1,0,0,0,1750,1752,7,25,0,0,1751,1750,1,0,0,0,1751,1752,1,0,0,0,1752,
        1753,1,0,0,0,1753,1755,3,324,162,0,1754,1756,3,188,94,0,1755,1754,
        1,0,0,0,1755,1756,1,0,0,0,1756,1758,1,0,0,0,1757,1759,3,196,98,0,
        1758,1757,1,0,0,0,1758,1759,1,0,0,0,1759,1878,1,0,0,0,1760,1762,
        7,24,0,0,1761,1763,5,228,0,0,1762,1761,1,0,0,0,1762,1763,1,0,0,0,
        1763,1764,1,0,0,0,1764,1878,3,182,91,0,1765,1766,5,91,0,0,1766,1767,
        5,203,0,0,1767,1768,3,192,96,0,1768,1769,3,324,162,0,1769,1770,5,
        169,0,0,1770,1771,7,26,0,0,1771,1878,1,0,0,0,1772,1773,5,91,0,0,
        1773,1774,5,203,0,0,1774,1775,5,273,0,0,1775,1776,3,324,162,0,1776,
        1777,5,169,0,0,1777,1778,7,26,0,0,1778,1878,1,0,0,0,1779,1780,5,
        235,0,0,1780,1781,5,273,0,0,1781,1878,3,324,162,0,1782,1790,5,235,
        0,0,1783,1791,5,330,0,0,1784,1786,9,0,0,0,1785,1784,1,0,0,0,1786,
        1789,1,0,0,0,1787,1788,1,0,0,0,1787,1785,1,0,0,0,1788,1791,1,0,0,
        0,1789,1787,1,0,0,0,1790,1783,1,0,0,0,1790,1787,1,0,0,0,1791,1878,
        1,0,0,0,1792,1794,5,77,0,0,1793,1795,5,175,0,0,1794,1793,1,0,0,0,
        1794,1795,1,0,0,0,1795,1796,1,0,0,0,1796,1797,5,273,0,0,1797,1800,
        3,324,162,0,1798,1799,5,206,0,0,1799,1801,3,206,103,0,1800,1798,
        1,0,0,0,1800,1801,1,0,0,0,1801,1806,1,0,0,0,1802,1804,5,68,0,0,1803,
        1802,1,0,0,0,1803,1804,1,0,0,0,1804,1805,1,0,0,0,1805,1807,3,182,
        91,0,1806,1803,1,0,0,0,1806,1807,1,0,0,0,1807,1878,1,0,0,0,1808,
        1809,5,292,0,0,1809,1812,5,273,0,0,1810,1811,5,156,0,0,1811,1813,
        5,129,0,0,1812,1810,1,0,0,0,1812,1813,1,0,0,0,1813,1814,1,0,0,0,
        1814,1878,3,324,162,0,1815,1816,5,83,0,0,1816,1878,5,77,0,0,1817,
        1818,5,182,0,0,1818,1820,5,107,0,0,1819,1821,5,183,0,0,1820,1819,
        1,0,0,0,1820,1821,1,0,0,0,1821,1822,1,0,0,0,1822,1823,5,163,0,0,
        1823,1825,5,330,0,0,1824,1826,5,215,0,0,1825,1824,1,0,0,0,1825,1826,
        1,0,0,0,1826,1827,1,0,0,0,1827,1828,5,168,0,0,1828,1829,5,273,0,
        0,1829,1831,3,324,162,0,1830,1832,3,188,94,0,1831,1830,1,0,0,0,1831,
        1832,1,0,0,0,1832,1878,1,0,0,0,1833,1834,5,288,0,0,1834,1835,5,273,
        0,0,1835,1837,3,324,162,0,1836,1838,3,188,94,0,1837,1836,1,0,0,0,
        1837,1838,1,0,0,0,1838,1878,1,0,0,0,1839,1840,5,194,0,0,1840,1841,
        5,237,0,0,1841,1842,5,273,0,0,1842,1878,3,324,162,0,1843,1844,7,
        27,0,0,1844,1852,3,414,207,0,1845,1853,5,330,0,0,1846,1848,9,0,0,
        0,1847,1846,1,0,0,0,1848,1851,1,0,0,0,1849,1850,1,0,0,0,1849,1847,
        1,0,0,0,1850,1853,1,0,0,0,1851,1849,1,0,0,0,1852,1845,1,0,0,0,1852,
        1849,1,0,0,0,1853,1878,1,0,0,0,1854,1855,5,258,0,0,1855,1859,5,244,
        0,0,1856,1858,9,0,0,0,1857,1856,1,0,0,0,1858,1861,1,0,0,0,1859,1860,
        1,0,0,0,1859,1857,1,0,0,0,1860,1878,1,0,0,0,1861,1859,1,0,0,0,1862,
        1866,5,258,0,0,1863,1865,9,0,0,0,1864,1863,1,0,0,0,1865,1868,1,0,
        0,0,1866,1867,1,0,0,0,1866,1864,1,0,0,0,1867,1878,1,0,0,0,1868,1866,
        1,0,0,0,1869,1878,5,239,0,0,1870,1874,3,168,84,0,1871,1873,9,0,0,
        0,1872,1871,1,0,0,0,1873,1876,1,0,0,0,1874,1875,1,0,0,0,1874,1872,
        1,0,0,0,1875,1878,1,0,0,0,1876,1874,1,0,0,0,1877,1172,1,0,0,0,1877,
        1174,1,0,0,0,1877,1177,1,0,0,0,1877,1182,1,0,0,0,1877,1200,1,0,0,
        0,1877,1207,1,0,0,0,1877,1213,1,0,0,0,1877,1223,1,0,0,0,1877,1235,
        1,0,0,0,1877,1250,1,0,0,0,1877,1287,1,0,0,0,1877,1308,1,0,0,0,1877,
        1323,1,0,0,0,1877,1340,1,0,0,0,1877,1347,1,0,0,0,1877,1356,1,0,0,
        0,1877,1365,1,0,0,0,1877,1374,1,0,0,0,1877,1381,1,0,0,0,1877,1388,
        1,0,0,0,1877,1395,1,0,0,0,1877,1406,1,0,0,0,1877,1417,1,0,0,0,1877,
        1432,1,0,0,0,1877,1444,1,0,0,0,1877,1458,1,0,0,0,1877,1468,1,0,0,
        0,1877,1482,1,0,0,0,1877,1490,1,0,0,0,1877,1509,1,0,0,0,1877,1518,
        1,0,0,0,1877,1524,1,0,0,0,1877,1534,1,0,0,0,1877,1541,1,0,0,0,1877,
        1576,1,0,0,0,1877,1598,1,0,0,0,1877,1606,1,0,0,0,1877,1634,1,0,0,
        0,1877,1644,1,0,0,0,1877,1649,1,0,0,0,1877,1661,1,0,0,0,1877,1673,
        1,0,0,0,1877,1682,1,0,0,0,1877,1690,1,0,0,0,1877,1702,1,0,0,0,1877,
        1708,1,0,0,0,1877,1722,1,0,0,0,1877,1730,1,0,0,0,1877,1733,1,0,0,
        0,1877,1739,1,0,0,0,1877,1746,1,0,0,0,1877,1760,1,0,0,0,1877,1765,
        1,0,0,0,1877,1772,1,0,0,0,1877,1779,1,0,0,0,1877,1782,1,0,0,0,1877,
        1792,1,0,0,0,1877,1808,1,0,0,0,1877,1815,1,0,0,0,1877,1817,1,0,0,
        0,1877,1833,1,0,0,0,1877,1839,1,0,0,0,1877,1843,1,0,0,0,1877,1854,
        1,0,0,0,1877,1862,1,0,0,0,1877,1869,1,0,0,0,1877,1870,1,0,0,0,1878,
        167,1,0,0,0,1879,1880,5,99,0,0,1880,2048,5,244,0,0,1881,1882,5,122,
        0,0,1882,2048,5,244,0,0,1883,1885,5,151,0,0,1884,1886,5,244,0,0,
        1885,1884,1,0,0,0,1885,1886,1,0,0,0,1886,2048,1,0,0,0,1887,1889,
        5,241,0,0,1888,1890,5,244,0,0,1889,1888,1,0,0,0,1889,1890,1,0,0,
        0,1890,2048,1,0,0,0,1891,1892,5,261,0,0,1892,2048,5,151,0,0,1893,
        1894,5,261,0,0,1894,1896,5,244,0,0,1895,1897,5,151,0,0,1896,1895,
        1,0,0,0,1896,1897,1,0,0,0,1897,2048,1,0,0,0,1898,1899,5,261,0,0,
        1899,2048,5,225,0,0,1900,1901,5,261,0,0,1901,2048,5,245,0,0,1902,
        1903,5,261,0,0,1903,1904,5,102,0,0,1904,2048,5,245,0,0,1905,1906,
        5,131,0,0,1906,2048,5,273,0,0,1907,1908,5,158,0,0,1908,2048,5,273,
        0,0,1909,1910,5,261,0,0,1910,2048,5,94,0,0,1911,1912,5,261,0,0,1912,
        1913,5,99,0,0,1913,2048,5,273,0,0,1914,1915,5,261,0,0,1915,2048,
        5,284,0,0,1916,1917,5,261,0,0,1917,2048,5,161,0,0,1918,1919,5,261,
        0,0,1919,2048,5,186,0,0,1920,1921,5,99,0,0,1921,2048,5,160,0,0,1922,
        1923,5,122,0,0,1923,2048,5,160,0,0,1924,1925,5,61,0,0,1925,2048,
        5,160,0,0,1926,1927,5,185,0,0,1927,2048,5,273,0,0,1928,1929,5,185,
        0,0,1929,2048,5,108,0,0,1930,1931,5,296,0,0,1931,2048,5,273,0,0,
        1932,1933,5,296,0,0,1933,2048,5,108,0,0,1934,1935,5,99,0,0,1935,
        1936,5,277,0,0,1936,2048,5,188,0,0,1937,1938,5,122,0,0,1938,1939,
        5,277,0,0,1939,2048,5,188,0,0,1940,1941,5,61,0,0,1941,1942,5,273,
        0,0,1942,1943,3,326,163,0,1943,1944,5,199,0,0,1944,1945,5,85,0,0,
        1945,2048,1,0,0,0,1946,1947,5,61,0,0,1947,1948,5,273,0,0,1948,1949,
        3,326,163,0,1949,1950,5,85,0,0,1950,1951,5,76,0,0,1951,2048,1,0,
        0,0,1952,1953,5,61,0,0,1953,1954,5,273,0,0,1954,1955,3,326,163,0,
        1955,1956,5,199,0,0,1956,1957,5,265,0,0,1957,2048,1,0,0,0,1958,1959,
        5,61,0,0,1959,1960,5,273,0,0,1960,1961,3,326,163,0,1961,1962,5,262,
        0,0,1962,1963,5,76,0,0,1963,2048,1,0,0,0,1964,1965,5,61,0,0,1965,
        1966,5,273,0,0,1966,1967,3,326,163,0,1967,1968,5,199,0,0,1968,1969,
        5,262,0,0,1969,2048,1,0,0,0,1970,1971,5,61,0,0,1971,1972,5,273,0,
        0,1972,1973,3,326,163,0,1973,1974,5,199,0,0,1974,1975,5,268,0,0,
        1975,1976,5,68,0,0,1976,1977,5,118,0,0,1977,2048,1,0,0,0,1978,1979,
        5,61,0,0,1979,1980,5,273,0,0,1980,1981,3,326,163,0,1981,1982,5,258,
        0,0,1982,1983,5,262,0,0,1983,1984,5,184,0,0,1984,2048,1,0,0,0,1985,
        1986,5,61,0,0,1986,1987,5,273,0,0,1987,1988,3,326,163,0,1988,1989,
        5,128,0,0,1989,1990,5,216,0,0,1990,2048,1,0,0,0,1991,1992,5,61,0,
        0,1992,1993,5,273,0,0,1993,1994,3,326,163,0,1994,1995,5,66,0,0,1995,
        1996,5,216,0,0,1996,2048,1,0,0,0,1997,1998,5,61,0,0,1998,1999,5,
        273,0,0,1999,2000,3,326,163,0,2000,2001,5,290,0,0,2001,2002,5,216,
        0,0,2002,2048,1,0,0,0,2003,2004,5,61,0,0,2004,2005,5,273,0,0,2005,
        2006,3,326,163,0,2006,2007,5,281,0,0,2007,2048,1,0,0,0,2008,2009,
        5,61,0,0,2009,2010,5,273,0,0,2010,2012,3,326,163,0,2011,2013,3,188,
        94,0,2012,2011,1,0,0,0,2012,2013,1,0,0,0,2013,2014,1,0,0,0,2014,
        2015,5,93,0,0,2015,2048,1,0,0,0,2016,2017,5,61,0,0,2017,2018,5,273,
        0,0,2018,2020,3,326,163,0,2019,2021,3,188,94,0,2020,2019,1,0,0,0,
        2020,2021,1,0,0,0,2021,2022,1,0,0,0,2022,2023,5,96,0,0,2023,2048,
        1,0,0,0,2024,2025,5,61,0,0,2025,2026,5,273,0,0,2026,2028,3,326,163,
        0,2027,2029,3,188,94,0,2028,2027,1,0,0,0,2028,2029,1,0,0,0,2029,
        2030,1,0,0,0,2030,2031,5,258,0,0,2031,2032,5,139,0,0,2032,2048,1,
        0,0,0,2033,2034,5,61,0,0,2034,2035,5,273,0,0,2035,2037,3,326,163,
        0,2036,2038,3,188,94,0,2037,2036,1,0,0,0,2037,2038,1,0,0,0,2038,
        2039,1,0,0,0,2039,2040,5,238,0,0,2040,2041,5,90,0,0,2041,2048,1,
        0,0,0,2042,2043,5,266,0,0,2043,2048,5,283,0,0,2044,2048,5,92,0,0,
        2045,2048,5,246,0,0,2046,2048,5,117,0,0,2047,1879,1,0,0,0,2047,1881,
        1,0,0,0,2047,1883,1,0,0,0,2047,1887,1,0,0,0,2047,1891,1,0,0,0,2047,
        1893,1,0,0,0,2047,1898,1,0,0,0,2047,1900,1,0,0,0,2047,1902,1,0,0,
        0,2047,1905,1,0,0,0,2047,1907,1,0,0,0,2047,1909,1,0,0,0,2047,1911,
        1,0,0,0,2047,1914,1,0,0,0,2047,1916,1,0,0,0,2047,1918,1,0,0,0,2047,
        1920,1,0,0,0,2047,1922,1,0,0,0,2047,1924,1,0,0,0,2047,1926,1,0,0,
        0,2047,1928,1,0,0,0,2047,1930,1,0,0,0,2047,1932,1,0,0,0,2047,1934,
        1,0,0,0,2047,1937,1,0,0,0,2047,1940,1,0,0,0,2047,1946,1,0,0,0,2047,
        1952,1,0,0,0,2047,1958,1,0,0,0,2047,1964,1,0,0,0,2047,1970,1,0,0,
        0,2047,1978,1,0,0,0,2047,1985,1,0,0,0,2047,1991,1,0,0,0,2047,1997,
        1,0,0,0,2047,2003,1,0,0,0,2047,2008,1,0,0,0,2047,2016,1,0,0,0,2047,
        2024,1,0,0,0,2047,2033,1,0,0,0,2047,2042,1,0,0,0,2047,2044,1,0,0,
        0,2047,2045,1,0,0,0,2047,2046,1,0,0,0,2048,169,1,0,0,0,2049,2051,
        5,99,0,0,2050,2052,5,277,0,0,2051,2050,1,0,0,0,2051,2052,1,0,0,0,
        2052,2054,1,0,0,0,2053,2055,5,133,0,0,2054,2053,1,0,0,0,2054,2055,
        1,0,0,0,2055,2056,1,0,0,0,2056,2060,5,273,0,0,2057,2058,5,156,0,
        0,2058,2059,5,199,0,0,2059,2061,5,129,0,0,2060,2057,1,0,0,0,2060,
        2061,1,0,0,0,2061,2062,1,0,0,0,2062,2063,3,324,162,0,2063,171,1,
        0,0,0,2064,2065,5,99,0,0,2065,2067,5,207,0,0,2066,2064,1,0,0,0,2066,
        2067,1,0,0,0,2067,2068,1,0,0,0,2068,2069,5,238,0,0,2069,2070,5,273,
        0,0,2070,2071,3,324,162,0,2071,173,1,0,0,0,2072,2073,5,85,0,0,2073,
        2074,5,76,0,0,2074,2078,3,300,150,0,2075,2076,5,265,0,0,2076,2077,
        5,76,0,0,2077,2079,3,304,152,0,2078,2075,1,0,0,0,2078,2079,1,0,0,
        0,2079,2080,1,0,0,0,2080,2081,5,168,0,0,2081,2082,5,334,0,0,2082,
        2083,5,75,0,0,2083,175,1,0,0,0,2084,2085,5,262,0,0,2085,2086,5,76,
        0,0,2086,2087,3,300,150,0,2087,2090,5,203,0,0,2088,2091,3,214,107,
        0,2089,2091,3,216,108,0,2090,2088,1,0,0,0,2090,2089,1,0,0,0,2091,
        2095,1,0,0,0,2092,2093,5,268,0,0,2093,2094,5,68,0,0,2094,2096,5,
        118,0,0,2095,2092,1,0,0,0,2095,2096,1,0,0,0,2096,177,1,0,0,0,2097,
        2098,5,184,0,0,2098,2099,5,330,0,0,2099,179,1,0,0,0,2100,2101,5,
        91,0,0,2101,2102,5,330,0,0,2102,181,1,0,0,0,2103,2105,3,48,24,0,
        2104,2103,1,0,0,0,2104,2105,1,0,0,0,2105,2107,1,0,0,0,2106,2108,
        3,198,99,0,2107,2106,1,0,0,0,2107,2108,1,0,0,0,2108,2109,1,0,0,0,
        2109,2110,3,232,116,0,2110,2111,3,228,114,0,2111,183,1,0,0,0,2112,
        2113,5,165,0,0,2113,2115,5,215,0,0,2114,2116,5,273,0,0,2115,2114,
        1,0,0,0,2115,2116,1,0,0,0,2116,2117,1,0,0,0,2117,2124,3,324,162,
        0,2118,2122,3,188,94,0,2119,2120,5,156,0,0,2120,2121,5,199,0,0,2121,
        2123,5,129,0,0,2122,2119,1,0,0,0,2122,2123,1,0,0,0,2123,2125,1,0,
        0,0,2124,2118,1,0,0,0,2124,2125,1,0,0,0,2125,2168,1,0,0,0,2126,2127,
        5,165,0,0,2127,2129,5,168,0,0,2128,2130,5,273,0,0,2129,2128,1,0,
        0,0,2129,2130,1,0,0,0,2130,2131,1,0,0,0,2131,2133,3,324,162,0,2132,
        2134,3,188,94,0,2133,2132,1,0,0,0,2133,2134,1,0,0,0,2134,2138,1,
        0,0,0,2135,2136,5,156,0,0,2136,2137,5,199,0,0,2137,2139,5,129,0,
        0,2138,2135,1,0,0,0,2138,2139,1,0,0,0,2139,2168,1,0,0,0,2140,2141,
        5,165,0,0,2141,2143,5,215,0,0,2142,2144,5,183,0,0,2143,2142,1,0,
        0,0,2143,2144,1,0,0,0,2144,2145,1,0,0,0,2145,2146,5,119,0,0,2146,
        2148,5,330,0,0,2147,2149,3,320,160,0,2148,2147,1,0,0,0,2148,2149,
        1,0,0,0,2149,2151,1,0,0,0,2150,2152,3,218,109,0,2151,2150,1,0,0,
        0,2151,2152,1,0,0,0,2152,2168,1,0,0,0,2153,2154,5,165,0,0,2154,2156,
        5,215,0,0,2155,2157,5,183,0,0,2156,2155,1,0,0,0,2156,2157,1,0,0,
        0,2157,2158,1,0,0,0,2158,2160,5,119,0,0,2159,2161,5,330,0,0,2160,
        2159,1,0,0,0,2160,2161,1,0,0,0,2161,2162,1,0,0,0,2162,2165,3,202,
        101,0,2163,2164,5,206,0,0,2164,2166,3,206,103,0,2165,2163,1,0,0,
        0,2165,2166,1,0,0,0,2166,2168,1,0,0,0,2167,2112,1,0,0,0,2167,2126,
        1,0,0,0,2167,2140,1,0,0,0,2167,2153,1,0,0,0,2168,185,1,0,0,0,2169,
        2171,3,188,94,0,2170,2172,3,178,89,0,2171,2170,1,0,0,0,2171,2172,
        1,0,0,0,2172,187,1,0,0,0,2173,2174,5,216,0,0,2174,2175,5,5,0,0,2175,
        2180,3,190,95,0,2176,2177,5,2,0,0,2177,2179,3,190,95,0,2178,2176,
        1,0,0,0,2179,2182,1,0,0,0,2180,2178,1,0,0,0,2180,2181,1,0,0,0,2181,
        2183,1,0,0,0,2182,2180,1,0,0,0,2183,2184,5,6,0,0,2184,189,1,0,0,
        0,2185,2188,3,414,207,0,2186,2187,5,310,0,0,2187,2189,3,350,175,
        0,2188,2186,1,0,0,0,2188,2189,1,0,0,0,2189,191,1,0,0,0,2190,2191,
        7,28,0,0,2191,193,1,0,0,0,2192,2198,3,408,204,0,2193,2198,5,330,
        0,0,2194,2198,3,352,176,0,2195,2198,3,356,178,0,2196,2198,3,358,
        179,0,2197,2192,1,0,0,0,2197,2193,1,0,0,0,2197,2194,1,0,0,0,2197,
        2195,1,0,0,0,2197,2196,1,0,0,0,2198,195,1,0,0,0,2199,2204,3,414,
        207,0,2200,2201,5,7,0,0,2201,2203,3,414,207,0,2202,2200,1,0,0,0,
        2203,2206,1,0,0,0,2204,2202,1,0,0,0,2204,2205,1,0,0,0,2205,197,1,
        0,0,0,2206,2204,1,0,0,0,2207,2208,5,308,0,0,2208,2213,3,200,100,
        0,2209,2210,5,2,0,0,2210,2212,3,200,100,0,2211,2209,1,0,0,0,2212,
        2215,1,0,0,0,2213,2211,1,0,0,0,2213,2214,1,0,0,0,2214,199,1,0,0,
        0,2215,2213,1,0,0,0,2216,2218,3,410,205,0,2217,2219,3,300,150,0,
        2218,2217,1,0,0,0,2218,2219,1,0,0,0,2219,2221,1,0,0,0,2220,2222,
        5,68,0,0,2221,2220,1,0,0,0,2221,2222,1,0,0,0,2222,2223,1,0,0,0,2223,
        2224,5,5,0,0,2224,2225,3,182,91,0,2225,2226,5,6,0,0,2226,201,1,0,
        0,0,2227,2228,5,301,0,0,2228,2229,3,324,162,0,2229,203,1,0,0,0,2230,
        2231,5,206,0,0,2231,2241,3,206,103,0,2232,2233,5,217,0,0,2233,2234,
        5,76,0,0,2234,2241,3,334,167,0,2235,2241,3,174,87,0,2236,2241,3,
        178,89,0,2237,2241,3,180,90,0,2238,2239,5,276,0,0,2239,2241,3,206,
        103,0,2240,2230,1,0,0,0,2240,2232,1,0,0,0,2240,2235,1,0,0,0,2240,
        2236,1,0,0,0,2240,2237,1,0,0,0,2240,2238,1,0,0,0,2241,2244,1,0,0,
        0,2242,2240,1,0,0,0,2242,2243,1,0,0,0,2243,205,1,0,0,0,2244,2242,
        1,0,0,0,2245,2246,5,5,0,0,2246,2251,3,208,104,0,2247,2248,5,2,0,
        0,2248,2250,3,208,104,0,2249,2247,1,0,0,0,2250,2253,1,0,0,0,2251,
        2249,1,0,0,0,2251,2252,1,0,0,0,2252,2254,1,0,0,0,2253,2251,1,0,0,
        0,2254,2255,5,6,0,0,2255,207,1,0,0,0,2256,2261,3,210,105,0,2257,
        2259,5,310,0,0,2258,2257,1,0,0,0,2258,2259,1,0,0,0,2259,2260,1,0,
        0,0,2260,2262,3,212,106,0,2261,2258,1,0,0,0,2261,2262,1,0,0,0,2262,
        209,1,0,0,0,2263,2268,3,414,207,0,2264,2265,5,7,0,0,2265,2267,3,
        414,207,0,2266,2264,1,0,0,0,2267,2270,1,0,0,0,2268,2266,1,0,0,0,
        2268,2269,1,0,0,0,2269,2273,1,0,0,0,2270,2268,1,0,0,0,2271,2273,
        5,330,0,0,2272,2263,1,0,0,0,2272,2271,1,0,0,0,2273,211,1,0,0,0,2274,
        2279,5,334,0,0,2275,2279,5,336,0,0,2276,2279,3,360,180,0,2277,2279,
        5,330,0,0,2278,2274,1,0,0,0,2278,2275,1,0,0,0,2278,2276,1,0,0,0,
        2278,2277,1,0,0,0,2279,213,1,0,0,0,2280,2281,5,5,0,0,2281,2286,3,
        350,175,0,2282,2283,5,2,0,0,2283,2285,3,350,175,0,2284,2282,1,0,
        0,0,2285,2288,1,0,0,0,2286,2284,1,0,0,0,2286,2287,1,0,0,0,2287,2289,
        1,0,0,0,2288,2286,1,0,0,0,2289,2290,5,6,0,0,2290,215,1,0,0,0,2291,
        2292,5,5,0,0,2292,2297,3,214,107,0,2293,2294,5,2,0,0,2294,2296,3,
        214,107,0,2295,2293,1,0,0,0,2296,2299,1,0,0,0,2297,2295,1,0,0,0,
        2297,2298,1,0,0,0,2298,2300,1,0,0,0,2299,2297,1,0,0,0,2300,2301,
        5,6,0,0,2301,217,1,0,0,0,2302,2303,5,268,0,0,2303,2304,5,68,0,0,
        2304,2309,3,220,110,0,2305,2306,5,268,0,0,2306,2307,5,76,0,0,2307,
        2309,3,222,111,0,2308,2302,1,0,0,0,2308,2305,1,0,0,0,2309,219,1,
        0,0,0,2310,2311,5,164,0,0,2311,2312,5,330,0,0,2312,2313,5,211,0,
        0,2313,2316,5,330,0,0,2314,2316,3,414,207,0,2315,2310,1,0,0,0,2315,
        2314,1,0,0,0,2316,221,1,0,0,0,2317,2321,5,330,0,0,2318,2319,5,308,
        0,0,2319,2320,5,256,0,0,2320,2322,3,206,103,0,2321,2318,1,0,0,0,
        2321,2322,1,0,0,0,2322,223,1,0,0,0,2323,2324,3,414,207,0,2324,2325,
        5,330,0,0,2325,225,1,0,0,0,2326,2327,3,184,92,0,2327,2328,3,232,
        116,0,2328,2329,3,228,114,0,2329,2378,1,0,0,0,2330,2332,3,272,136,
        0,2331,2333,3,230,115,0,2332,2331,1,0,0,0,2333,2334,1,0,0,0,2334,
        2332,1,0,0,0,2334,2335,1,0,0,0,2335,2378,1,0,0,0,2336,2337,5,113,
        0,0,2337,2338,5,146,0,0,2338,2339,3,324,162,0,2339,2341,3,318,159,
        0,2340,2342,3,264,132,0,2341,2340,1,0,0,0,2341,2342,1,0,0,0,2342,
        2378,1,0,0,0,2343,2344,5,298,0,0,2344,2345,3,324,162,0,2345,2346,
        3,318,159,0,2346,2348,3,250,125,0,2347,2349,3,264,132,0,2348,2347,
        1,0,0,0,2348,2349,1,0,0,0,2349,2378,1,0,0,0,2350,2351,5,191,0,0,
        2351,2352,5,168,0,0,2352,2353,3,324,162,0,2353,2354,3,318,159,0,
        2354,2360,5,301,0,0,2355,2361,3,324,162,0,2356,2357,5,5,0,0,2357,
        2358,3,182,91,0,2358,2359,5,6,0,0,2359,2361,1,0,0,0,2360,2355,1,
        0,0,0,2360,2356,1,0,0,0,2361,2362,1,0,0,0,2362,2363,3,318,159,0,
        2363,2364,5,203,0,0,2364,2368,3,342,171,0,2365,2367,3,252,126,0,
        2366,2365,1,0,0,0,2367,2370,1,0,0,0,2368,2366,1,0,0,0,2368,2369,
        1,0,0,0,2369,2374,1,0,0,0,2370,2368,1,0,0,0,2371,2373,3,254,127,
        0,2372,2371,1,0,0,0,2373,2376,1,0,0,0,2374,2372,1,0,0,0,2374,2375,
        1,0,0,0,2375,2378,1,0,0,0,2376,2374,1,0,0,0,2377,2326,1,0,0,0,2377,
        2330,1,0,0,0,2377,2336,1,0,0,0,2377,2343,1,0,0,0,2377,2350,1,0,0,
        0,2378,227,1,0,0,0,2379,2380,5,208,0,0,2380,2381,5,76,0,0,2381,2386,
        3,236,118,0,2382,2383,5,2,0,0,2383,2385,3,236,118,0,2384,2382,1,
        0,0,0,2385,2388,1,0,0,0,2386,2384,1,0,0,0,2386,2387,1,0,0,0,2387,
        2390,1,0,0,0,2388,2386,1,0,0,0,2389,2379,1,0,0,0,2389,2390,1,0,0,
        0,2390,2401,1,0,0,0,2391,2392,5,84,0,0,2392,2393,5,76,0,0,2393,2398,
        3,340,170,0,2394,2395,5,2,0,0,2395,2397,3,340,170,0,2396,2394,1,
        0,0,0,2397,2400,1,0,0,0,2398,2396,1,0,0,0,2398,2399,1,0,0,0,2399,
        2402,1,0,0,0,2400,2398,1,0,0,0,2401,2391,1,0,0,0,2401,2402,1,0,0,
        0,2402,2413,1,0,0,0,2403,2404,5,121,0,0,2404,2405,5,76,0,0,2405,
        2410,3,340,170,0,2406,2407,5,2,0,0,2407,2409,3,340,170,0,2408,2406,
        1,0,0,0,2409,2412,1,0,0,0,2410,2408,1,0,0,0,2410,2411,1,0,0,0,2411,
        2414,1,0,0,0,2412,2410,1,0,0,0,2413,2403,1,0,0,0,2413,2414,1,0,0,
        0,2414,2425,1,0,0,0,2415,2416,5,264,0,0,2416,2417,5,76,0,0,2417,
        2422,3,236,118,0,2418,2419,5,2,0,0,2419,2421,3,236,118,0,2420,2418,
        1,0,0,0,2421,2424,1,0,0,0,2422,2420,1,0,0,0,2422,2423,1,0,0,0,2423,
        2426,1,0,0,0,2424,2422,1,0,0,0,2425,2415,1,0,0,0,2425,2426,1,0,0,
        0,2426,2428,1,0,0,0,2427,2429,3,394,197,0,2428,2427,1,0,0,0,2428,
        2429,1,0,0,0,2429,2435,1,0,0,0,2430,2433,5,179,0,0,2431,2434,5,60,
        0,0,2432,2434,3,340,170,0,2433,2431,1,0,0,0,2433,2432,1,0,0,0,2434,
        2436,1,0,0,0,2435,2430,1,0,0,0,2435,2436,1,0,0,0,2436,229,1,0,0,
        0,2437,2438,3,184,92,0,2438,2439,3,240,120,0,2439,231,1,0,0,0,2440,
        2441,6,116,-1,0,2441,2444,3,234,117,0,2442,2444,3,8,4,0,2443,2440,
        1,0,0,0,2443,2442,1,0,0,0,2444,2465,1,0,0,0,2445,2446,10,3,0,0,2446,
        2448,7,29,0,0,2447,2449,3,286,143,0,2448,2447,1,0,0,0,2448,2449,
        1,0,0,0,2449,2450,1,0,0,0,2450,2464,3,232,116,4,2451,2452,10,2,0,
        0,2452,2454,5,166,0,0,2453,2455,3,286,143,0,2454,2453,1,0,0,0,2454,
        2455,1,0,0,0,2455,2456,1,0,0,0,2456,2464,3,232,116,3,2457,2458,10,
        1,0,0,2458,2460,7,30,0,0,2459,2461,3,286,143,0,2460,2459,1,0,0,0,
        2460,2461,1,0,0,0,2461,2462,1,0,0,0,2462,2464,3,232,116,2,2463,2445,
        1,0,0,0,2463,2451,1,0,0,0,2463,2457,1,0,0,0,2464,2467,1,0,0,0,2465,
        2463,1,0,0,0,2465,2466,1,0,0,0,2466,233,1,0,0,0,2467,2465,1,0,0,
        0,2468,2474,3,242,121,0,2469,2474,3,238,119,0,2470,2471,5,273,0,
        0,2471,2474,3,324,162,0,2472,2474,3,314,157,0,2473,2468,1,0,0,0,
        2473,2469,1,0,0,0,2473,2470,1,0,0,0,2473,2472,1,0,0,0,2474,235,1,
        0,0,0,2475,2477,3,340,170,0,2476,2478,7,12,0,0,2477,2476,1,0,0,0,
        2477,2478,1,0,0,0,2478,2481,1,0,0,0,2479,2480,5,201,0,0,2480,2482,
        7,3,0,0,2481,2479,1,0,0,0,2481,2482,1,0,0,0,2482,237,1,0,0,0,2483,
        2485,3,272,136,0,2484,2486,3,240,120,0,2485,2484,1,0,0,0,2486,2487,
        1,0,0,0,2487,2485,1,0,0,0,2487,2488,1,0,0,0,2488,239,1,0,0,0,2489,
        2491,3,246,123,0,2490,2492,3,264,132,0,2491,2490,1,0,0,0,2491,2492,
        1,0,0,0,2492,2493,1,0,0,0,2493,2494,3,228,114,0,2494,2517,1,0,0,
        0,2495,2499,3,248,124,0,2496,2498,3,284,142,0,2497,2496,1,0,0,0,
        2498,2501,1,0,0,0,2499,2497,1,0,0,0,2499,2500,1,0,0,0,2500,2503,
        1,0,0,0,2501,2499,1,0,0,0,2502,2504,3,264,132,0,2503,2502,1,0,0,
        0,2503,2504,1,0,0,0,2504,2506,1,0,0,0,2505,2507,3,274,137,0,2506,
        2505,1,0,0,0,2506,2507,1,0,0,0,2507,2509,1,0,0,0,2508,2510,3,266,
        133,0,2509,2508,1,0,0,0,2509,2510,1,0,0,0,2510,2512,1,0,0,0,2511,
        2513,3,394,197,0,2512,2511,1,0,0,0,2512,2513,1,0,0,0,2513,2514,1,
        0,0,0,2514,2515,3,228,114,0,2515,2517,1,0,0,0,2516,2489,1,0,0,0,
        2516,2495,1,0,0,0,2517,241,1,0,0,0,2518,2519,3,246,123,0,2519,2521,
        3,244,122,0,2520,2522,3,264,132,0,2521,2520,1,0,0,0,2521,2522,1,
        0,0,0,2522,2544,1,0,0,0,2523,2524,3,248,124,0,2524,2528,3,244,122,
        0,2525,2527,3,284,142,0,2526,2525,1,0,0,0,2527,2530,1,0,0,0,2528,
        2526,1,0,0,0,2528,2529,1,0,0,0,2529,2532,1,0,0,0,2530,2528,1,0,0,
        0,2531,2533,3,264,132,0,2532,2531,1,0,0,0,2532,2533,1,0,0,0,2533,
        2535,1,0,0,0,2534,2536,3,274,137,0,2535,2534,1,0,0,0,2535,2536,1,
        0,0,0,2536,2538,1,0,0,0,2537,2539,3,266,133,0,2538,2537,1,0,0,0,
        2538,2539,1,0,0,0,2539,2541,1,0,0,0,2540,2542,3,394,197,0,2541,2540,
        1,0,0,0,2541,2542,1,0,0,0,2542,2544,1,0,0,0,2543,2518,1,0,0,0,2543,
        2523,1,0,0,0,2544,243,1,0,0,0,2545,2547,3,272,136,0,2546,2545,1,
        0,0,0,2546,2547,1,0,0,0,2547,245,1,0,0,0,2548,2549,5,252,0,0,2549,
        2550,5,285,0,0,2550,2551,5,5,0,0,2551,2552,3,332,166,0,2552,2553,
        5,6,0,0,2553,2559,1,0,0,0,2554,2555,5,189,0,0,2555,2559,3,332,166,
        0,2556,2557,5,233,0,0,2557,2559,3,332,166,0,2558,2548,1,0,0,0,2558,
        2554,1,0,0,0,2558,2556,1,0,0,0,2559,2561,1,0,0,0,2560,2562,3,320,
        160,0,2561,2560,1,0,0,0,2561,2562,1,0,0,0,2562,2565,1,0,0,0,2563,
        2564,5,231,0,0,2564,2566,5,330,0,0,2565,2563,1,0,0,0,2565,2566,1,
        0,0,0,2566,2567,1,0,0,0,2567,2568,5,301,0,0,2568,2581,5,330,0,0,
        2569,2579,5,68,0,0,2570,2580,3,302,151,0,2571,2580,3,384,192,0,2572,
        2575,5,5,0,0,2573,2576,3,302,151,0,2574,2576,3,384,192,0,2575,2573,
        1,0,0,0,2575,2574,1,0,0,0,2576,2577,1,0,0,0,2577,2578,5,6,0,0,2578,
        2580,1,0,0,0,2579,2570,1,0,0,0,2579,2571,1,0,0,0,2579,2572,1,0,0,
        0,2580,2582,1,0,0,0,2581,2569,1,0,0,0,2581,2582,1,0,0,0,2582,2584,
        1,0,0,0,2583,2585,3,320,160,0,2584,2583,1,0,0,0,2584,2585,1,0,0,
        0,2585,2588,1,0,0,0,2586,2587,5,230,0,0,2587,2589,5,330,0,0,2588,
        2586,1,0,0,0,2588,2589,1,0,0,0,2589,247,1,0,0,0,2590,2594,5,252,
        0,0,2591,2593,3,268,134,0,2592,2591,1,0,0,0,2593,2596,1,0,0,0,2594,
        2592,1,0,0,0,2594,2595,1,0,0,0,2595,2598,1,0,0,0,2596,2594,1,0,0,
        0,2597,2599,3,286,143,0,2598,2597,1,0,0,0,2598,2599,1,0,0,0,2599,
        2600,1,0,0,0,2600,2601,3,332,166,0,2601,249,1,0,0,0,2602,2603,5,
        258,0,0,2603,2604,3,260,130,0,2604,251,1,0,0,0,2605,2606,5,305,0,
        0,2606,2609,5,190,0,0,2607,2608,5,63,0,0,2608,2610,3,342,171,0,2609,
        2607,1,0,0,0,2609,2610,1,0,0,0,2610,2611,1,0,0,0,2611,2612,5,279,
        0,0,2612,2613,3,256,128,0,2613,253,1,0,0,0,2614,2615,5,305,0,0,2615,
        2616,5,199,0,0,2616,2619,5,190,0,0,2617,2618,5,63,0,0,2618,2620,
        3,342,171,0,2619,2617,1,0,0,0,2619,2620,1,0,0,0,2620,2621,1,0,0,
        0,2621,2622,5,279,0,0,2622,2623,3,258,129,0,2623,255,1,0,0,0,2624,
        2632,5,113,0,0,2625,2626,5,298,0,0,2626,2627,5,258,0,0,2627,2632,
        5,321,0,0,2628,2629,5,298,0,0,2629,2630,5,258,0,0,2630,2632,3,260,
        130,0,2631,2624,1,0,0,0,2631,2625,1,0,0,0,2631,2628,1,0,0,0,2632,
        257,1,0,0,0,2633,2634,5,165,0,0,2634,2652,5,321,0,0,2635,2636,5,
        165,0,0,2636,2637,5,5,0,0,2637,2638,3,322,161,0,2638,2639,5,6,0,
        0,2639,2640,5,302,0,0,2640,2641,5,5,0,0,2641,2646,3,340,170,0,2642,
        2643,5,2,0,0,2643,2645,3,340,170,0,2644,2642,1,0,0,0,2645,2648,1,
        0,0,0,2646,2644,1,0,0,0,2646,2647,1,0,0,0,2647,2649,1,0,0,0,2648,
        2646,1,0,0,0,2649,2650,5,6,0,0,2650,2652,1,0,0,0,2651,2633,1,0,0,
        0,2651,2635,1,0,0,0,2652,259,1,0,0,0,2653,2658,3,262,131,0,2654,
        2655,5,2,0,0,2655,2657,3,262,131,0,2656,2654,1,0,0,0,2657,2660,1,
        0,0,0,2658,2656,1,0,0,0,2658,2659,1,0,0,0,2659,261,1,0,0,0,2660,
        2658,1,0,0,0,2661,2662,3,324,162,0,2662,2663,5,310,0,0,2663,2664,
        3,340,170,0,2664,263,1,0,0,0,2665,2666,5,306,0,0,2666,2667,3,342,
        171,0,2667,265,1,0,0,0,2668,2669,5,154,0,0,2669,2670,3,342,171,0,
        2670,267,1,0,0,0,2671,2672,5,14,0,0,2672,2679,3,270,135,0,2673,2675,
        5,2,0,0,2674,2673,1,0,0,0,2674,2675,1,0,0,0,2675,2676,1,0,0,0,2676,
        2678,3,270,135,0,2677,2674,1,0,0,0,2678,2681,1,0,0,0,2679,2677,1,
        0,0,0,2679,2680,1,0,0,0,2680,2682,1,0,0,0,2681,2679,1,0,0,0,2682,
        2683,5,15,0,0,2683,269,1,0,0,0,2684,2698,3,414,207,0,2685,2686,3,
        414,207,0,2686,2687,5,5,0,0,2687,2692,3,348,174,0,2688,2689,5,2,
        0,0,2689,2691,3,348,174,0,2690,2688,1,0,0,0,2691,2694,1,0,0,0,2692,
        2690,1,0,0,0,2692,2693,1,0,0,0,2693,2695,1,0,0,0,2694,2692,1,0,0,
        0,2695,2696,5,6,0,0,2696,2698,1,0,0,0,2697,2684,1,0,0,0,2697,2685,
        1,0,0,0,2698,271,1,0,0,0,2699,2700,5,146,0,0,2700,2705,3,288,144,
        0,2701,2702,5,2,0,0,2702,2704,3,288,144,0,2703,2701,1,0,0,0,2704,
        2707,1,0,0,0,2705,2703,1,0,0,0,2705,2706,1,0,0,0,2706,2711,1,0,0,
        0,2707,2705,1,0,0,0,2708,2710,3,284,142,0,2709,2708,1,0,0,0,2710,
        2713,1,0,0,0,2711,2709,1,0,0,0,2711,2712,1,0,0,0,2712,2715,1,0,0,
        0,2713,2711,1,0,0,0,2714,2716,3,278,139,0,2715,2714,1,0,0,0,2715,
        2716,1,0,0,0,2716,273,1,0,0,0,2717,2718,5,152,0,0,2718,2719,5,76,
        0,0,2719,2724,3,340,170,0,2720,2721,5,2,0,0,2721,2723,3,340,170,
        0,2722,2720,1,0,0,0,2723,2726,1,0,0,0,2724,2722,1,0,0,0,2724,2725,
        1,0,0,0,2725,2744,1,0,0,0,2726,2724,1,0,0,0,2727,2728,5,308,0,0,
        2728,2745,5,247,0,0,2729,2730,5,308,0,0,2730,2745,5,101,0,0,2731,
        2732,5,153,0,0,2732,2733,5,260,0,0,2733,2734,5,5,0,0,2734,2739,3,
        276,138,0,2735,2736,5,2,0,0,2736,2738,3,276,138,0,2737,2735,1,0,
        0,0,2738,2741,1,0,0,0,2739,2737,1,0,0,0,2739,2740,1,0,0,0,2740,2742,
        1,0,0,0,2741,2739,1,0,0,0,2742,2743,5,6,0,0,2743,2745,1,0,0,0,2744,
        2727,1,0,0,0,2744,2729,1,0,0,0,2744,2731,1,0,0,0,2744,2745,1,0,0,
        0,2745,2762,1,0,0,0,2746,2747,5,152,0,0,2747,2748,5,76,0,0,2748,
        2749,5,153,0,0,2749,2750,5,260,0,0,2750,2751,5,5,0,0,2751,2756,3,
        276,138,0,2752,2753,5,2,0,0,2753,2755,3,276,138,0,2754,2752,1,0,
        0,0,2755,2758,1,0,0,0,2756,2754,1,0,0,0,2756,2757,1,0,0,0,2757,2759,
        1,0,0,0,2758,2756,1,0,0,0,2759,2760,5,6,0,0,2760,2762,1,0,0,0,2761,
        2717,1,0,0,0,2761,2746,1,0,0,0,2762,275,1,0,0,0,2763,2772,5,5,0,
        0,2764,2769,3,340,170,0,2765,2766,5,2,0,0,2766,2768,3,340,170,0,
        2767,2765,1,0,0,0,2768,2771,1,0,0,0,2769,2767,1,0,0,0,2769,2770,
        1,0,0,0,2770,2773,1,0,0,0,2771,2769,1,0,0,0,2772,2764,1,0,0,0,2772,
        2773,1,0,0,0,2773,2774,1,0,0,0,2774,2777,5,6,0,0,2775,2777,3,340,
        170,0,2776,2763,1,0,0,0,2776,2775,1,0,0,0,2777,277,1,0,0,0,2778,
        2779,5,220,0,0,2779,2780,5,5,0,0,2780,2781,3,332,166,0,2781,2782,
        5,142,0,0,2782,2783,3,280,140,0,2783,2784,5,159,0,0,2784,2785,5,
        5,0,0,2785,2790,3,282,141,0,2786,2787,5,2,0,0,2787,2789,3,282,141,
        0,2788,2786,1,0,0,0,2789,2792,1,0,0,0,2790,2788,1,0,0,0,2790,2791,
        1,0,0,0,2791,2793,1,0,0,0,2792,2790,1,0,0,0,2793,2794,5,6,0,0,2794,
        2795,5,6,0,0,2795,279,1,0,0,0,2796,2809,3,414,207,0,2797,2798,5,
        5,0,0,2798,2803,3,414,207,0,2799,2800,5,2,0,0,2800,2802,3,414,207,
        0,2801,2799,1,0,0,0,2802,2805,1,0,0,0,2803,2801,1,0,0,0,2803,2804,
        1,0,0,0,2804,2806,1,0,0,0,2805,2803,1,0,0,0,2806,2807,5,6,0,0,2807,
        2809,1,0,0,0,2808,2796,1,0,0,0,2808,2797,1,0,0,0,2809,281,1,0,0,
        0,2810,2815,3,340,170,0,2811,2813,5,68,0,0,2812,2811,1,0,0,0,2812,
        2813,1,0,0,0,2813,2814,1,0,0,0,2814,2816,3,414,207,0,2815,2812,1,
        0,0,0,2815,2816,1,0,0,0,2816,283,1,0,0,0,2817,2818,5,174,0,0,2818,
        2820,5,303,0,0,2819,2821,5,210,0,0,2820,2819,1,0,0,0,2820,2821,1,
        0,0,0,2821,2822,1,0,0,0,2822,2823,3,408,204,0,2823,2832,5,5,0,0,
        2824,2829,3,340,170,0,2825,2826,5,2,0,0,2826,2828,3,340,170,0,2827,
        2825,1,0,0,0,2828,2831,1,0,0,0,2829,2827,1,0,0,0,2829,2830,1,0,0,
        0,2830,2833,1,0,0,0,2831,2829,1,0,0,0,2832,2824,1,0,0,0,2832,2833,
        1,0,0,0,2833,2834,1,0,0,0,2834,2835,5,6,0,0,2835,2847,3,414,207,
        0,2836,2838,5,68,0,0,2837,2836,1,0,0,0,2837,2838,1,0,0,0,2838,2839,
        1,0,0,0,2839,2844,3,414,207,0,2840,2841,5,2,0,0,2841,2843,3,414,
        207,0,2842,2840,1,0,0,0,2843,2846,1,0,0,0,2844,2842,1,0,0,0,2844,
        2845,1,0,0,0,2845,2848,1,0,0,0,2846,2844,1,0,0,0,2847,2837,1,0,0,
        0,2847,2848,1,0,0,0,2848,285,1,0,0,0,2849,2850,7,31,0,0,2850,287,
        1,0,0,0,2851,2855,3,312,156,0,2852,2854,3,290,145,0,2853,2852,1,
        0,0,0,2854,2857,1,0,0,0,2855,2853,1,0,0,0,2855,2856,1,0,0,0,2856,
        289,1,0,0,0,2857,2855,1,0,0,0,2858,2859,3,292,146,0,2859,2860,5,
        171,0,0,2860,2862,3,312,156,0,2861,2863,3,294,147,0,2862,2861,1,
        0,0,0,2862,2863,1,0,0,0,2863,2870,1,0,0,0,2864,2865,5,197,0,0,2865,
        2866,3,292,146,0,2866,2867,5,171,0,0,2867,2868,3,312,156,0,2868,
        2870,1,0,0,0,2869,2858,1,0,0,0,2869,2864,1,0,0,0,2870,291,1,0,0,
        0,2871,2873,5,162,0,0,2872,2871,1,0,0,0,2872,2873,1,0,0,0,2873,2896,
        1,0,0,0,2874,2896,5,100,0,0,2875,2877,5,177,0,0,2876,2878,5,210,
        0,0,2877,2876,1,0,0,0,2877,2878,1,0,0,0,2878,2896,1,0,0,0,2879,2881,
        5,177,0,0,2880,2879,1,0,0,0,2880,2881,1,0,0,0,2881,2882,1,0,0,0,
        2882,2896,5,253,0,0,2883,2885,5,242,0,0,2884,2886,5,210,0,0,2885,
        2884,1,0,0,0,2885,2886,1,0,0,0,2886,2896,1,0,0,0,2887,2889,5,147,
        0,0,2888,2890,5,210,0,0,2889,2888,1,0,0,0,2889,2890,1,0,0,0,2890,
        2896,1,0,0,0,2891,2893,5,177,0,0,2892,2891,1,0,0,0,2892,2893,1,0,
        0,0,2893,2894,1,0,0,0,2894,2896,5,64,0,0,2895,2872,1,0,0,0,2895,
        2874,1,0,0,0,2895,2875,1,0,0,0,2895,2880,1,0,0,0,2895,2883,1,0,0,
        0,2895,2887,1,0,0,0,2895,2892,1,0,0,0,2896,293,1,0,0,0,2897,2898,
        5,203,0,0,2898,2902,3,342,171,0,2899,2900,5,301,0,0,2900,2902,3,
        300,150,0,2901,2897,1,0,0,0,2901,2899,1,0,0,0,2902,295,1,0,0,0,2903,
        2905,5,275,0,0,2904,2906,7,32,0,0,2905,2904,1,0,0,0,2905,2906,1,
        0,0,0,2906,2907,1,0,0,0,2907,2909,5,5,0,0,2908,2910,3,298,149,0,
        2909,2908,1,0,0,0,2909,2910,1,0,0,0,2910,2911,1,0,0,0,2911,2912,
        5,6,0,0,2912,297,1,0,0,0,2913,2915,5,320,0,0,2914,2913,1,0,0,0,2914,
        2915,1,0,0,0,2915,2916,1,0,0,0,2916,2917,7,8,0,0,2917,2938,7,9,0,
        0,2918,2919,3,340,170,0,2919,2920,5,249,0,0,2920,2938,1,0,0,0,2921,
        2922,5,74,0,0,2922,2923,5,334,0,0,2923,2924,5,209,0,0,2924,2925,
        5,202,0,0,2925,2934,5,334,0,0,2926,2932,5,203,0,0,2927,2933,3,414,
        207,0,2928,2929,3,408,204,0,2929,2930,5,5,0,0,2930,2931,5,6,0,0,
        2931,2933,1,0,0,0,2932,2927,1,0,0,0,2932,2928,1,0,0,0,2933,2935,
        1,0,0,0,2934,2926,1,0,0,0,2934,2935,1,0,0,0,2935,2938,1,0,0,0,2936,
        2938,3,340,170,0,2937,2914,1,0,0,0,2937,2918,1,0,0,0,2937,2921,1,
        0,0,0,2937,2936,1,0,0,0,2938,299,1,0,0,0,2939,2940,5,5,0,0,2940,
        2941,3,302,151,0,2941,2942,5,6,0,0,2942,301,1,0,0,0,2943,2948,3,
        410,205,0,2944,2945,5,2,0,0,2945,2947,3,410,205,0,2946,2944,1,0,
        0,0,2947,2950,1,0,0,0,2948,2946,1,0,0,0,2948,2949,1,0,0,0,2949,303,
        1,0,0,0,2950,2948,1,0,0,0,2951,2952,5,5,0,0,2952,2957,3,306,153,
        0,2953,2954,5,2,0,0,2954,2956,3,306,153,0,2955,2953,1,0,0,0,2956,
        2959,1,0,0,0,2957,2955,1,0,0,0,2957,2958,1,0,0,0,2958,2960,1,0,0,
        0,2959,2957,1,0,0,0,2960,2961,5,6,0,0,2961,305,1,0,0,0,2962,2964,
        3,410,205,0,2963,2965,7,12,0,0,2964,2963,1,0,0,0,2964,2965,1,0,0,
        0,2965,307,1,0,0,0,2966,2967,5,5,0,0,2967,2972,3,310,155,0,2968,
        2969,5,2,0,0,2969,2971,3,310,155,0,2970,2968,1,0,0,0,2971,2974,1,
        0,0,0,2972,2970,1,0,0,0,2972,2973,1,0,0,0,2973,2975,1,0,0,0,2974,
        2972,1,0,0,0,2975,2976,5,6,0,0,2976,309,1,0,0,0,2977,2979,3,414,
        207,0,2978,2980,3,180,90,0,2979,2978,1,0,0,0,2979,2980,1,0,0,0,2980,
        311,1,0,0,0,2981,2983,3,324,162,0,2982,2984,3,76,38,0,2983,2982,
        1,0,0,0,2983,2984,1,0,0,0,2984,2986,1,0,0,0,2985,2987,3,296,148,
        0,2986,2985,1,0,0,0,2986,2987,1,0,0,0,2987,2988,1,0,0,0,2988,2989,
        3,318,159,0,2989,3009,1,0,0,0,2990,2991,5,5,0,0,2991,2992,3,182,
        91,0,2992,2994,5,6,0,0,2993,2995,3,296,148,0,2994,2993,1,0,0,0,2994,
        2995,1,0,0,0,2995,2996,1,0,0,0,2996,2997,3,318,159,0,2997,3009,1,
        0,0,0,2998,2999,5,5,0,0,2999,3000,3,288,144,0,3000,3002,5,6,0,0,
        3001,3003,3,296,148,0,3002,3001,1,0,0,0,3002,3003,1,0,0,0,3003,3004,
        1,0,0,0,3004,3005,3,318,159,0,3005,3009,1,0,0,0,3006,3009,3,314,
        157,0,3007,3009,3,316,158,0,3008,2981,1,0,0,0,3008,2990,1,0,0,0,
        3008,2998,1,0,0,0,3008,3006,1,0,0,0,3008,3007,1,0,0,0,3009,313,1,
        0,0,0,3010,3011,5,302,0,0,3011,3016,3,340,170,0,3012,3013,5,2,0,
        0,3013,3015,3,340,170,0,3014,3012,1,0,0,0,3015,3018,1,0,0,0,3016,
        3014,1,0,0,0,3016,3017,1,0,0,0,3017,3019,1,0,0,0,3018,3016,1,0,0,
        0,3019,3020,3,318,159,0,3020,315,1,0,0,0,3021,3022,3,410,205,0,3022,
        3031,5,5,0,0,3023,3028,3,340,170,0,3024,3025,5,2,0,0,3025,3027,3,
        340,170,0,3026,3024,1,0,0,0,3027,3030,1,0,0,0,3028,3026,1,0,0,0,
        3028,3029,1,0,0,0,3029,3032,1,0,0,0,3030,3028,1,0,0,0,3031,3023,
        1,0,0,0,3031,3032,1,0,0,0,3032,3033,1,0,0,0,3033,3034,5,6,0,0,3034,
        3035,3,318,159,0,3035,317,1,0,0,0,3036,3038,5,68,0,0,3037,3036,1,
        0,0,0,3037,3038,1,0,0,0,3038,3039,1,0,0,0,3039,3041,3,416,208,0,
        3040,3042,3,300,150,0,3041,3040,1,0,0,0,3041,3042,1,0,0,0,3042,3044,
        1,0,0,0,3043,3037,1,0,0,0,3043,3044,1,0,0,0,3044,319,1,0,0,0,3045,
        3046,5,248,0,0,3046,3047,5,144,0,0,3047,3048,5,255,0,0,3048,3052,
        5,330,0,0,3049,3050,5,308,0,0,3050,3051,5,256,0,0,3051,3053,3,206,
        103,0,3052,3049,1,0,0,0,3052,3053,1,0,0,0,3053,3095,1,0,0,0,3054,
        3055,5,248,0,0,3055,3056,5,144,0,0,3056,3066,5,114,0,0,3057,3058,
        5,137,0,0,3058,3059,5,278,0,0,3059,3060,5,76,0,0,3060,3064,5,330,
        0,0,3061,3062,5,126,0,0,3062,3063,5,76,0,0,3063,3065,5,330,0,0,3064,
        3061,1,0,0,0,3064,3065,1,0,0,0,3065,3067,1,0,0,0,3066,3057,1,0,0,
        0,3066,3067,1,0,0,0,3067,3073,1,0,0,0,3068,3069,5,88,0,0,3069,3070,
        5,170,0,0,3070,3071,5,278,0,0,3071,3072,5,76,0,0,3072,3074,5,330,
        0,0,3073,3068,1,0,0,0,3073,3074,1,0,0,0,3074,3080,1,0,0,0,3075,3076,
        5,189,0,0,3076,3077,5,172,0,0,3077,3078,5,278,0,0,3078,3079,5,76,
        0,0,3079,3081,5,330,0,0,3080,3075,1,0,0,0,3080,3081,1,0,0,0,3081,
        3086,1,0,0,0,3082,3083,5,180,0,0,3083,3084,5,278,0,0,3084,3085,5,
        76,0,0,3085,3087,5,330,0,0,3086,3082,1,0,0,0,3086,3087,1,0,0,0,3087,
        3092,1,0,0,0,3088,3089,5,200,0,0,3089,3090,5,112,0,0,3090,3091,5,
        68,0,0,3091,3093,5,330,0,0,3092,3088,1,0,0,0,3092,3093,1,0,0,0,3093,
        3095,1,0,0,0,3094,3045,1,0,0,0,3094,3054,1,0,0,0,3095,321,1,0,0,
        0,3096,3101,3,324,162,0,3097,3098,5,2,0,0,3098,3100,3,324,162,0,
        3099,3097,1,0,0,0,3100,3103,1,0,0,0,3101,3099,1,0,0,0,3101,3102,
        1,0,0,0,3102,323,1,0,0,0,3103,3101,1,0,0,0,3104,3109,3,410,205,0,
        3105,3106,5,7,0,0,3106,3108,3,410,205,0,3107,3105,1,0,0,0,3108,3111,
        1,0,0,0,3109,3107,1,0,0,0,3109,3110,1,0,0,0,3110,325,1,0,0,0,3111,
        3109,1,0,0,0,3112,3113,3,410,205,0,3113,3114,5,7,0,0,3114,3116,1,
        0,0,0,3115,3112,1,0,0,0,3115,3116,1,0,0,0,3116,3117,1,0,0,0,3117,
        3118,3,410,205,0,3118,327,1,0,0,0,3119,3120,3,410,205,0,3120,3121,
        5,7,0,0,3121,3123,1,0,0,0,3122,3119,1,0,0,0,3122,3123,1,0,0,0,3123,
        3124,1,0,0,0,3124,3125,3,410,205,0,3125,329,1,0,0,0,3126,3134,3,
        340,170,0,3127,3129,5,68,0,0,3128,3127,1,0,0,0,3128,3129,1,0,0,0,
        3129,3132,1,0,0,0,3130,3133,3,410,205,0,3131,3133,3,300,150,0,3132,
        3130,1,0,0,0,3132,3131,1,0,0,0,3133,3135,1,0,0,0,3134,3128,1,0,0,
        0,3134,3135,1,0,0,0,3135,331,1,0,0,0,3136,3141,3,330,165,0,3137,
        3138,5,2,0,0,3138,3140,3,330,165,0,3139,3137,1,0,0,0,3140,3143,1,
        0,0,0,3141,3139,1,0,0,0,3141,3142,1,0,0,0,3142,333,1,0,0,0,3143,
        3141,1,0,0,0,3144,3145,5,5,0,0,3145,3150,3,336,168,0,3146,3147,5,
        2,0,0,3147,3149,3,336,168,0,3148,3146,1,0,0,0,3149,3152,1,0,0,0,
        3150,3148,1,0,0,0,3150,3151,1,0,0,0,3151,3153,1,0,0,0,3152,3150,
        1,0,0,0,3153,3154,5,6,0,0,3154,335,1,0,0,0,3155,3169,3,408,204,0,
        3156,3157,3,414,207,0,3157,3158,5,5,0,0,3158,3163,3,338,169,0,3159,
        3160,5,2,0,0,3160,3162,3,338,169,0,3161,3159,1,0,0,0,3162,3165,1,
        0,0,0,3163,3161,1,0,0,0,3163,3164,1,0,0,0,3164,3166,1,0,0,0,3165,
        3163,1,0,0,0,3166,3167,5,6,0,0,3167,3169,1,0,0,0,3168,3155,1,0,0,
        0,3168,3156,1,0,0,0,3169,337,1,0,0,0,3170,3173,3,408,204,0,3171,
        3173,3,350,175,0,3172,3170,1,0,0,0,3172,3171,1,0,0,0,3173,339,1,
        0,0,0,3174,3175,3,342,171,0,3175,341,1,0,0,0,3176,3177,6,171,-1,
        0,3177,3178,5,199,0,0,3178,3189,3,342,171,5,3179,3180,5,129,0,0,
        3180,3181,5,5,0,0,3181,3182,3,182,91,0,3182,3183,5,6,0,0,3183,3189,
        1,0,0,0,3184,3186,3,346,173,0,3185,3187,3,344,172,0,3186,3185,1,
        0,0,0,3186,3187,1,0,0,0,3187,3189,1,0,0,0,3188,3176,1,0,0,0,3188,
        3179,1,0,0,0,3188,3184,1,0,0,0,3189,3198,1,0,0,0,3190,3191,10,2,
        0,0,3191,3192,5,63,0,0,3192,3197,3,342,171,3,3193,3194,10,1,0,0,
        3194,3195,5,207,0,0,3195,3197,3,342,171,2,3196,3190,1,0,0,0,3196,
        3193,1,0,0,0,3197,3200,1,0,0,0,3198,3196,1,0,0,0,3198,3199,1,0,0,
        0,3199,343,1,0,0,0,3200,3198,1,0,0,0,3201,3203,5,199,0,0,3202,3201,
        1,0,0,0,3202,3203,1,0,0,0,3203,3204,1,0,0,0,3204,3205,5,72,0,0,3205,
        3206,3,346,173,0,3206,3207,5,63,0,0,3207,3208,3,346,173,0,3208,3284,
        1,0,0,0,3209,3211,5,199,0,0,3210,3209,1,0,0,0,3210,3211,1,0,0,0,
        3211,3212,1,0,0,0,3212,3213,5,159,0,0,3213,3214,5,5,0,0,3214,3219,
        3,340,170,0,3215,3216,5,2,0,0,3216,3218,3,340,170,0,3217,3215,1,
        0,0,0,3218,3221,1,0,0,0,3219,3217,1,0,0,0,3219,3220,1,0,0,0,3220,
        3222,1,0,0,0,3221,3219,1,0,0,0,3222,3223,5,6,0,0,3223,3284,1,0,0,
        0,3224,3226,5,199,0,0,3225,3224,1,0,0,0,3225,3226,1,0,0,0,3226,3227,
        1,0,0,0,3227,3228,5,159,0,0,3228,3229,5,5,0,0,3229,3230,3,182,91,
        0,3230,3231,5,6,0,0,3231,3284,1,0,0,0,3232,3234,5,199,0,0,3233,3232,
        1,0,0,0,3233,3234,1,0,0,0,3234,3235,1,0,0,0,3235,3236,5,243,0,0,
        3236,3284,3,346,173,0,3237,3239,5,199,0,0,3238,3237,1,0,0,0,3238,
        3239,1,0,0,0,3239,3240,1,0,0,0,3240,3241,5,178,0,0,3241,3255,7,33,
        0,0,3242,3243,5,5,0,0,3243,3256,5,6,0,0,3244,3245,5,5,0,0,3245,3250,
        3,340,170,0,3246,3247,5,2,0,0,3247,3249,3,340,170,0,3248,3246,1,
        0,0,0,3249,3252,1,0,0,0,3250,3248,1,0,0,0,3250,3251,1,0,0,0,3251,
        3253,1,0,0,0,3252,3250,1,0,0,0,3253,3254,5,6,0,0,3254,3256,1,0,0,
        0,3255,3242,1,0,0,0,3255,3244,1,0,0,0,3256,3284,1,0,0,0,3257,3259,
        5,199,0,0,3258,3257,1,0,0,0,3258,3259,1,0,0,0,3259,3260,1,0,0,0,
        3260,3261,5,178,0,0,3261,3264,3,346,173,0,3262,3263,5,125,0,0,3263,
        3265,5,330,0,0,3264,3262,1,0,0,0,3264,3265,1,0,0,0,3265,3284,1,0,
        0,0,3266,3268,5,169,0,0,3267,3269,5,199,0,0,3268,3267,1,0,0,0,3268,
        3269,1,0,0,0,3269,3270,1,0,0,0,3270,3284,5,200,0,0,3271,3273,5,169,
        0,0,3272,3274,5,199,0,0,3273,3272,1,0,0,0,3273,3274,1,0,0,0,3274,
        3275,1,0,0,0,3275,3284,7,34,0,0,3276,3278,5,169,0,0,3277,3279,5,
        199,0,0,3278,3277,1,0,0,0,3278,3279,1,0,0,0,3279,3280,1,0,0,0,3280,
        3281,5,120,0,0,3281,3282,5,146,0,0,3282,3284,3,346,173,0,3283,3202,
        1,0,0,0,3283,3210,1,0,0,0,3283,3225,1,0,0,0,3283,3233,1,0,0,0,3283,
        3238,1,0,0,0,3283,3258,1,0,0,0,3283,3266,1,0,0,0,3283,3271,1,0,0,
        0,3283,3276,1,0,0,0,3284,345,1,0,0,0,3285,3286,6,173,-1,0,3286,3290,
        3,348,174,0,3287,3288,7,35,0,0,3288,3290,3,346,173,7,3289,3285,1,
        0,0,0,3289,3287,1,0,0,0,3290,3312,1,0,0,0,3291,3292,10,6,0,0,3292,
        3293,7,36,0,0,3293,3311,3,346,173,7,3294,3295,10,5,0,0,3295,3296,
        7,37,0,0,3296,3311,3,346,173,6,3297,3298,10,4,0,0,3298,3299,5,326,
        0,0,3299,3311,3,346,173,5,3300,3301,10,3,0,0,3301,3302,5,329,0,0,
        3302,3311,3,346,173,4,3303,3304,10,2,0,0,3304,3305,5,327,0,0,3305,
        3311,3,346,173,3,3306,3307,10,1,0,0,3307,3308,3,352,176,0,3308,3309,
        3,346,173,2,3309,3311,1,0,0,0,3310,3291,1,0,0,0,3310,3294,1,0,0,
        0,3310,3297,1,0,0,0,3310,3300,1,0,0,0,3310,3303,1,0,0,0,3310,3306,
        1,0,0,0,3311,3314,1,0,0,0,3312,3310,1,0,0,0,3312,3313,1,0,0,0,3313,
        347,1,0,0,0,3314,3312,1,0,0,0,3315,3316,6,174,-1,0,3316,3500,7,38,
        0,0,3317,3319,5,79,0,0,3318,3320,3,392,196,0,3319,3318,1,0,0,0,3320,
        3321,1,0,0,0,3321,3319,1,0,0,0,3321,3322,1,0,0,0,3322,3325,1,0,0,
        0,3323,3324,5,123,0,0,3324,3326,3,340,170,0,3325,3323,1,0,0,0,3325,
        3326,1,0,0,0,3326,3327,1,0,0,0,3327,3328,5,124,0,0,3328,3500,1,0,
        0,0,3329,3330,5,79,0,0,3330,3332,3,340,170,0,3331,3333,3,392,196,
        0,3332,3331,1,0,0,0,3333,3334,1,0,0,0,3334,3332,1,0,0,0,3334,3335,
        1,0,0,0,3335,3338,1,0,0,0,3336,3337,5,123,0,0,3337,3339,3,340,170,
        0,3338,3336,1,0,0,0,3338,3339,1,0,0,0,3339,3340,1,0,0,0,3340,3341,
        5,124,0,0,3341,3500,1,0,0,0,3342,3343,5,80,0,0,3343,3344,5,5,0,0,
        3344,3345,3,340,170,0,3345,3346,5,68,0,0,3346,3347,3,378,189,0,3347,
        3348,5,6,0,0,3348,3500,1,0,0,0,3349,3350,5,270,0,0,3350,3359,5,5,
        0,0,3351,3356,3,330,165,0,3352,3353,5,2,0,0,3353,3355,3,330,165,
        0,3354,3352,1,0,0,0,3355,3358,1,0,0,0,3356,3354,1,0,0,0,3356,3357,
        1,0,0,0,3357,3360,1,0,0,0,3358,3356,1,0,0,0,3359,3351,1,0,0,0,3359,
        3360,1,0,0,0,3360,3361,1,0,0,0,3361,3500,5,6,0,0,3362,3363,5,140,
        0,0,3363,3364,5,5,0,0,3364,3367,3,340,170,0,3365,3366,5,157,0,0,
        3366,3368,5,201,0,0,3367,3365,1,0,0,0,3367,3368,1,0,0,0,3368,3369,
        1,0,0,0,3369,3370,5,6,0,0,3370,3500,1,0,0,0,3371,3372,5,173,0,0,
        3372,3373,5,5,0,0,3373,3376,3,340,170,0,3374,3375,5,157,0,0,3375,
        3377,5,201,0,0,3376,3374,1,0,0,0,3376,3377,1,0,0,0,3377,3378,1,0,
        0,0,3378,3379,5,6,0,0,3379,3500,1,0,0,0,3380,3381,5,222,0,0,3381,
        3382,5,5,0,0,3382,3383,3,346,173,0,3383,3384,5,159,0,0,3384,3385,
        3,346,173,0,3385,3386,5,6,0,0,3386,3500,1,0,0,0,3387,3500,3,350,
        175,0,3388,3500,5,321,0,0,3389,3390,3,408,204,0,3390,3391,5,7,0,
        0,3391,3392,5,321,0,0,3392,3500,1,0,0,0,3393,3394,5,5,0,0,3394,3397,
        3,330,165,0,3395,3396,5,2,0,0,3396,3398,3,330,165,0,3397,3395,1,
        0,0,0,3398,3399,1,0,0,0,3399,3397,1,0,0,0,3399,3400,1,0,0,0,3400,
        3401,1,0,0,0,3401,3402,5,6,0,0,3402,3500,1,0,0,0,3403,3404,5,5,0,
        0,3404,3405,3,182,91,0,3405,3406,5,6,0,0,3406,3500,1,0,0,0,3407,
        3408,3,406,203,0,3408,3420,5,5,0,0,3409,3411,3,286,143,0,3410,3409,
        1,0,0,0,3410,3411,1,0,0,0,3411,3412,1,0,0,0,3412,3417,3,340,170,
        0,3413,3414,5,2,0,0,3414,3416,3,340,170,0,3415,3413,1,0,0,0,3416,
        3419,1,0,0,0,3417,3415,1,0,0,0,3417,3418,1,0,0,0,3418,3421,1,0,0,
        0,3419,3417,1,0,0,0,3420,3410,1,0,0,0,3420,3421,1,0,0,0,3421,3422,
        1,0,0,0,3422,3429,5,6,0,0,3423,3424,5,138,0,0,3424,3425,5,5,0,0,
        3425,3426,5,306,0,0,3426,3427,3,342,171,0,3427,3428,5,6,0,0,3428,
        3430,1,0,0,0,3429,3423,1,0,0,0,3429,3430,1,0,0,0,3430,3433,1,0,0,
        0,3431,3432,5,212,0,0,3432,3434,3,398,199,0,3433,3431,1,0,0,0,3433,
        3434,1,0,0,0,3434,3500,1,0,0,0,3435,3436,3,414,207,0,3436,3437,5,
        16,0,0,3437,3438,3,340,170,0,3438,3500,1,0,0,0,3439,3440,5,5,0,0,
        3440,3443,3,414,207,0,3441,3442,5,2,0,0,3442,3444,3,414,207,0,3443,
        3441,1,0,0,0,3444,3445,1,0,0,0,3445,3443,1,0,0,0,3445,3446,1,0,0,
        0,3446,3447,1,0,0,0,3447,3448,5,6,0,0,3448,3449,5,16,0,0,3449,3450,
        3,340,170,0,3450,3500,1,0,0,0,3451,3500,3,414,207,0,3452,3453,5,
        5,0,0,3453,3454,3,340,170,0,3454,3455,5,6,0,0,3455,3500,1,0,0,0,
        3456,3457,5,134,0,0,3457,3458,5,5,0,0,3458,3459,3,414,207,0,3459,
        3460,5,146,0,0,3460,3461,3,346,173,0,3461,3462,5,6,0,0,3462,3500,
        1,0,0,0,3463,3464,7,39,0,0,3464,3465,5,5,0,0,3465,3466,3,346,173,
        0,3466,3467,7,40,0,0,3467,3470,3,346,173,0,3468,3469,7,41,0,0,3469,
        3471,3,346,173,0,3470,3468,1,0,0,0,3470,3471,1,0,0,0,3471,3472,1,
        0,0,0,3472,3473,5,6,0,0,3473,3500,1,0,0,0,3474,3475,5,286,0,0,3475,
        3477,5,5,0,0,3476,3478,7,42,0,0,3477,3476,1,0,0,0,3477,3478,1,0,
        0,0,3478,3480,1,0,0,0,3479,3481,3,346,173,0,3480,3479,1,0,0,0,3480,
        3481,1,0,0,0,3481,3482,1,0,0,0,3482,3483,5,146,0,0,3483,3484,3,346,
        173,0,3484,3485,5,6,0,0,3485,3500,1,0,0,0,3486,3487,5,214,0,0,3487,
        3488,5,5,0,0,3488,3489,3,346,173,0,3489,3490,5,221,0,0,3490,3491,
        3,346,173,0,3491,3492,5,146,0,0,3492,3495,3,346,173,0,3493,3494,
        5,142,0,0,3494,3496,3,346,173,0,3495,3493,1,0,0,0,3495,3496,1,0,
        0,0,3496,3497,1,0,0,0,3497,3498,5,6,0,0,3498,3500,1,0,0,0,3499,3315,
        1,0,0,0,3499,3317,1,0,0,0,3499,3329,1,0,0,0,3499,3342,1,0,0,0,3499,
        3349,1,0,0,0,3499,3362,1,0,0,0,3499,3371,1,0,0,0,3499,3380,1,0,0,
        0,3499,3387,1,0,0,0,3499,3388,1,0,0,0,3499,3389,1,0,0,0,3499,3393,
        1,0,0,0,3499,3403,1,0,0,0,3499,3407,1,0,0,0,3499,3435,1,0,0,0,3499,
        3439,1,0,0,0,3499,3451,1,0,0,0,3499,3452,1,0,0,0,3499,3456,1,0,0,
        0,3499,3463,1,0,0,0,3499,3474,1,0,0,0,3499,3486,1,0,0,0,3500,3511,
        1,0,0,0,3501,3502,10,8,0,0,3502,3503,5,1,0,0,3503,3504,3,346,173,
        0,3504,3505,5,3,0,0,3505,3510,1,0,0,0,3506,3507,10,6,0,0,3507,3508,
        5,7,0,0,3508,3510,3,414,207,0,3509,3501,1,0,0,0,3509,3506,1,0,0,
        0,3510,3513,1,0,0,0,3511,3509,1,0,0,0,3511,3512,1,0,0,0,3512,349,
        1,0,0,0,3513,3511,1,0,0,0,3514,3527,5,200,0,0,3515,3527,3,362,181,
        0,3516,3517,3,414,207,0,3517,3518,5,330,0,0,3518,3527,1,0,0,0,3519,
        3527,3,420,210,0,3520,3527,3,360,180,0,3521,3523,5,330,0,0,3522,
        3521,1,0,0,0,3523,3524,1,0,0,0,3524,3522,1,0,0,0,3524,3525,1,0,0,
        0,3525,3527,1,0,0,0,3526,3514,1,0,0,0,3526,3515,1,0,0,0,3526,3516,
        1,0,0,0,3526,3519,1,0,0,0,3526,3520,1,0,0,0,3526,3522,1,0,0,0,3527,
        351,1,0,0,0,3528,3537,3,354,177,0,3529,3537,5,313,0,0,3530,3537,
        5,314,0,0,3531,3537,5,315,0,0,3532,3537,5,316,0,0,3533,3537,5,317,
        0,0,3534,3537,5,318,0,0,3535,3537,5,312,0,0,3536,3528,1,0,0,0,3536,
        3529,1,0,0,0,3536,3530,1,0,0,0,3536,3531,1,0,0,0,3536,3532,1,0,0,
        0,3536,3533,1,0,0,0,3536,3534,1,0,0,0,3536,3535,1,0,0,0,3537,353,
        1,0,0,0,3538,3539,7,43,0,0,3539,355,1,0,0,0,3540,3541,7,44,0,0,3541,
        357,1,0,0,0,3542,3543,7,45,0,0,3543,359,1,0,0,0,3544,3545,7,46,0,
        0,3545,361,1,0,0,0,3546,3549,5,167,0,0,3547,3550,3,364,182,0,3548,
        3550,3,368,184,0,3549,3547,1,0,0,0,3549,3548,1,0,0,0,3549,3550,1,
        0,0,0,3550,363,1,0,0,0,3551,3553,3,366,183,0,3552,3554,3,370,185,
        0,3553,3552,1,0,0,0,3553,3554,1,0,0,0,3554,365,1,0,0,0,3555,3556,
        3,372,186,0,3556,3557,3,374,187,0,3557,3559,1,0,0,0,3558,3555,1,
        0,0,0,3559,3560,1,0,0,0,3560,3558,1,0,0,0,3560,3561,1,0,0,0,3561,
        367,1,0,0,0,3562,3565,3,370,185,0,3563,3566,3,366,183,0,3564,3566,
        3,370,185,0,3565,3563,1,0,0,0,3565,3564,1,0,0,0,3565,3566,1,0,0,
        0,3566,369,1,0,0,0,3567,3568,3,372,186,0,3568,3569,3,374,187,0,3569,
        3570,5,280,0,0,3570,3571,3,374,187,0,3571,371,1,0,0,0,3572,3574,
        7,47,0,0,3573,3572,1,0,0,0,3573,3574,1,0,0,0,3574,3575,1,0,0,0,3575,
        3578,7,8,0,0,3576,3578,5,330,0,0,3577,3573,1,0,0,0,3577,3576,1,0,
        0,0,3578,373,1,0,0,0,3579,3587,5,110,0,0,3580,3587,5,155,0,0,3581,
        3587,5,192,0,0,3582,3587,5,193,0,0,3583,3587,5,251,0,0,3584,3587,
        5,309,0,0,3585,3587,3,414,207,0,3586,3579,1,0,0,0,3586,3580,1,0,
        0,0,3586,3581,1,0,0,0,3586,3582,1,0,0,0,3586,3583,1,0,0,0,3586,3584,
        1,0,0,0,3586,3585,1,0,0,0,3587,375,1,0,0,0,3588,3592,5,140,0,0,3589,
        3590,5,59,0,0,3590,3592,3,410,205,0,3591,3588,1,0,0,0,3591,3589,
        1,0,0,0,3592,377,1,0,0,0,3593,3594,5,67,0,0,3594,3595,5,315,0,0,
        3595,3596,3,378,189,0,3596,3597,5,317,0,0,3597,3628,1,0,0,0,3598,
        3599,5,189,0,0,3599,3600,5,315,0,0,3600,3601,3,378,189,0,3601,3602,
        5,2,0,0,3602,3603,3,378,189,0,3603,3604,5,317,0,0,3604,3628,1,0,
        0,0,3605,3612,5,270,0,0,3606,3608,5,315,0,0,3607,3609,3,388,194,
        0,3608,3607,1,0,0,0,3608,3609,1,0,0,0,3609,3610,1,0,0,0,3610,3613,
        5,317,0,0,3611,3613,5,313,0,0,3612,3606,1,0,0,0,3612,3611,1,0,0,
        0,3613,3628,1,0,0,0,3614,3625,3,414,207,0,3615,3616,5,5,0,0,3616,
        3621,5,334,0,0,3617,3618,5,2,0,0,3618,3620,5,334,0,0,3619,3617,1,
        0,0,0,3620,3623,1,0,0,0,3621,3619,1,0,0,0,3621,3622,1,0,0,0,3622,
        3624,1,0,0,0,3623,3621,1,0,0,0,3624,3626,5,6,0,0,3625,3615,1,0,0,
        0,3625,3626,1,0,0,0,3626,3628,1,0,0,0,3627,3593,1,0,0,0,3627,3598,
        1,0,0,0,3627,3605,1,0,0,0,3627,3614,1,0,0,0,3628,379,1,0,0,0,3629,
        3634,3,382,191,0,3630,3631,5,2,0,0,3631,3633,3,382,191,0,3632,3630,
        1,0,0,0,3633,3636,1,0,0,0,3634,3632,1,0,0,0,3634,3635,1,0,0,0,3635,
        381,1,0,0,0,3636,3634,1,0,0,0,3637,3638,3,324,162,0,3638,3641,3,
        378,189,0,3639,3640,5,199,0,0,3640,3642,5,200,0,0,3641,3639,1,0,
        0,0,3641,3642,1,0,0,0,3642,3644,1,0,0,0,3643,3645,3,180,90,0,3644,
        3643,1,0,0,0,3644,3645,1,0,0,0,3645,3647,1,0,0,0,3646,3648,3,376,
        188,0,3647,3646,1,0,0,0,3647,3648,1,0,0,0,3648,383,1,0,0,0,3649,
        3654,3,386,193,0,3650,3651,5,2,0,0,3651,3653,3,386,193,0,3652,3650,
        1,0,0,0,3653,3656,1,0,0,0,3654,3652,1,0,0,0,3654,3655,1,0,0,0,3655,
        385,1,0,0,0,3656,3654,1,0,0,0,3657,3658,3,410,205,0,3658,3661,3,
        378,189,0,3659,3660,5,199,0,0,3660,3662,5,200,0,0,3661,3659,1,0,
        0,0,3661,3662,1,0,0,0,3662,3664,1,0,0,0,3663,3665,3,180,90,0,3664,
        3663,1,0,0,0,3664,3665,1,0,0,0,3665,387,1,0,0,0,3666,3671,3,390,
        195,0,3667,3668,5,2,0,0,3668,3670,3,390,195,0,3669,3667,1,0,0,0,
        3670,3673,1,0,0,0,3671,3669,1,0,0,0,3671,3672,1,0,0,0,3672,389,1,
        0,0,0,3673,3671,1,0,0,0,3674,3675,3,414,207,0,3675,3676,5,4,0,0,
        3676,3679,3,378,189,0,3677,3678,5,199,0,0,3678,3680,5,200,0,0,3679,
        3677,1,0,0,0,3679,3680,1,0,0,0,3680,3682,1,0,0,0,3681,3683,3,180,
        90,0,3682,3681,1,0,0,0,3682,3683,1,0,0,0,3683,391,1,0,0,0,3684,3685,
        5,305,0,0,3685,3686,3,340,170,0,3686,3687,5,279,0,0,3687,3688,3,
        340,170,0,3688,393,1,0,0,0,3689,3690,5,307,0,0,3690,3695,3,396,198,
        0,3691,3692,5,2,0,0,3692,3694,3,396,198,0,3693,3691,1,0,0,0,3694,
        3697,1,0,0,0,3695,3693,1,0,0,0,3695,3696,1,0,0,0,3696,395,1,0,0,
        0,3697,3695,1,0,0,0,3698,3699,3,410,205,0,3699,3700,5,68,0,0,3700,
        3701,3,398,199,0,3701,397,1,0,0,0,3702,3749,3,410,205,0,3703,3704,
        5,5,0,0,3704,3705,3,410,205,0,3705,3706,5,6,0,0,3706,3749,1,0,0,
        0,3707,3742,5,5,0,0,3708,3709,5,84,0,0,3709,3710,5,76,0,0,3710,3715,
        3,340,170,0,3711,3712,5,2,0,0,3712,3714,3,340,170,0,3713,3711,1,
        0,0,0,3714,3717,1,0,0,0,3715,3713,1,0,0,0,3715,3716,1,0,0,0,3716,
        3743,1,0,0,0,3717,3715,1,0,0,0,3718,3719,7,48,0,0,3719,3720,5,76,
        0,0,3720,3725,3,340,170,0,3721,3722,5,2,0,0,3722,3724,3,340,170,
        0,3723,3721,1,0,0,0,3724,3727,1,0,0,0,3725,3723,1,0,0,0,3725,3726,
        1,0,0,0,3726,3729,1,0,0,0,3727,3725,1,0,0,0,3728,3718,1,0,0,0,3728,
        3729,1,0,0,0,3729,3740,1,0,0,0,3730,3731,7,49,0,0,3731,3732,5,76,
        0,0,3732,3737,3,236,118,0,3733,3734,5,2,0,0,3734,3736,3,236,118,
        0,3735,3733,1,0,0,0,3736,3739,1,0,0,0,3737,3735,1,0,0,0,3737,3738,
        1,0,0,0,3738,3741,1,0,0,0,3739,3737,1,0,0,0,3740,3730,1,0,0,0,3740,
        3741,1,0,0,0,3741,3743,1,0,0,0,3742,3708,1,0,0,0,3742,3728,1,0,0,
        0,3743,3745,1,0,0,0,3744,3746,3,400,200,0,3745,3744,1,0,0,0,3745,
        3746,1,0,0,0,3746,3747,1,0,0,0,3747,3749,5,6,0,0,3748,3702,1,0,0,
        0,3748,3703,1,0,0,0,3748,3707,1,0,0,0,3749,399,1,0,0,0,3750,3751,
        5,229,0,0,3751,3767,3,402,201,0,3752,3753,5,249,0,0,3753,3767,3,
        402,201,0,3754,3755,5,229,0,0,3755,3756,5,72,0,0,3756,3757,3,402,
        201,0,3757,3758,5,63,0,0,3758,3759,3,402,201,0,3759,3767,1,0,0,0,
        3760,3761,5,249,0,0,3761,3762,5,72,0,0,3762,3763,3,402,201,0,3763,
        3764,5,63,0,0,3764,3765,3,402,201,0,3765,3767,1,0,0,0,3766,3750,
        1,0,0,0,3766,3752,1,0,0,0,3766,3754,1,0,0,0,3766,3760,1,0,0,0,3767,
        401,1,0,0,0,3768,3769,5,291,0,0,3769,3776,7,50,0,0,3770,3771,5,102,
        0,0,3771,3776,5,248,0,0,3772,3773,3,340,170,0,3773,3774,7,50,0,0,
        3774,3776,1,0,0,0,3775,3768,1,0,0,0,3775,3770,1,0,0,0,3775,3772,
        1,0,0,0,3776,403,1,0,0,0,3777,3782,3,408,204,0,3778,3779,5,2,0,0,
        3779,3781,3,408,204,0,3780,3778,1,0,0,0,3781,3784,1,0,0,0,3782,3780,
        1,0,0,0,3782,3783,1,0,0,0,3783,405,1,0,0,0,3784,3782,1,0,0,0,3785,
        3790,3,408,204,0,3786,3790,5,138,0,0,3787,3790,5,177,0,0,3788,3790,
        5,242,0,0,3789,3785,1,0,0,0,3789,3786,1,0,0,0,3789,3787,1,0,0,0,
        3789,3788,1,0,0,0,3790,407,1,0,0,0,3791,3796,3,414,207,0,3792,3793,
        5,7,0,0,3793,3795,3,414,207,0,3794,3792,1,0,0,0,3795,3798,1,0,0,
        0,3796,3794,1,0,0,0,3796,3797,1,0,0,0,3797,409,1,0,0,0,3798,3796,
        1,0,0,0,3799,3800,3,414,207,0,3800,411,1,0,0,0,3801,3802,5,320,0,
        0,3802,3804,3,414,207,0,3803,3801,1,0,0,0,3804,3805,1,0,0,0,3805,
        3803,1,0,0,0,3805,3806,1,0,0,0,3806,413,1,0,0,0,3807,3810,3,416,
        208,0,3808,3810,3,426,213,0,3809,3807,1,0,0,0,3809,3808,1,0,0,0,
        3810,415,1,0,0,0,3811,3815,5,339,0,0,3812,3815,3,418,209,0,3813,
        3815,3,428,214,0,3814,3811,1,0,0,0,3814,3812,1,0,0,0,3814,3813,1,
        0,0,0,3815,417,1,0,0,0,3816,3817,5,340,0,0,3817,419,1,0,0,0,3818,
        3820,5,320,0,0,3819,3818,1,0,0,0,3819,3820,1,0,0,0,3820,3821,1,0,
        0,0,3821,3855,5,335,0,0,3822,3824,5,320,0,0,3823,3822,1,0,0,0,3823,
        3824,1,0,0,0,3824,3825,1,0,0,0,3825,3855,5,336,0,0,3826,3828,5,320,
        0,0,3827,3826,1,0,0,0,3827,3828,1,0,0,0,3828,3829,1,0,0,0,3829,3855,
        7,51,0,0,3830,3832,5,320,0,0,3831,3830,1,0,0,0,3831,3832,1,0,0,0,
        3832,3833,1,0,0,0,3833,3855,5,334,0,0,3834,3836,5,320,0,0,3835,3834,
        1,0,0,0,3835,3836,1,0,0,0,3836,3837,1,0,0,0,3837,3855,5,331,0,0,
        3838,3840,5,320,0,0,3839,3838,1,0,0,0,3839,3840,1,0,0,0,3840,3841,
        1,0,0,0,3841,3855,5,332,0,0,3842,3844,5,320,0,0,3843,3842,1,0,0,
        0,3843,3844,1,0,0,0,3844,3845,1,0,0,0,3845,3855,5,333,0,0,3846,3848,
        5,320,0,0,3847,3846,1,0,0,0,3847,3848,1,0,0,0,3848,3849,1,0,0,0,
        3849,3855,5,337,0,0,3850,3852,5,320,0,0,3851,3850,1,0,0,0,3851,3852,
        1,0,0,0,3852,3853,1,0,0,0,3853,3855,5,338,0,0,3854,3819,1,0,0,0,
        3854,3823,1,0,0,0,3854,3827,1,0,0,0,3854,3831,1,0,0,0,3854,3835,
        1,0,0,0,3854,3839,1,0,0,0,3854,3843,1,0,0,0,3854,3847,1,0,0,0,3854,
        3851,1,0,0,0,3855,421,1,0,0,0,3856,3857,5,289,0,0,3857,3864,3,378,
        189,0,3858,3864,3,180,90,0,3859,3864,3,376,188,0,3860,3861,7,52,
        0,0,3861,3862,5,199,0,0,3862,3864,5,200,0,0,3863,3856,1,0,0,0,3863,
        3858,1,0,0,0,3863,3859,1,0,0,0,3863,3860,1,0,0,0,3864,423,1,0,0,
        0,3865,3866,7,53,0,0,3866,425,1,0,0,0,3867,3868,7,54,0,0,3868,427,
        1,0,0,0,3869,3870,7,55,0,0,3870,429,1,0,0,0,524,433,446,449,453,
        456,459,475,479,482,487,491,494,502,505,509,512,516,523,530,537,
        541,550,554,561,565,570,574,579,584,588,593,597,602,606,610,617,
        625,629,632,636,640,643,648,655,658,662,666,669,673,675,679,682,
        686,689,693,697,700,705,709,712,716,721,726,732,746,752,757,760,
        763,766,770,773,776,779,784,787,790,793,795,803,807,812,814,823,
        831,834,842,848,853,865,869,874,878,883,890,896,900,910,913,919,
        923,926,933,935,945,952,956,960,965,970,973,980,988,993,1002,1010,
        1016,1021,1029,1034,1041,1065,1076,1085,1091,1098,1107,1115,1119,
        1125,1133,1149,1174,1179,1187,1195,1197,1217,1221,1227,1230,1233,
        1240,1245,1248,1255,1267,1276,1278,1282,1285,1292,1303,1305,1313,
        1318,1321,1327,1338,1402,1411,1415,1421,1425,1430,1436,1448,1456,
        1462,1475,1480,1496,1503,1507,1513,1528,1532,1538,1544,1547,1550,
        1556,1560,1568,1570,1579,1582,1591,1596,1602,1609,1612,1618,1629,
        1632,1636,1641,1646,1653,1656,1659,1666,1671,1680,1688,1694,1697,
        1700,1706,1710,1714,1718,1720,1728,1736,1742,1748,1751,1755,1758,
        1762,1787,1790,1794,1800,1803,1806,1812,1820,1825,1831,1837,1849,
        1852,1859,1866,1874,1877,1885,1889,1896,2012,2020,2028,2037,2047,
        2051,2054,2060,2066,2078,2090,2095,2104,2107,2115,2122,2124,2129,
        2133,2138,2143,2148,2151,2156,2160,2165,2167,2171,2180,2188,2197,
        2204,2213,2218,2221,2240,2242,2251,2258,2261,2268,2272,2278,2286,
        2297,2308,2315,2321,2334,2341,2348,2360,2368,2374,2377,2386,2389,
        2398,2401,2410,2413,2422,2425,2428,2433,2435,2443,2448,2454,2460,
        2463,2465,2473,2477,2481,2487,2491,2499,2503,2506,2509,2512,2516,
        2521,2528,2532,2535,2538,2541,2543,2546,2558,2561,2565,2575,2579,
        2581,2584,2588,2594,2598,2609,2619,2631,2646,2651,2658,2674,2679,
        2692,2697,2705,2711,2715,2724,2739,2744,2756,2761,2769,2772,2776,
        2790,2803,2808,2812,2815,2820,2829,2832,2837,2844,2847,2855,2862,
        2869,2872,2877,2880,2885,2889,2892,2895,2901,2905,2909,2914,2932,
        2934,2937,2948,2957,2964,2972,2979,2983,2986,2994,3002,3008,3016,
        3028,3031,3037,3041,3043,3052,3064,3066,3073,3080,3086,3092,3094,
        3101,3109,3115,3122,3128,3132,3134,3141,3150,3163,3168,3172,3186,
        3188,3196,3198,3202,3210,3219,3225,3233,3238,3250,3255,3258,3264,
        3268,3273,3278,3283,3289,3310,3312,3321,3325,3334,3338,3356,3359,
        3367,3376,3399,3410,3417,3420,3429,3433,3445,3470,3477,3480,3495,
        3499,3509,3511,3524,3526,3536,3549,3553,3560,3565,3573,3577,3586,
        3591,3608,3612,3621,3625,3627,3634,3641,3644,3647,3654,3661,3664,
        3671,3679,3682,3695,3715,3725,3728,3737,3740,3742,3745,3748,3766,
        3775,3782,3789,3796,3805,3809,3814,3819,3823,3827,3831,3835,3839,
        3843,3847,3851,3854,3863
    ]

class fugue_sqlParser ( Parser ):

    grammarFileName = "fugue_sql.g4"

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

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

    sharedContextCache = PredictionContextCache()

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

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

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

    ruleNames =  [ "fugueLanguage", "fugueSingleStatement", "fugueSingleTask", 
                   "fugueNestableTask", "fugueNestableTaskCollectionNoSelect", 
                   "fugueTransformTask", "fugueProcessTask", "fugueSaveAndUseTask", 
                   "fugueRenameColumnsTask", "fugueAlterColumnsTask", "fugueDropColumnsTask", 
                   "fugueDropnaTask", "fugueFillnaTask", "fugueSampleTask", 
                   "fugueTakeTask", "fugueZipTask", "fugueCreateTask", "fugueCreateDataTask", 
                   "fugueLoadTask", "fugueOutputTask", "fuguePrintTask", 
                   "fugueSaveTask", "fugueOutputTransformTask", "fugueModuleTask", 
                   "fugueSqlEngine", "fugueSingleFile", "fugueLoadColumns", 
                   "fugueSaveMode", "fugueFileFormat", "fuguePath", "fuguePaths", 
                   "fugueCheckpoint", "fugueCheckpointNamespace", "fugueYield", 
                   "fugueBroadcast", "fugueDataFrames", "fugueDataFramePair", 
                   "fugueDataFrame", "fugueDataFrameMember", "fugueAssignment", 
                   "fugueAssignmentSign", "fugueSingleOutputExtensionCommonWild", 
                   "fugueSingleOutputExtensionCommon", "fugueExtension", 
                   "fugueSampleMethod", "fugueZipType", "fuguePrepartition", 
                   "fuguePartitionAlgo", "fuguePartitionNum", "fuguePartitionNumber", 
                   "fugueParams", "fugueCols", "fugueColsSort", "fugueColSort", 
                   "fugueColumnIdentifier", "fugueRenameExpression", "fugueWildSchema", 
                   "fugueWildSchemaPair", "fugueSchemaOp", "fugueSchema", 
                   "fugueSchemaPair", "fugueSchemaKey", "fugueSchemaType", 
                   "fugueRenamePair", "fugueJson", "fugueJsonObj", "fugueJsonPairs", 
                   "fugueJsonPair", "fugueJsonKey", "fugueJsonArray", "fugueJsonValue", 
                   "fugueJsonNumber", "fugueJsonString", "fugueJsonBool", 
                   "fugueJsonNull", "fugueIdentifier", "singleStatement", 
                   "singleExpression", "singleTableIdentifier", "singleMultipartIdentifier", 
                   "singleFunctionIdentifier", "singleDataType", "singleTableSchema", 
                   "statement", "unsupportedHiveNativeCommands", "createTableHeader", 
                   "replaceTableHeader", "bucketSpec", "skewSpec", "locationSpec", 
                   "commentSpec", "query", "insertInto", "partitionSpecLocation", 
                   "partitionSpec", "partitionVal", "theNamespace", "describeFuncName", 
                   "describeColName", "ctes", "namedQuery", "tableProvider", 
                   "createTableClauses", "tablePropertyList", "tableProperty", 
                   "tablePropertyKey", "tablePropertyValue", "constantList", 
                   "nestedConstantList", "createFileFormat", "fileFormat", 
                   "storageHandler", "resource", "dmlStatementNoWith", "queryOrganization", 
                   "multiInsertQueryBody", "queryTerm", "queryPrimary", 
                   "sortItem", "fromStatement", "fromStatementBody", "querySpecification", 
                   "optionalFromClause", "transformClause", "selectClause", 
                   "setClause", "matchedClause", "notMatchedClause", "matchedAction", 
                   "notMatchedAction", "assignmentList", "assignment", "whereClause", 
                   "havingClause", "hint", "hintStatement", "fromClause", 
                   "aggregationClause", "groupingSet", "pivotClause", "pivotColumn", 
                   "pivotValue", "lateralView", "setQuantifier", "relation", 
                   "joinRelation", "joinType", "joinCriteria", "sample", 
                   "sampleMethod", "identifierList", "identifierSeq", "orderedIdentifierList", 
                   "orderedIdentifier", "identifierCommentList", "identifierComment", 
                   "relationPrimary", "inlineTable", "functionTable", "tableAlias", 
                   "rowFormat", "multipartIdentifierList", "multipartIdentifier", 
                   "tableIdentifier", "functionIdentifier", "namedExpression", 
                   "namedExpressionSeq", "transformList", "transform", "transformArgument", 
                   "expression", "booleanExpression", "predicate", "valueExpression", 
                   "primaryExpression", "constant", "comparisonOperator", 
                   "comparisonEqualOperator", "arithmeticOperator", "predicateOperator", 
                   "booleanValue", "interval", "errorCapturingMultiUnitsInterval", 
                   "multiUnitsInterval", "errorCapturingUnitToUnitInterval", 
                   "unitToUnitInterval", "intervalValue", "intervalUnit", 
                   "colPosition", "dataType", "qualifiedColTypeWithPositionList", 
                   "qualifiedColTypeWithPosition", "colTypeList", "colType", 
                   "complexColTypeList", "complexColType", "whenClause", 
                   "windowClause", "namedWindow", "windowSpec", "windowFrame", 
                   "frameBound", "qualifiedNameList", "functionName", "qualifiedName", 
                   "errorCapturingIdentifier", "errorCapturingIdentifierExtra", 
                   "identifier", "strictIdentifier", "quotedIdentifier", 
                   "number", "alterColumnAction", "ansiNonReserved", "strictNonReserved", 
                   "nonReserved" ]

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

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




    class FugueLanguageContext(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(fugue_sqlParser.EOF, 0)

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueLanguage

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




    def fugueLanguage(self):

        localctx = fugue_sqlParser.FugueLanguageContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_fugueLanguage)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 431 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 430
                self.fugueSingleTask()
                self.state = 433 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((_la) & ~0x3f) == 0 and ((1 << _la) & -269793669747965952) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0 or (((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0 or (((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & 18014398509481983) != 0 or (((_la - 324)) & ~0x3f) == 0 and ((1 << (_la - 324)) & 98305) != 0):
                    break

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


    class FugueSingleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleStatement

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




    def fugueSingleStatement(self):

        localctx = fugue_sqlParser.FugueSingleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_fugueSingleStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 437
            self.fugueSingleTask()
            self.state = 438
            self.match(fugue_sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueSingleTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleTask

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




    def fugueSingleTask(self):

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

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

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

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

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

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


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


    class FugueNestableTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueNestableTask

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




    def fugueNestableTask(self):

        localctx = fugue_sqlParser.FugueNestableTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_fugueNestableTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 449
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 448
                localctx.assign = self.fugueAssignment()


            self.state = 451
            localctx.q = self.query()
            self.state = 453
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.state = 452
                localctx.checkpoint = self.fugueCheckpoint()


            self.state = 456
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==25:
                self.state = 455
                localctx.broadcast = self.fugueBroadcast()


            self.state = 459
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==46:
                self.state = 458
                localctx.y = self.fugueYield()


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


    class FugueNestableTaskCollectionNoSelectContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueNestableTaskCollectionNoSelect

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




    def fugueNestableTaskCollectionNoSelect(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


    class FugueTransformTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueTransformTask

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




    def fugueTransformTask(self):

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


            self.state = 482
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4302831616) != 0:
                self.state = 481
                localctx.partition = self.fuguePrepartition()


            self.state = 484
            localctx.params = self.fugueSingleOutputExtensionCommonWild()
            self.state = 487
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 485
                self.match(fugue_sqlParser.CALLBACK)
                self.state = 486
                localctx.callback = self.fugueExtension()


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


    class FugueProcessTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueProcessTask

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




    def fugueProcessTask(self):

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


            self.state = 494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4302831616) != 0:
                self.state = 493
                localctx.partition = self.fuguePrepartition()


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


    class FugueSaveAndUseTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


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


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


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


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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSaveAndUseTask

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




    def fugueSaveAndUseTask(self):

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


            self.state = 505
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4302831616) != 0:
                self.state = 504
                localctx.partition = self.fuguePrepartition()


            self.state = 507
            localctx.m = self.fugueSaveMode()
            self.state = 509
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==41:
                self.state = 508
                localctx.single = self.fugueSingleFile()


            self.state = 512
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 1924145348608) != 0:
                self.state = 511
                localctx.fmt = self.fugueFileFormat()


            self.state = 514
            localctx.path = self.fuguePath()
            self.state = 516
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.state = 515
                localctx.params = self.fugueParams()


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


    class FugueRenameColumnsTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueRenameColumnsTask

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




    def fugueRenameColumnsTask(self):

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


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


    class FugueAlterColumnsTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueAlterColumnsTask

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




    def fugueAlterColumnsTask(self):

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


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


    class FugueDropColumnsTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDropColumnsTask

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




    def fugueDropColumnsTask(self):

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


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


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


    class FugueDropnaTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

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

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDropnaTask

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




    def fugueDropnaTask(self):

        localctx = fugue_sqlParser.FugueDropnaTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_fugueDropnaTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 543
            self.match(fugue_sqlParser.DROP)
            self.state = 544
            self.match(fugue_sqlParser.ROWS)
            self.state = 545
            self.match(fugue_sqlParser.IF)
            self.state = 546
            localctx.how = self._input.LT(1)
            _la = self._input.LA(1)
            if not(_la==60 or _la==65):
                localctx.how = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 547
            _la = self._input.LA(1)
            if not(_la==200 or _la==201):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 550
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.state = 548
                self.match(fugue_sqlParser.ON)
                self.state = 549
                localctx.cols = self.fugueCols()


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


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


    class FugueFillnaTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueFillnaTask

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




    def fugueFillnaTask(self):

        localctx = fugue_sqlParser.FugueFillnaTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_fugueFillnaTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 556
            self.match(fugue_sqlParser.FILL)
            self.state = 557
            _la = self._input.LA(1)
            if not(_la==200 or _la==201):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 558
            localctx.params = self.fugueParams()
            self.state = 561
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.state = 559
                self.match(fugue_sqlParser.FROM)
                self.state = 560
                localctx.df = self.fugueDataFrame()


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


    class FugueSampleTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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

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

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

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSampleTask

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




    def fugueSampleTask(self):

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


            self.state = 567
            localctx.method = self.fugueSampleMethod()
            self.state = 570
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
            if la_ == 1:
                self.state = 568
                self.match(fugue_sqlParser.SEED)
                self.state = 569
                localctx.seed = self.match(fugue_sqlParser.INTEGER_VALUE)


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


            self.state = 579
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.state = 576
                self.match(fugue_sqlParser.PREPARTITION)
                self.state = 577
                self.match(fugue_sqlParser.BY)
                self.state = 578
                localctx.by = self.fugueCols()


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


    class FugueTakeTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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


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

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

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

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

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueTakeTask

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




    def fugueTakeTask(self):

        localctx = fugue_sqlParser.FugueTakeTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_fugueTakeTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 581
            self.match(fugue_sqlParser.TAKE)
            self.state = 584
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                self.state = 582
                localctx.rows = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 583
                _la = self._input.LA(1)
                if not(_la==248 or _la==249):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 588
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.state = 586
                self.match(fugue_sqlParser.FROM)
                self.state = 587
                localctx.df = self.fugueDataFrame()


            self.state = 593
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.state = 590
                localctx.partition = self.fuguePrepartition()

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


            self.state = 597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.state = 595
                _la = self._input.LA(1)
                if not(_la==200 or _la==201):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 596
                localctx.na_position = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==140 or _la==173):
                    localctx.na_position = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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


    class FugueZipTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueZipTask

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




    def fugueZipTask(self):

        localctx = fugue_sqlParser.FugueZipTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_fugueZipTask)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 599
            self.match(fugue_sqlParser.ZIP)
            self.state = 600
            localctx.dfs = self.fugueDataFrames()
            self.state = 602
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
            if la_ == 1:
                self.state = 601
                localctx.how = self.fugueZipType()


            self.state = 606
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.state = 604
                self.match(fugue_sqlParser.BY)
                self.state = 605
                localctx.by = self.fugueCols()


            self.state = 610
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
            if la_ == 1:
                self.state = 608
                self.match(fugue_sqlParser.PRESORT)
                self.state = 609
                localctx.presort = self.fugueColsSort()


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


    class FugueCreateTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCreateTask

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




    def fugueCreateTask(self):

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


    class FugueCreateDataTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCreateDataTask

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




    def fugueCreateDataTask(self):

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


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


    class FugueLoadTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


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


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


        def fuguePaths(self):
            return self.getTypedRuleContext(fugue_sqlParser.FuguePathsContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueLoadTask

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




    def fugueLoadTask(self):

        localctx = fugue_sqlParser.FugueLoadTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_fugueLoadTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 623
            self.match(fugue_sqlParser.LOAD)
            self.state = 625
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 1924145348608) != 0:
                self.state = 624
                localctx.fmt = self.fugueFileFormat()


            self.state = 629
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [330]:
                self.state = 627
                localctx.path = self.fuguePath()
                pass
            elif token in [1]:
                self.state = 628
                localctx.paths = self.fuguePaths()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 632
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.state = 631
                localctx.params = self.fugueParams()


            self.state = 636
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.state = 634
                self.match(fugue_sqlParser.COLUMNS)
                self.state = 635
                localctx.columns = self.fugueLoadColumns()


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


    class FugueOutputTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueOutputTask

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




    def fugueOutputTask(self):

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


            self.state = 643
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4302831616) != 0:
                self.state = 642
                localctx.partition = self.fuguePrepartition()


            self.state = 645
            self.match(fugue_sqlParser.USING)
            self.state = 646
            localctx.fugueUsing = self.fugueExtension()
            self.state = 648
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 67109152) != 0:
                self.state = 647
                localctx.params = self.fugueParams()


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


    class FuguePrintTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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


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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePrintTask

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




    def fuguePrintTask(self):

        localctx = fugue_sqlParser.FuguePrintTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_fuguePrintTask)
        self._la = 0 # Token type
        try:
            self.state = 675
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 650
                self.match(fugue_sqlParser.PRINT)
                self.state = 651
                localctx.rows = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 652
                _la = self._input.LA(1)
                if not(_la==248 or _la==249):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 655
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
                if la_ == 1:
                    self.state = 653
                    self.match(fugue_sqlParser.FROM)
                    self.state = 654
                    localctx.dfs = self.fugueDataFrames()


                self.state = 658
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==30:
                    self.state = 657
                    localctx.count = self.match(fugue_sqlParser.ROWCOUNT)


                self.state = 662
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==35:
                    self.state = 660
                    self.match(fugue_sqlParser.TITLE)
                    self.state = 661
                    localctx.title = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 664
                self.match(fugue_sqlParser.PRINT)
                self.state = 666
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
                if la_ == 1:
                    self.state = 665
                    localctx.dfs = self.fugueDataFrames()


                self.state = 669
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==30:
                    self.state = 668
                    localctx.count = self.match(fugue_sqlParser.ROWCOUNT)


                self.state = 673
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==35:
                    self.state = 671
                    self.match(fugue_sqlParser.TITLE)
                    self.state = 672
                    localctx.title = self.match(fugue_sqlParser.STRING)


                pass


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


    class FugueSaveTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


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


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


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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSaveTask

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




    def fugueSaveTask(self):

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


            self.state = 682
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4302831616) != 0:
                self.state = 681
                localctx.partition = self.fuguePrepartition()


            self.state = 684
            localctx.m = self.fugueSaveMode()
            self.state = 686
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==41:
                self.state = 685
                localctx.single = self.fugueSingleFile()


            self.state = 689
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 1924145348608) != 0:
                self.state = 688
                localctx.fmt = self.fugueFileFormat()


            self.state = 691
            localctx.path = self.fuguePath()
            self.state = 693
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 67109152) != 0:
                self.state = 692
                localctx.params = self.fugueParams()


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


    class FugueOutputTransformTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueOutputTransformTask

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




    def fugueOutputTransformTask(self):

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


            self.state = 700
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4302831616) != 0:
                self.state = 699
                localctx.partition = self.fuguePrepartition()


            self.state = 702
            self.match(fugue_sqlParser.USING)
            self.state = 703
            localctx.fugueUsing = self.fugueExtension()
            self.state = 705
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 67109152) != 0:
                self.state = 704
                localctx.params = self.fugueParams()


            self.state = 709
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==55:
                self.state = 707
                self.match(fugue_sqlParser.CALLBACK)
                self.state = 708
                localctx.callback = self.fugueExtension()


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


    class FugueModuleTaskContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueModuleTask

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




    def fugueModuleTask(self):

        localctx = fugue_sqlParser.FugueModuleTaskContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_fugueModuleTask)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 712
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & -1) != 0 or (((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & -1) != 0 or (((_la - 186)) & ~0x3f) == 0 and ((1 << (_la - 186)) & -1) != 0 or (((_la - 250)) & ~0x3f) == 0 and ((1 << (_la - 250)) & 1152921504606846975) != 0 or (((_la - 324)) & ~0x3f) == 0 and ((1 << (_la - 324)) & 98305) != 0:
                self.state = 711
                localctx.assign = self.fugueAssignment()


            self.state = 714
            self.match(fugue_sqlParser.SUB)
            self.state = 716
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
            if la_ == 1:
                self.state = 715
                localctx.dfs = self.fugueDataFrames()


            self.state = 718
            self.match(fugue_sqlParser.USING)
            self.state = 719
            localctx.fugueUsing = self.fugueExtension()
            self.state = 721
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 67109152) != 0:
                self.state = 720
                localctx.params = self.fugueParams()


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


    class FugueSqlEngineContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSqlEngine

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




    def fugueSqlEngine(self):

        localctx = fugue_sqlParser.FugueSqlEngineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_fugueSqlEngine)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 723
            self.match(fugue_sqlParser.CONNECT)
            self.state = 724
            localctx.fugueUsing = self.fugueExtension()
            self.state = 726
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 67109152) != 0:
                self.state = 725
                localctx.params = self.fugueParams()


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


    class FugueSingleFileContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleFile

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




    def fugueSingleFile(self):

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


    class FugueLoadColumnsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueLoadColumns

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




    def fugueLoadColumns(self):

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

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


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


    class FugueSaveModeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSaveMode

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




    def fugueSaveMode(self):

        localctx = fugue_sqlParser.FugueSaveModeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_fugueSaveMode)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 734
            _la = self._input.LA(1)
            if not(_la==37 or _la==215 or _la==280):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueFileFormatContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueFileFormat

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




    def fugueFileFormat(self):

        localctx = fugue_sqlParser.FugueFileFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_fugueFileFormat)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 736
            _la = self._input.LA(1)
            if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 1924145348608) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FuguePathContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePath

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




    def fuguePath(self):

        localctx = fugue_sqlParser.FuguePathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_fuguePath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 738
            self.match(fugue_sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FuguePathsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePaths

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




    def fuguePaths(self):

        localctx = fugue_sqlParser.FuguePathsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_fuguePaths)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 740
            self.match(fugue_sqlParser.T__0)
            self.state = 741
            self.fuguePath()
            self.state = 746
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 742
                self.match(fugue_sqlParser.T__1)
                self.state = 743
                self.fuguePath()
                self.state = 748
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class FugueCheckpointContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCheckpoint

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



    class FugueCheckpointDeterministicContext(FugueCheckpointContext):

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

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

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

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

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


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


    class FugueCheckpointWeakContext(FugueCheckpointContext):

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

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


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


    class FugueCheckpointStrongContext(FugueCheckpointContext):

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

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

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

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


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



    def fugueCheckpoint(self):

        localctx = fugue_sqlParser.FugueCheckpointContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_fugueCheckpoint)
        self._la = 0 # Token type
        try:
            self.state = 795
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.FugueCheckpointWeakContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 752
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==175:
                    self.state = 751
                    self.match(fugue_sqlParser.LAZY)


                self.state = 757
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [24]:
                    self.state = 754
                    self.match(fugue_sqlParser.PERSIST)
                    pass
                elif token in [43]:
                    self.state = 755
                    self.match(fugue_sqlParser.WEAK)
                    self.state = 756
                    self.match(fugue_sqlParser.CHECKPOINT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 760
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 67109152) != 0:
                    self.state = 759
                    localctx.params = self.fugueParams()


                pass

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


                self.state = 766
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 765
                    self.match(fugue_sqlParser.STRONG)


                self.state = 768
                self.match(fugue_sqlParser.CHECKPOINT)
                self.state = 770
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4302831616) != 0:
                    self.state = 769
                    localctx.partition = self.fuguePrepartition()


                self.state = 773
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==41:
                    self.state = 772
                    localctx.single = self.fugueSingleFile()


                self.state = 776
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 67109152) != 0:
                    self.state = 775
                    localctx.params = self.fugueParams()


                pass

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


                self.state = 781
                self.match(fugue_sqlParser.DETERMINISTIC)
                self.state = 782
                self.match(fugue_sqlParser.CHECKPOINT)
                self.state = 784
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==330:
                    self.state = 783
                    localctx.ns = self.fugueCheckpointNamespace()


                self.state = 787
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4302831616) != 0:
                    self.state = 786
                    localctx.partition = self.fuguePrepartition()


                self.state = 790
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==41:
                    self.state = 789
                    localctx.single = self.fugueSingleFile()


                self.state = 793
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 67109152) != 0:
                    self.state = 792
                    localctx.params = self.fugueParams()


                pass


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


    class FugueCheckpointNamespaceContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCheckpointNamespace

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




    def fugueCheckpointNamespace(self):

        localctx = fugue_sqlParser.FugueCheckpointNamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_fugueCheckpointNamespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 797
            self.match(fugue_sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueYieldContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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


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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueYield

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




    def fugueYield(self):

        localctx = fugue_sqlParser.FugueYieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_fugueYield)
        self._la = 0 # Token type
        try:
            self.state = 814
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 799
                self.match(fugue_sqlParser.YIELD)
                self.state = 800
                _la = self._input.LA(1)
                if not(_la==57 or _la==273 or _la==303):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 803
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
                if la_ == 1:
                    self.state = 801
                    self.match(fugue_sqlParser.AS)
                    self.state = 802
                    localctx.name = self.fugueIdentifier()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 805
                self.match(fugue_sqlParser.YIELD)
                self.state = 807
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 806
                    self.match(fugue_sqlParser.LOCAL)


                self.state = 809
                self.match(fugue_sqlParser.DATAFRAME)
                self.state = 812
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
                if la_ == 1:
                    self.state = 810
                    self.match(fugue_sqlParser.AS)
                    self.state = 811
                    localctx.name = self.fugueIdentifier()


                pass


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


    class FugueBroadcastContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueBroadcast

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




    def fugueBroadcast(self):

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


    class FugueDataFramesContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDataFrames

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



    class FugueDataFramesDictContext(FugueDataFramesContext):

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

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


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


    class FugueDataFramesListContext(FugueDataFramesContext):

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

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


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



    def fugueDataFrames(self):

        localctx = fugue_sqlParser.FugueDataFramesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_fugueDataFrames)
        try:
            self.state = 834
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.FugueDataFramesListContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 818
                self.fugueDataFrame()
                self.state = 823
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,83,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 819
                        self.match(fugue_sqlParser.T__1)
                        self.state = 820
                        self.fugueDataFrame() 
                    self.state = 825
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,83,self._ctx)

                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.FugueDataFramesDictContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 826
                self.fugueDataFramePair()
                self.state = 831
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,84,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 827
                        self.match(fugue_sqlParser.T__1)
                        self.state = 828
                        self.fugueDataFramePair() 
                    self.state = 833
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,84,self._ctx)

                pass


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


    class FugueDataFramePairContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDataFramePair

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




    def fugueDataFramePair(self):

        localctx = fugue_sqlParser.FugueDataFramePairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_fugueDataFramePair)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 836
            localctx.key = self.fugueIdentifier()
            self.state = 837
            _la = self._input.LA(1)
            if not(_la==4 or _la==310):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 838
            localctx.value = self.fugueDataFrame()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueDataFrameContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDataFrame

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



    class FugueDataFrameSourceContext(FugueDataFrameContext):

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

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

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


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


    class FugueDataFrameNestedContext(FugueDataFrameContext):

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

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


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



    def fugueDataFrame(self):

        localctx = fugue_sqlParser.FugueDataFrameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_fugueDataFrame)
        try:
            self.state = 848
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                localctx = fugue_sqlParser.FugueDataFrameSourceContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 840
                self.fugueIdentifier()
                self.state = 842
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
                if la_ == 1:
                    self.state = 841
                    self.fugueDataFrameMember()


                pass
            elif token in [5]:
                localctx = fugue_sqlParser.FugueDataFrameNestedContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 844
                self.match(fugue_sqlParser.T__4)
                self.state = 845
                localctx.task = self.fugueNestableTask()
                self.state = 846
                self.match(fugue_sqlParser.T__5)
                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 FugueDataFrameMemberContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueDataFrameMember

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




    def fugueDataFrameMember(self):

        localctx = fugue_sqlParser.FugueDataFrameMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_fugueDataFrameMember)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 850
            self.match(fugue_sqlParser.T__0)
            self.state = 853
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [334]:
                self.state = 851
                localctx.index = self.match(fugue_sqlParser.INTEGER_VALUE)
                pass
            elif token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                self.state = 852
                localctx.key = self.fugueIdentifier()
                pass
            else:
                raise NoViableAltException(self)

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


    class FugueAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueAssignment

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




    def fugueAssignment(self):

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


    class FugueAssignmentSignContext(ParserRuleContext):
        __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(fugue_sqlParser.EQUAL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueAssignmentSign

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




    def fugueAssignmentSign(self):

        localctx = fugue_sqlParser.FugueAssignmentSignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_fugueAssignmentSign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 860
            self.match(fugue_sqlParser.EQUAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueSingleOutputExtensionCommonWildContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleOutputExtensionCommonWild

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




    def fugueSingleOutputExtensionCommonWild(self):

        localctx = fugue_sqlParser.FugueSingleOutputExtensionCommonWildContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_fugueSingleOutputExtensionCommonWild)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 862
            self.match(fugue_sqlParser.USING)
            self.state = 863
            localctx.fugueUsing = self.fugueExtension()
            self.state = 865
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
            if la_ == 1:
                self.state = 864
                localctx.params = self.fugueParams()


            self.state = 869
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.state = 867
                self.match(fugue_sqlParser.SCHEMA)
                self.state = 868
                localctx.schema = self.fugueWildSchema()


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


    class FugueSingleOutputExtensionCommonContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSingleOutputExtensionCommon

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




    def fugueSingleOutputExtensionCommon(self):

        localctx = fugue_sqlParser.FugueSingleOutputExtensionCommonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_fugueSingleOutputExtensionCommon)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 871
            self.match(fugue_sqlParser.USING)
            self.state = 872
            localctx.fugueUsing = self.fugueExtension()
            self.state = 874
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,91,self._ctx)
            if la_ == 1:
                self.state = 873
                localctx.params = self.fugueParams()


            self.state = 878
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
            if la_ == 1:
                self.state = 876
                self.match(fugue_sqlParser.SCHEMA)
                self.state = 877
                localctx.schema = self.fugueSchema()


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


    class FugueExtensionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueExtension

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




    def fugueExtension(self):

        localctx = fugue_sqlParser.FugueExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_fugueExtension)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 883
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
            if la_ == 1:
                self.state = 880
                localctx.domain = self.fugueIdentifier()
                self.state = 881
                self.match(fugue_sqlParser.T__3)


            self.state = 885
            self.fugueIdentifier()
            self.state = 890
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,94,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 886
                    self.match(fugue_sqlParser.T__6)
                    self.state = 887
                    self.fugueIdentifier() 
                self.state = 892
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,94,self._ctx)

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


    class FugueSampleMethodContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSampleMethod

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




    def fugueSampleMethod(self):

        localctx = fugue_sqlParser.FugueSampleMethodContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_fugueSampleMethod)
        self._la = 0 # Token type
        try:
            self.state = 900
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 893
                localctx.percentage = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==334 or _la==336):
                    localctx.percentage = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 894
                _la = self._input.LA(1)
                if not(_la==219 or _la==323):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 896
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==50:
                    self.state = 895
                    self.match(fugue_sqlParser.APPROX)


                self.state = 898
                localctx.rows = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 899
                self.match(fugue_sqlParser.ROWS)
                pass


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


    class FugueZipTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueZipType

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




    def fugueZipType(self):

        localctx = fugue_sqlParser.FugueZipTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_fugueZipType)
        try:
            self.state = 910
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [100]:
                self.enterOuterAlt(localctx, 1)
                self.state = 902
                self.match(fugue_sqlParser.CROSS)
                pass
            elif token in [162]:
                self.enterOuterAlt(localctx, 2)
                self.state = 903
                self.match(fugue_sqlParser.INNER)
                pass
            elif token in [177]:
                self.enterOuterAlt(localctx, 3)
                self.state = 904
                self.match(fugue_sqlParser.LEFT)
                self.state = 905
                self.match(fugue_sqlParser.OUTER)
                pass
            elif token in [242]:
                self.enterOuterAlt(localctx, 4)
                self.state = 906
                self.match(fugue_sqlParser.RIGHT)
                self.state = 907
                self.match(fugue_sqlParser.OUTER)
                pass
            elif token in [147]:
                self.enterOuterAlt(localctx, 5)
                self.state = 908
                self.match(fugue_sqlParser.FULL)
                self.state = 909
                self.match(fugue_sqlParser.OUTER)
                pass
            else:
                raise NoViableAltException(self)

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


    class FuguePrepartitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePrepartition

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




    def fuguePrepartition(self):

        localctx = fugue_sqlParser.FuguePrepartitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_fuguePrepartition)
        self._la = 0 # Token type
        try:
            self.state = 935
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,103,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 913
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 7864320) != 0:
                    self.state = 912
                    localctx.algo = self.fuguePartitionAlgo()


                self.state = 915
                self.match(fugue_sqlParser.PREPARTITION)
                self.state = 916
                localctx.num = self.fuguePartitionNum(0)
                self.state = 919
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
                if la_ == 1:
                    self.state = 917
                    self.match(fugue_sqlParser.BY)
                    self.state = 918
                    localctx.by = self.fugueCols()


                self.state = 923
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
                if la_ == 1:
                    self.state = 921
                    self.match(fugue_sqlParser.PRESORT)
                    self.state = 922
                    localctx.presort = self.fugueColsSort()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 926
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 7864320) != 0:
                    self.state = 925
                    localctx.algo = self.fuguePartitionAlgo()


                self.state = 928
                self.match(fugue_sqlParser.PREPARTITION)
                self.state = 929
                self.match(fugue_sqlParser.BY)
                self.state = 930
                localctx.by = self.fugueCols()
                self.state = 933
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
                if la_ == 1:
                    self.state = 931
                    self.match(fugue_sqlParser.PRESORT)
                    self.state = 932
                    localctx.presort = self.fugueColsSort()


                pass


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


    class FuguePartitionAlgoContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePartitionAlgo

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




    def fuguePartitionAlgo(self):

        localctx = fugue_sqlParser.FuguePartitionAlgoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_fuguePartitionAlgo)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 937
            _la = self._input.LA(1)
            if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 7864320) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FuguePartitionNumContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePartitionNum

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



    def fuguePartitionNum(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = fugue_sqlParser.FuguePartitionNumContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 96
        self.enterRecursionRule(localctx, 96, self.RULE_fuguePartitionNum, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 945
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [30, 31, 320, 334, 336]:
                self.state = 940
                self.fuguePartitionNumber()
                pass
            elif token in [5]:
                self.state = 941
                self.match(fugue_sqlParser.T__4)
                self.state = 942
                self.fuguePartitionNum(0)
                self.state = 943
                self.match(fugue_sqlParser.T__5)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 952
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,105,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = fugue_sqlParser.FuguePartitionNumContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_fuguePartitionNum)
                    self.state = 947
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 948
                    _la = self._input.LA(1)
                    if not((((_la - 319)) & ~0x3f) == 0 and ((1 << (_la - 319)) & 15) != 0):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 949
                    self.fuguePartitionNum(2) 
                self.state = 954
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,105,self._ctx)

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


    class FuguePartitionNumberContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fuguePartitionNumber

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




    def fuguePartitionNumber(self):

        localctx = fugue_sqlParser.FuguePartitionNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_fuguePartitionNumber)
        self._la = 0 # Token type
        try:
            self.state = 965
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 956
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 955
                    self.match(fugue_sqlParser.MINUS)


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

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


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

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

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


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


    class FugueParamsContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueParams

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



    class FugueParamsPairsContext(FugueParamsContext):

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

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


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


    class FugueParamsObjContext(FugueParamsContext):

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

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

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

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



    def fugueParams(self):

        localctx = fugue_sqlParser.FugueParamsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_fugueParams)
        self._la = 0 # Token type
        try:
            self.state = 973
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.FugueParamsPairsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 967
                self.match(fugue_sqlParser.PARAMS)
                self.state = 968
                localctx.pairs = self.fugueJsonPairs()
                pass

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


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


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


    class FugueColsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueCols

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




    def fugueCols(self):

        localctx = fugue_sqlParser.FugueColsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_fugueCols)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 975
            self.fugueColumnIdentifier()
            self.state = 980
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,111,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 976
                    self.match(fugue_sqlParser.T__1)
                    self.state = 977
                    self.fugueColumnIdentifier() 
                self.state = 982
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,111,self._ctx)

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


    class FugueColsSortContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueColsSort

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




    def fugueColsSort(self):

        localctx = fugue_sqlParser.FugueColsSortContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_fugueColsSort)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 983
            self.fugueColSort()
            self.state = 988
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,112,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 984
                    self.match(fugue_sqlParser.T__1)
                    self.state = 985
                    self.fugueColSort() 
                self.state = 990
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,112,self._ctx)

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


    class FugueColSortContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueColSort

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




    def fugueColSort(self):

        localctx = fugue_sqlParser.FugueColSortContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_fugueColSort)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 991
            self.fugueColumnIdentifier()
            self.state = 993
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
            if la_ == 1:
                self.state = 992
                _la = self._input.LA(1)
                if not(_la==69 or _la==115):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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


    class FugueColumnIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueColumnIdentifier

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




    def fugueColumnIdentifier(self):

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


    class FugueRenameExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueRenameExpression

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




    def fugueRenameExpression(self):

        localctx = fugue_sqlParser.FugueRenameExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_fugueRenameExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 997
            self.fugueRenamePair()
            self.state = 1002
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,114,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 998
                    self.match(fugue_sqlParser.T__1)
                    self.state = 999
                    self.fugueRenamePair() 
                self.state = 1004
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,114,self._ctx)

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


    class FugueWildSchemaContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueWildSchema

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




    def fugueWildSchema(self):

        localctx = fugue_sqlParser.FugueWildSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_fugueWildSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1005
            self.fugueWildSchemaPair()
            self.state = 1010
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,115,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1006
                    self.match(fugue_sqlParser.T__1)
                    self.state = 1007
                    self.fugueWildSchemaPair() 
                self.state = 1012
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,115,self._ctx)

            self.state = 1016
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,116,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1013
                    self.fugueSchemaOp() 
                self.state = 1018
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,116,self._ctx)

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


    class FugueWildSchemaPairContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueWildSchemaPair

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




    def fugueWildSchemaPair(self):

        localctx = fugue_sqlParser.FugueWildSchemaPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_fugueWildSchemaPair)
        try:
            self.state = 1021
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1019
                localctx.pair = self.fugueSchemaPair()
                pass
            elif token in [321]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1020
                self.match(fugue_sqlParser.ASTERISK)
                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 FugueSchemaOpContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchemaOp

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




    def fugueSchemaOp(self):

        localctx = fugue_sqlParser.FugueSchemaOpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_fugueSchemaOp)
        self._la = 0 # Token type
        try:
            self.state = 1034
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [320, 325]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1023
                _la = self._input.LA(1)
                if not(_la==320 or _la==325):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1024
                self.fugueSchemaKey()
                self.state = 1029
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,118,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1025
                        self.match(fugue_sqlParser.T__1)
                        self.state = 1026
                        self.fugueSchemaKey() 
                    self.state = 1031
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,118,self._ctx)

                pass
            elif token in [319]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1032
                self.match(fugue_sqlParser.PLUS)
                self.state = 1033
                self.fugueSchema()
                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 FugueSchemaContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchema

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




    def fugueSchema(self):

        localctx = fugue_sqlParser.FugueSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_fugueSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1036
            self.fugueSchemaPair()
            self.state = 1041
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,120,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1037
                    self.match(fugue_sqlParser.T__1)
                    self.state = 1038
                    self.fugueSchemaPair() 
                self.state = 1043
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,120,self._ctx)

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


    class FugueSchemaPairContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchemaPair

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




    def fugueSchemaPair(self):

        localctx = fugue_sqlParser.FugueSchemaPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_fugueSchemaPair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1044
            localctx.key = self.fugueSchemaKey()
            self.state = 1045
            self.match(fugue_sqlParser.T__3)
            self.state = 1046
            localctx.value = self.fugueSchemaType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueSchemaKeyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchemaKey

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




    def fugueSchemaKey(self):

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


    class FugueSchemaTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueSchemaType

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



    class FugueSchemaSimpleTypeContext(FugueSchemaTypeContext):

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

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


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


    class FugueSchemaMapTypeContext(FugueSchemaTypeContext):

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

        def LT(self):
            return self.getToken(fugue_sqlParser.LT, 0)
        def fugueSchemaType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FugueSchemaTypeContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FugueSchemaTypeContext,i)

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

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


    class FugueSchemaStructTypeContext(FugueSchemaTypeContext):

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

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


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


    class FugueSchemaListTypeContext(FugueSchemaTypeContext):

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

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


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



    def fugueSchemaType(self):

        localctx = fugue_sqlParser.FugueSchemaTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_fugueSchemaType)
        try:
            self.state = 1065
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                localctx = fugue_sqlParser.FugueSchemaSimpleTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1050
                self.fugueIdentifier()
                pass
            elif token in [1]:
                localctx = fugue_sqlParser.FugueSchemaListTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1051
                self.match(fugue_sqlParser.T__0)
                self.state = 1052
                self.fugueSchemaType()
                self.state = 1053
                self.match(fugue_sqlParser.T__2)
                pass
            elif token in [8]:
                localctx = fugue_sqlParser.FugueSchemaStructTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1055
                self.match(fugue_sqlParser.T__7)
                self.state = 1056
                self.fugueSchema()
                self.state = 1057
                self.match(fugue_sqlParser.T__8)
                pass
            elif token in [315]:
                localctx = fugue_sqlParser.FugueSchemaMapTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1059
                self.match(fugue_sqlParser.LT)
                self.state = 1060
                self.fugueSchemaType()
                self.state = 1061
                self.match(fugue_sqlParser.T__1)
                self.state = 1062
                self.fugueSchemaType()
                self.state = 1063
                self.match(fugue_sqlParser.GT)
                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 FugueRenamePairContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueRenamePair

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




    def fugueRenamePair(self):

        localctx = fugue_sqlParser.FugueRenamePairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_fugueRenamePair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1067
            localctx.key = self.fugueSchemaKey()
            self.state = 1068
            self.match(fugue_sqlParser.T__3)
            self.state = 1069
            localctx.value = self.fugueSchemaKey()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueJsonContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJson

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




    def fugueJson(self):

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


    class FugueJsonObjContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonObj

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




    def fugueJsonObj(self):

        localctx = fugue_sqlParser.FugueJsonObjContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_fugueJsonObj)
        self._la = 0 # Token type
        try:
            self.state = 1091
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1073
                self.match(fugue_sqlParser.T__7)
                self.state = 1074
                self.fugueJsonPairs()
                self.state = 1076
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==2:
                    self.state = 1075
                    self.match(fugue_sqlParser.T__1)


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

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1082
                self.match(fugue_sqlParser.T__4)
                self.state = 1083
                self.fugueJsonPairs()
                self.state = 1085
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==2:
                    self.state = 1084
                    self.match(fugue_sqlParser.T__1)


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

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1089
                self.match(fugue_sqlParser.T__4)
                self.state = 1090
                self.match(fugue_sqlParser.T__5)
                pass


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


    class FugueJsonPairsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonPairs

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




    def fugueJsonPairs(self):

        localctx = fugue_sqlParser.FugueJsonPairsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_fugueJsonPairs)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1093
            self.fugueJsonPair()
            self.state = 1098
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,125,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1094
                    self.match(fugue_sqlParser.T__1)
                    self.state = 1095
                    self.fugueJsonPair() 
                self.state = 1100
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,125,self._ctx)

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


    class FugueJsonPairContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonPair

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




    def fugueJsonPair(self):

        localctx = fugue_sqlParser.FugueJsonPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_fugueJsonPair)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1101
            localctx.key = self.fugueJsonKey()
            self.state = 1102
            _la = self._input.LA(1)
            if not(_la==4 or _la==310):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1103
            localctx.value = self.fugueJsonValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueJsonKeyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonKey

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




    def fugueJsonKey(self):

        localctx = fugue_sqlParser.FugueJsonKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_fugueJsonKey)
        try:
            self.state = 1107
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1105
                self.fugueIdentifier()
                pass
            elif token in [330]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1106
                self.fugueJsonString()
                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 FugueJsonArrayContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonArray

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




    def fugueJsonArray(self):

        localctx = fugue_sqlParser.FugueJsonArrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_fugueJsonArray)
        self._la = 0 # Token type
        try:
            self.state = 1125
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1109
                self.match(fugue_sqlParser.T__0)
                self.state = 1110
                self.fugueJsonValue()
                self.state = 1115
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,127,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1111
                        self.match(fugue_sqlParser.T__1)
                        self.state = 1112
                        self.fugueJsonValue() 
                    self.state = 1117
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,127,self._ctx)

                self.state = 1119
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==2:
                    self.state = 1118
                    self.match(fugue_sqlParser.T__1)


                self.state = 1121
                self.match(fugue_sqlParser.T__2)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1123
                self.match(fugue_sqlParser.T__0)
                self.state = 1124
                self.match(fugue_sqlParser.T__2)
                pass


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


    class FugueJsonValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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


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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonValue

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




    def fugueJsonValue(self):

        localctx = fugue_sqlParser.FugueJsonValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_fugueJsonValue)
        try:
            self.state = 1133
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [330]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1127
                self.fugueJsonString()
                pass
            elif token in [320, 331, 332, 333, 334, 335, 336, 337, 338]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1128
                self.fugueJsonNumber()
                pass
            elif token in [5, 8]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1129
                self.fugueJsonObj()
                pass
            elif token in [1]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1130
                self.fugueJsonArray()
                pass
            elif token in [10, 11, 135, 287]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1131
                self.fugueJsonBool()
                pass
            elif token in [12, 200]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1132
                self.fugueJsonNull()
                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 FugueJsonNumberContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonNumber

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




    def fugueJsonNumber(self):

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


    class FugueJsonStringContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonString

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




    def fugueJsonString(self):

        localctx = fugue_sqlParser.FugueJsonStringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_fugueJsonString)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1137
            self.match(fugue_sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueJsonBoolContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonBool

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




    def fugueJsonBool(self):

        localctx = fugue_sqlParser.FugueJsonBoolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_fugueJsonBool)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1139
            _la = self._input.LA(1)
            if not(_la==10 or _la==11 or _la==135 or _la==287):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueJsonNullContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueJsonNull

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




    def fugueJsonNull(self):

        localctx = fugue_sqlParser.FugueJsonNullContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_fugueJsonNull)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1141
            _la = self._input.LA(1)
            if not(_la==12 or _la==200):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FugueIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fugueIdentifier

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




    def fugueIdentifier(self):

        localctx = fugue_sqlParser.FugueIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_fugueIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1143
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_singleStatement

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




    def singleStatement(self):

        localctx = fugue_sqlParser.SingleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_singleStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1145
            self.statement()
            self.state = 1149
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==13:
                self.state = 1146
                self.match(fugue_sqlParser.T__12)
                self.state = 1151
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class SingleExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_singleExpression

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




    def singleExpression(self):

        localctx = fugue_sqlParser.SingleExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_singleExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1154
            self.namedExpression()
            self.state = 1155
            self.match(fugue_sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleTableIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_singleTableIdentifier

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




    def singleTableIdentifier(self):

        localctx = fugue_sqlParser.SingleTableIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_singleTableIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1157
            self.tableIdentifier()
            self.state = 1158
            self.match(fugue_sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleMultipartIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_singleMultipartIdentifier

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




    def singleMultipartIdentifier(self):

        localctx = fugue_sqlParser.SingleMultipartIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_singleMultipartIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1160
            self.multipartIdentifier()
            self.state = 1161
            self.match(fugue_sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleFunctionIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_singleFunctionIdentifier

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




    def singleFunctionIdentifier(self):

        localctx = fugue_sqlParser.SingleFunctionIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_singleFunctionIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1163
            self.functionIdentifier()
            self.state = 1164
            self.match(fugue_sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleDataTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_singleDataType

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




    def singleDataType(self):

        localctx = fugue_sqlParser.SingleDataTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_singleDataType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1166
            self.dataType()
            self.state = 1167
            self.match(fugue_sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleTableSchemaContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_singleTableSchema

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




    def singleTableSchema(self):

        localctx = fugue_sqlParser.SingleTableSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_singleTableSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1169
            self.colTypeList()
            self.state = 1170
            self.match(fugue_sqlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_statement

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



    class ExplainContext(StatementContext):

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

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

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

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


    class ResetConfigurationContext(StatementContext):

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

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

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


    class AlterViewQueryContext(StatementContext):

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

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

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

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

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


    class UseContext(StatementContext):

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

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

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

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


    class DropNamespaceContext(StatementContext):

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

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

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

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

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


    class CreateTempViewUsingContext(StatementContext):

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

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

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

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

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


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


    class RenameTableContext(StatementContext):

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

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


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


    class FailNativeCommandContext(StatementContext):

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

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


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


    class ClearCacheContext(StatementContext):

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

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

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


    class DropViewContext(StatementContext):

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

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

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

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


    class ShowTablesContext(StatementContext):

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

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

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

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


    class RecoverPartitionsContext(StatementContext):

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

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

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

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


    class ShowCurrentNamespaceContext(StatementContext):

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

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

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


    class RenameTablePartitionContext(StatementContext):

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

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

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


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


    class RepairTableContext(StatementContext):

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

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


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


    class RefreshResourceContext(StatementContext):

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

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

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


    class ShowCreateTableContext(StatementContext):

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

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

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

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


    class ShowNamespacesContext(StatementContext):

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

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

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

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


    class ShowColumnsContext(StatementContext):

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

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


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


    class ReplaceTableContext(StatementContext):

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

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

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

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

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

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

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

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


    class AddTablePartitionContext(StatementContext):

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

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

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


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


    class SetNamespaceLocationContext(StatementContext):

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

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

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

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


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


    class RefreshTableContext(StatementContext):

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

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


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


    class SetNamespacePropertiesContext(StatementContext):

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

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

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

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

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

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


    class ManageResourceContext(StatementContext):

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

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

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

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


    class AnalyzeContext(StatementContext):

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

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

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

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

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

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

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


    class CreateHiveTableContext(StatementContext):

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    class CreateFunctionContext(StatementContext):

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

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

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


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


    class ShowTableContext(StatementContext):

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

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

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


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


    class HiveReplaceColumnsContext(StatementContext):

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

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

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

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


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


    class CommentNamespaceContext(StatementContext):

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

        def COMMENT(self):
            return self.getToken(fugue_sqlParser.COMMENT, 0)
        def ON(self):
            return self.getToken(fugue_sqlParser.ON, 0)
        def theNamespace(self):
            return self.getTypedRuleContext(fugue_sqlParser.TheNamespaceContext,0)

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

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

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


    class CreateTableContext(StatementContext):

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

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

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

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

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

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

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

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


    class DmlStatementContext(StatementContext):

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

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

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


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


    class CreateTableLikeContext(StatementContext):

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

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

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

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

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

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

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


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


    class UncacheTableContext(StatementContext):

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

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

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

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


    class DropFunctionContext(StatementContext):

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

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

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

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


    class DescribeRelationContext(StatementContext):

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

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

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

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

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

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


    class LoadDataContext(StatementContext):

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

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

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


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


    class ShowPartitionsContext(StatementContext):

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

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

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


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


    class DescribeFunctionContext(StatementContext):

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

        def FUNCTION(self):
            return self.getToken(fugue_sqlParser.FUNCTION, 0)
        def describeFuncName(self):
            return self.getTypedRuleContext(fugue_sqlParser.DescribeFuncNameContext,0)

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(fugue_sqlParser.DESCRIBE, 0)
        def EXTENDED(self):
            return self.getToken(fugue_sqlParser.EXTENDED, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescribeFunction" ):
                return visitor.visitDescribeFunction(self)
            else:
                return visitor.visitChildren(self)


    class RenameTableColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.ifrom = None # MultipartIdentifierContext
            self.to = None # ErrorCapturingIdentifierContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def RENAME(self):
            return self.getToken(fugue_sqlParser.RENAME, 0)
        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def TO(self):
            return self.getToken(fugue_sqlParser.TO, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,i)

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRenameTableColumn" ):
                return visitor.visitRenameTableColumn(self)
            else:
                return visitor.visitChildren(self)


    class StatementDefaultContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatementDefault" ):
                return visitor.visitStatementDefault(self)
            else:
                return visitor.visitChildren(self)


    class HiveChangeColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.colName = None # MultipartIdentifierContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def CHANGE(self):
            return self.getToken(fugue_sqlParser.CHANGE, 0)
        def colType(self):
            return self.getTypedRuleContext(fugue_sqlParser.ColTypeContext,0)

        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,i)

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,0)

        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def colPosition(self):
            return self.getTypedRuleContext(fugue_sqlParser.ColPositionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHiveChangeColumn" ):
                return visitor.visitHiveChangeColumn(self)
            else:
                return visitor.visitChildren(self)


    class DescribeQueryContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(fugue_sqlParser.DESCRIBE, 0)
        def QUERY(self):
            return self.getToken(fugue_sqlParser.QUERY, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescribeQuery" ):
                return visitor.visitDescribeQuery(self)
            else:
                return visitor.visitChildren(self)


    class TruncateTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TRUNCATE(self):
            return self.getToken(fugue_sqlParser.TRUNCATE, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTruncateTable" ):
                return visitor.visitTruncateTable(self)
            else:
                return visitor.visitChildren(self)


    class SetTableSerDeContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)
        def SERDE(self):
            return self.getToken(fugue_sqlParser.SERDE, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,0)

        def WITH(self):
            return self.getToken(fugue_sqlParser.WITH, 0)
        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetTableSerDe" ):
                return visitor.visitSetTableSerDe(self)
            else:
                return visitor.visitChildren(self)


    class CreateViewContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(fugue_sqlParser.CREATE, 0)
        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)
        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)

        def OR(self):
            return self.getToken(fugue_sqlParser.OR, 0)
        def REPLACE(self):
            return self.getToken(fugue_sqlParser.REPLACE, 0)
        def TEMPORARY(self):
            return self.getToken(fugue_sqlParser.TEMPORARY, 0)
        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def identifierCommentList(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierCommentListContext,0)

        def commentSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.CommentSpecContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,i)

        def PARTITIONED(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.PARTITIONED)
            else:
                return self.getToken(fugue_sqlParser.PARTITIONED, i)
        def ON(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.ON)
            else:
                return self.getToken(fugue_sqlParser.ON, i)
        def identifierList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierListContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierListContext,i)

        def TBLPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.TBLPROPERTIES)
            else:
                return self.getToken(fugue_sqlParser.TBLPROPERTIES, i)
        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,i)

        def GLOBAL(self):
            return self.getToken(fugue_sqlParser.GLOBAL, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateView" ):
                return visitor.visitCreateView(self)
            else:
                return visitor.visitChildren(self)


    class DropTablePartitionsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def DROP(self):
            return self.getToken(fugue_sqlParser.DROP, 0)
        def partitionSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.PartitionSpecContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,i)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)
        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def PURGE(self):
            return self.getToken(fugue_sqlParser.PURGE, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropTablePartitions" ):
                return visitor.visitDropTablePartitions(self)
            else:
                return visitor.visitChildren(self)


    class SetConfigurationContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetConfiguration" ):
                return visitor.visitSetConfiguration(self)
            else:
                return visitor.visitChildren(self)


    class DropTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DROP(self):
            return self.getToken(fugue_sqlParser.DROP, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def PURGE(self):
            return self.getToken(fugue_sqlParser.PURGE, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropTable" ):
                return visitor.visitDropTable(self)
            else:
                return visitor.visitChildren(self)


    class DescribeNamespaceContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def theNamespace(self):
            return self.getTypedRuleContext(fugue_sqlParser.TheNamespaceContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)
        def DESCRIBE(self):
            return self.getToken(fugue_sqlParser.DESCRIBE, 0)
        def EXTENDED(self):
            return self.getToken(fugue_sqlParser.EXTENDED, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescribeNamespace" ):
                return visitor.visitDescribeNamespace(self)
            else:
                return visitor.visitChildren(self)


    class AlterTableAlterColumnContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.column = None # MultipartIdentifierContext
            self.copyFrom(ctx)

        def ALTER(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.ALTER)
            else:
                return self.getToken(fugue_sqlParser.ALTER, i)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,i)

        def CHANGE(self):
            return self.getToken(fugue_sqlParser.CHANGE, 0)
        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def alterColumnAction(self):
            return self.getTypedRuleContext(fugue_sqlParser.AlterColumnActionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAlterTableAlterColumn" ):
                return visitor.visitAlterTableAlterColumn(self)
            else:
                return visitor.visitChildren(self)


    class CommentTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.comment = None # Token
            self.copyFrom(ctx)

        def COMMENT(self):
            return self.getToken(fugue_sqlParser.COMMENT, 0)
        def ON(self):
            return self.getToken(fugue_sqlParser.ON, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def IS(self):
            return self.getToken(fugue_sqlParser.IS, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCommentTable" ):
                return visitor.visitCommentTable(self)
            else:
                return visitor.visitChildren(self)


    class CreateNamespaceContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CREATE(self):
            return self.getToken(fugue_sqlParser.CREATE, 0)
        def theNamespace(self):
            return self.getTypedRuleContext(fugue_sqlParser.TheNamespaceContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def commentSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.CommentSpecContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,i)

        def locationSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.LocationSpecContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.LocationSpecContext,i)

        def WITH(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.WITH)
            else:
                return self.getToken(fugue_sqlParser.WITH, i)
        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,i)

        def DBPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.DBPROPERTIES)
            else:
                return self.getToken(fugue_sqlParser.DBPROPERTIES, i)
        def PROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.PROPERTIES)
            else:
                return self.getToken(fugue_sqlParser.PROPERTIES, i)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateNamespace" ):
                return visitor.visitCreateNamespace(self)
            else:
                return visitor.visitChildren(self)


    class ShowTblPropertiesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.table = None # MultipartIdentifierContext
            self.key = None # TablePropertyKeyContext
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(fugue_sqlParser.SHOW, 0)
        def TBLPROPERTIES(self):
            return self.getToken(fugue_sqlParser.TBLPROPERTIES, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def tablePropertyKey(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyKeyContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowTblProperties" ):
                return visitor.visitShowTblProperties(self)
            else:
                return visitor.visitChildren(self)


    class UnsetTablePropertiesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def UNSET(self):
            return self.getToken(fugue_sqlParser.UNSET, 0)
        def TBLPROPERTIES(self):
            return self.getToken(fugue_sqlParser.TBLPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,0)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)
        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnsetTableProperties" ):
                return visitor.visitUnsetTableProperties(self)
            else:
                return visitor.visitChildren(self)


    class SetTableLocationContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)
        def locationSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.LocationSpecContext,0)

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetTableLocation" ):
                return visitor.visitSetTableLocation(self)
            else:
                return visitor.visitChildren(self)


    class DropTableColumnsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.columns = None # MultipartIdentifierListContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def DROP(self):
            return self.getToken(fugue_sqlParser.DROP, 0)
        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def COLUMNS(self):
            return self.getToken(fugue_sqlParser.COLUMNS, 0)
        def multipartIdentifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierListContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDropTableColumns" ):
                return visitor.visitDropTableColumns(self)
            else:
                return visitor.visitChildren(self)


    class ShowViewsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(fugue_sqlParser.SHOW, 0)
        def VIEWS(self):
            return self.getToken(fugue_sqlParser.VIEWS, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowViews" ):
                return visitor.visitShowViews(self)
            else:
                return visitor.visitChildren(self)


    class ShowFunctionsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.pattern = None # Token
            self.copyFrom(ctx)

        def SHOW(self):
            return self.getToken(fugue_sqlParser.SHOW, 0)
        def FUNCTIONS(self):
            return self.getToken(fugue_sqlParser.FUNCTIONS, 0)
        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShowFunctions" ):
                return visitor.visitShowFunctions(self)
            else:
                return visitor.visitChildren(self)


    class CacheTableContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.options = None # TablePropertyListContext
            self.copyFrom(ctx)

        def CACHE(self):
            return self.getToken(fugue_sqlParser.CACHE, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def LAZY(self):
            return self.getToken(fugue_sqlParser.LAZY, 0)
        def OPTIONS(self):
            return self.getToken(fugue_sqlParser.OPTIONS, 0)
        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)

        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCacheTable" ):
                return visitor.visitCacheTable(self)
            else:
                return visitor.visitChildren(self)


    class AddTableColumnsContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.columns = None # QualifiedColTypeWithPositionListContext
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def ADD(self):
            return self.getToken(fugue_sqlParser.ADD, 0)
        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)
        def COLUMNS(self):
            return self.getToken(fugue_sqlParser.COLUMNS, 0)
        def qualifiedColTypeWithPositionList(self):
            return self.getTypedRuleContext(fugue_sqlParser.QualifiedColTypeWithPositionListContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAddTableColumns" ):
                return visitor.visitAddTableColumns(self)
            else:
                return visitor.visitChildren(self)


    class SetTablePropertiesContext(StatementContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StatementContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)
        def TBLPROPERTIES(self):
            return self.getToken(fugue_sqlParser.TBLPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,0)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetTableProperties" ):
                return visitor.visitSetTableProperties(self)
            else:
                return visitor.visitChildren(self)



    def statement(self):

        localctx = fugue_sqlParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 1877
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,237,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.StatementDefaultContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1172
                self.query()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.DmlStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1174
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==308:
                    self.state = 1173
                    self.ctes()


                self.state = 1176
                self.dmlStatementNoWith()
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.UseContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1177
                self.match(fugue_sqlParser.USE)
                self.state = 1179
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
                if la_ == 1:
                    self.state = 1178
                    self.match(fugue_sqlParser.NAMESPACE)


                self.state = 1181
                self.multipartIdentifier()
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.CreateNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1182
                self.match(fugue_sqlParser.CREATE)
                self.state = 1183
                self.theNamespace()
                self.state = 1187
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
                if la_ == 1:
                    self.state = 1184
                    self.match(fugue_sqlParser.IF)
                    self.state = 1185
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1186
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1189
                self.multipartIdentifier()
                self.state = 1197
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==91 or _la==184 or _la==308:
                    self.state = 1195
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [91]:
                        self.state = 1190
                        self.commentSpec()
                        pass
                    elif token in [184]:
                        self.state = 1191
                        self.locationSpec()
                        pass
                    elif token in [308]:
                        self.state = 1192
                        self.match(fugue_sqlParser.WITH)
                        self.state = 1193
                        _la = self._input.LA(1)
                        if not(_la==111 or _la==226):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1194
                        self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 1199
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.SetNamespacePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1200
                self.match(fugue_sqlParser.ALTER)
                self.state = 1201
                self.theNamespace()
                self.state = 1202
                self.multipartIdentifier()
                self.state = 1203
                self.match(fugue_sqlParser.SET)
                self.state = 1204
                _la = self._input.LA(1)
                if not(_la==111 or _la==226):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1205
                self.tablePropertyList()
                pass

            elif la_ == 6:
                localctx = fugue_sqlParser.SetNamespaceLocationContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 1207
                self.match(fugue_sqlParser.ALTER)
                self.state = 1208
                self.theNamespace()
                self.state = 1209
                self.multipartIdentifier()
                self.state = 1210
                self.match(fugue_sqlParser.SET)
                self.state = 1211
                self.locationSpec()
                pass

            elif la_ == 7:
                localctx = fugue_sqlParser.DropNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 1213
                self.match(fugue_sqlParser.DROP)
                self.state = 1214
                self.theNamespace()
                self.state = 1217
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
                if la_ == 1:
                    self.state = 1215
                    self.match(fugue_sqlParser.IF)
                    self.state = 1216
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1219
                self.multipartIdentifier()
                self.state = 1221
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==78 or _la==240:
                    self.state = 1220
                    _la = self._input.LA(1)
                    if not(_la==78 or _la==240):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                pass

            elif la_ == 8:
                localctx = fugue_sqlParser.ShowNamespacesContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 1223
                self.match(fugue_sqlParser.SHOW)
                self.state = 1224
                _la = self._input.LA(1)
                if not(_la==109 or _la==196):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1227
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==146 or _la==159:
                    self.state = 1225
                    _la = self._input.LA(1)
                    if not(_la==146 or _la==159):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1226
                    self.multipartIdentifier()


                self.state = 1233
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==178 or _la==330:
                    self.state = 1230
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==178:
                        self.state = 1229
                        self.match(fugue_sqlParser.LIKE)


                    self.state = 1232
                    localctx.pattern = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 9:
                localctx = fugue_sqlParser.CreateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 1235
                self.createTableHeader()
                self.state = 1240
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 1236
                    self.match(fugue_sqlParser.T__4)
                    self.state = 1237
                    self.colTypeList()
                    self.state = 1238
                    self.match(fugue_sqlParser.T__5)


                self.state = 1242
                self.tableProvider()
                self.state = 1243
                self.createTableClauses()
                self.state = 1248
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & 2269395221545987) != 0 or (((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 140737496743937) != 0 or (((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & 20266198323167361) != 0 or (((_la - 252)) & ~0x3f) == 0 and ((1 << (_la - 252)) & 73183502536802305) != 0:
                    self.state = 1245
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==68:
                        self.state = 1244
                        self.match(fugue_sqlParser.AS)


                    self.state = 1247
                    self.query()


                pass

            elif la_ == 10:
                localctx = fugue_sqlParser.CreateHiveTableContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 1250
                self.createTableHeader()
                self.state = 1255
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 1251
                    self.match(fugue_sqlParser.T__4)
                    self.state = 1252
                    localctx.columns = self.colTypeList()
                    self.state = 1253
                    self.match(fugue_sqlParser.T__5)


                self.state = 1278
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==85 or _la==91 or _la==184 or _la==217 or (((_la - 248)) & ~0x3f) == 0 and ((1 << (_la - 248)) & 269500417) != 0:
                    self.state = 1276
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [91]:
                        self.state = 1257
                        self.commentSpec()
                        pass
                    elif token in [217]:
                        self.state = 1267
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
                        if la_ == 1:
                            self.state = 1258
                            self.match(fugue_sqlParser.PARTITIONED)
                            self.state = 1259
                            self.match(fugue_sqlParser.BY)
                            self.state = 1260
                            self.match(fugue_sqlParser.T__4)
                            self.state = 1261
                            localctx.partitionColumns = self.colTypeList()
                            self.state = 1262
                            self.match(fugue_sqlParser.T__5)
                            pass

                        elif la_ == 2:
                            self.state = 1264
                            self.match(fugue_sqlParser.PARTITIONED)
                            self.state = 1265
                            self.match(fugue_sqlParser.BY)
                            self.state = 1266
                            localctx.partitionColumnNames = self.identifierList()
                            pass


                        pass
                    elif token in [85]:
                        self.state = 1269
                        self.bucketSpec()
                        pass
                    elif token in [262]:
                        self.state = 1270
                        self.skewSpec()
                        pass
                    elif token in [248]:
                        self.state = 1271
                        self.rowFormat()
                        pass
                    elif token in [268]:
                        self.state = 1272
                        self.createFileFormat()
                        pass
                    elif token in [184]:
                        self.state = 1273
                        self.locationSpec()
                        pass
                    elif token in [276]:
                        self.state = 1274
                        self.match(fugue_sqlParser.TBLPROPERTIES)
                        self.state = 1275
                        localctx.tableProps = self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 1280
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1285
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & 2269395221545987) != 0 or (((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 140737496743937) != 0 or (((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & 20266198323167361) != 0 or (((_la - 252)) & ~0x3f) == 0 and ((1 << (_la - 252)) & 73183502536802305) != 0:
                    self.state = 1282
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==68:
                        self.state = 1281
                        self.match(fugue_sqlParser.AS)


                    self.state = 1284
                    self.query()


                pass

            elif la_ == 11:
                localctx = fugue_sqlParser.CreateTableLikeContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 1287
                self.match(fugue_sqlParser.CREATE)
                self.state = 1288
                self.match(fugue_sqlParser.TABLE)
                self.state = 1292
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,151,self._ctx)
                if la_ == 1:
                    self.state = 1289
                    self.match(fugue_sqlParser.IF)
                    self.state = 1290
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1291
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1294
                localctx.target = self.tableIdentifier()
                self.state = 1295
                self.match(fugue_sqlParser.LIKE)
                self.state = 1296
                localctx.source = self.tableIdentifier()
                self.state = 1305
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==184 or (((_la - 248)) & ~0x3f) == 0 and ((1 << (_la - 248)) & 9007199524225025) != 0:
                    self.state = 1303
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [301]:
                        self.state = 1297
                        self.tableProvider()
                        pass
                    elif token in [248]:
                        self.state = 1298
                        self.rowFormat()
                        pass
                    elif token in [268]:
                        self.state = 1299
                        self.createFileFormat()
                        pass
                    elif token in [184]:
                        self.state = 1300
                        self.locationSpec()
                        pass
                    elif token in [276]:
                        self.state = 1301
                        self.match(fugue_sqlParser.TBLPROPERTIES)
                        self.state = 1302
                        localctx.tableProps = self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 1307
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 12:
                localctx = fugue_sqlParser.ReplaceTableContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 1308
                self.replaceTableHeader()
                self.state = 1313
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 1309
                    self.match(fugue_sqlParser.T__4)
                    self.state = 1310
                    self.colTypeList()
                    self.state = 1311
                    self.match(fugue_sqlParser.T__5)


                self.state = 1315
                self.tableProvider()
                self.state = 1316
                self.createTableClauses()
                self.state = 1321
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & 2269395221545987) != 0 or (((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 140737496743937) != 0 or (((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & 20266198323167361) != 0 or (((_la - 252)) & ~0x3f) == 0 and ((1 << (_la - 252)) & 73183502536802305) != 0:
                    self.state = 1318
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==68:
                        self.state = 1317
                        self.match(fugue_sqlParser.AS)


                    self.state = 1320
                    self.query()


                pass

            elif la_ == 13:
                localctx = fugue_sqlParser.AnalyzeContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 1323
                self.match(fugue_sqlParser.ANALYZE)
                self.state = 1324
                self.match(fugue_sqlParser.TABLE)
                self.state = 1325
                self.multipartIdentifier()
                self.state = 1327
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1326
                    self.partitionSpec()


                self.state = 1329
                self.match(fugue_sqlParser.COMPUTE)
                self.state = 1330
                self.match(fugue_sqlParser.STATISTICS)
                self.state = 1338
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
                if la_ == 1:
                    self.state = 1331
                    self.identifier()

                elif la_ == 2:
                    self.state = 1332
                    self.match(fugue_sqlParser.FOR)
                    self.state = 1333
                    self.match(fugue_sqlParser.COLUMNS)
                    self.state = 1334
                    self.identifierSeq()

                elif la_ == 3:
                    self.state = 1335
                    self.match(fugue_sqlParser.FOR)
                    self.state = 1336
                    self.match(fugue_sqlParser.ALL)
                    self.state = 1337
                    self.match(fugue_sqlParser.COLUMNS)


                pass

            elif la_ == 14:
                localctx = fugue_sqlParser.AddTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 1340
                self.match(fugue_sqlParser.ALTER)
                self.state = 1341
                self.match(fugue_sqlParser.TABLE)
                self.state = 1342
                self.multipartIdentifier()
                self.state = 1343
                self.match(fugue_sqlParser.ADD)
                self.state = 1344
                _la = self._input.LA(1)
                if not(_la==89 or _la==90):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1345
                localctx.columns = self.qualifiedColTypeWithPositionList()
                pass

            elif la_ == 15:
                localctx = fugue_sqlParser.AddTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 1347
                self.match(fugue_sqlParser.ALTER)
                self.state = 1348
                self.match(fugue_sqlParser.TABLE)
                self.state = 1349
                self.multipartIdentifier()
                self.state = 1350
                self.match(fugue_sqlParser.ADD)
                self.state = 1351
                _la = self._input.LA(1)
                if not(_la==89 or _la==90):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1352
                self.match(fugue_sqlParser.T__4)
                self.state = 1353
                localctx.columns = self.qualifiedColTypeWithPositionList()
                self.state = 1354
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 16:
                localctx = fugue_sqlParser.RenameTableColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 1356
                self.match(fugue_sqlParser.ALTER)
                self.state = 1357
                self.match(fugue_sqlParser.TABLE)
                self.state = 1358
                localctx.table = self.multipartIdentifier()
                self.state = 1359
                self.match(fugue_sqlParser.RENAME)
                self.state = 1360
                self.match(fugue_sqlParser.COLUMN)
                self.state = 1361
                localctx.ifrom = self.multipartIdentifier()
                self.state = 1362
                self.match(fugue_sqlParser.TO)
                self.state = 1363
                localctx.to = self.errorCapturingIdentifier()
                pass

            elif la_ == 17:
                localctx = fugue_sqlParser.DropTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 1365
                self.match(fugue_sqlParser.ALTER)
                self.state = 1366
                self.match(fugue_sqlParser.TABLE)
                self.state = 1367
                self.multipartIdentifier()
                self.state = 1368
                self.match(fugue_sqlParser.DROP)
                self.state = 1369
                _la = self._input.LA(1)
                if not(_la==89 or _la==90):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1370
                self.match(fugue_sqlParser.T__4)
                self.state = 1371
                localctx.columns = self.multipartIdentifierList()
                self.state = 1372
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 18:
                localctx = fugue_sqlParser.DropTableColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 1374
                self.match(fugue_sqlParser.ALTER)
                self.state = 1375
                self.match(fugue_sqlParser.TABLE)
                self.state = 1376
                self.multipartIdentifier()
                self.state = 1377
                self.match(fugue_sqlParser.DROP)
                self.state = 1378
                _la = self._input.LA(1)
                if not(_la==89 or _la==90):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1379
                localctx.columns = self.multipartIdentifierList()
                pass

            elif la_ == 19:
                localctx = fugue_sqlParser.RenameTableContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 1381
                self.match(fugue_sqlParser.ALTER)
                self.state = 1382
                _la = self._input.LA(1)
                if not(_la==273 or _la==303):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1383
                localctx.ifrom = self.multipartIdentifier()
                self.state = 1384
                self.match(fugue_sqlParser.RENAME)
                self.state = 1385
                self.match(fugue_sqlParser.TO)
                self.state = 1386
                localctx.to = self.multipartIdentifier()
                pass

            elif la_ == 20:
                localctx = fugue_sqlParser.SetTablePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 1388
                self.match(fugue_sqlParser.ALTER)
                self.state = 1389
                _la = self._input.LA(1)
                if not(_la==273 or _la==303):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1390
                self.multipartIdentifier()
                self.state = 1391
                self.match(fugue_sqlParser.SET)
                self.state = 1392
                self.match(fugue_sqlParser.TBLPROPERTIES)
                self.state = 1393
                self.tablePropertyList()
                pass

            elif la_ == 21:
                localctx = fugue_sqlParser.UnsetTablePropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 1395
                self.match(fugue_sqlParser.ALTER)
                self.state = 1396
                _la = self._input.LA(1)
                if not(_la==273 or _la==303):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1397
                self.multipartIdentifier()
                self.state = 1398
                self.match(fugue_sqlParser.UNSET)
                self.state = 1399
                self.match(fugue_sqlParser.TBLPROPERTIES)
                self.state = 1402
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==156:
                    self.state = 1400
                    self.match(fugue_sqlParser.IF)
                    self.state = 1401
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1404
                self.tablePropertyList()
                pass

            elif la_ == 22:
                localctx = fugue_sqlParser.AlterTableAlterColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 22)
                self.state = 1406
                self.match(fugue_sqlParser.ALTER)
                self.state = 1407
                self.match(fugue_sqlParser.TABLE)
                self.state = 1408
                localctx.table = self.multipartIdentifier()
                self.state = 1409
                _la = self._input.LA(1)
                if not(_la==61 or _la==81):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1411
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
                if la_ == 1:
                    self.state = 1410
                    self.match(fugue_sqlParser.COLUMN)


                self.state = 1413
                localctx.column = self.multipartIdentifier()
                self.state = 1415
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59 or (((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 562952100904961) != 0 or _la==258 or _la==289:
                    self.state = 1414
                    self.alterColumnAction()


                pass

            elif la_ == 23:
                localctx = fugue_sqlParser.HiveChangeColumnContext(self, localctx)
                self.enterOuterAlt(localctx, 23)
                self.state = 1417
                self.match(fugue_sqlParser.ALTER)
                self.state = 1418
                self.match(fugue_sqlParser.TABLE)
                self.state = 1419
                localctx.table = self.multipartIdentifier()
                self.state = 1421
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1420
                    self.partitionSpec()


                self.state = 1423
                self.match(fugue_sqlParser.CHANGE)
                self.state = 1425
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,163,self._ctx)
                if la_ == 1:
                    self.state = 1424
                    self.match(fugue_sqlParser.COLUMN)


                self.state = 1427
                localctx.colName = self.multipartIdentifier()
                self.state = 1428
                self.colType()
                self.state = 1430
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59 or _la==140:
                    self.state = 1429
                    self.colPosition()


                pass

            elif la_ == 24:
                localctx = fugue_sqlParser.HiveReplaceColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 24)
                self.state = 1432
                self.match(fugue_sqlParser.ALTER)
                self.state = 1433
                self.match(fugue_sqlParser.TABLE)
                self.state = 1434
                localctx.table = self.multipartIdentifier()
                self.state = 1436
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1435
                    self.partitionSpec()


                self.state = 1438
                self.match(fugue_sqlParser.REPLACE)
                self.state = 1439
                self.match(fugue_sqlParser.COLUMNS)
                self.state = 1440
                self.match(fugue_sqlParser.T__4)
                self.state = 1441
                localctx.columns = self.qualifiedColTypeWithPositionList()
                self.state = 1442
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 25:
                localctx = fugue_sqlParser.SetTableSerDeContext(self, localctx)
                self.enterOuterAlt(localctx, 25)
                self.state = 1444
                self.match(fugue_sqlParser.ALTER)
                self.state = 1445
                self.match(fugue_sqlParser.TABLE)
                self.state = 1446
                self.multipartIdentifier()
                self.state = 1448
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1447
                    self.partitionSpec()


                self.state = 1450
                self.match(fugue_sqlParser.SET)
                self.state = 1451
                self.match(fugue_sqlParser.SERDE)
                self.state = 1452
                self.match(fugue_sqlParser.STRING)
                self.state = 1456
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==308:
                    self.state = 1453
                    self.match(fugue_sqlParser.WITH)
                    self.state = 1454
                    self.match(fugue_sqlParser.SERDEPROPERTIES)
                    self.state = 1455
                    self.tablePropertyList()


                pass

            elif la_ == 26:
                localctx = fugue_sqlParser.SetTableSerDeContext(self, localctx)
                self.enterOuterAlt(localctx, 26)
                self.state = 1458
                self.match(fugue_sqlParser.ALTER)
                self.state = 1459
                self.match(fugue_sqlParser.TABLE)
                self.state = 1460
                self.multipartIdentifier()
                self.state = 1462
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1461
                    self.partitionSpec()


                self.state = 1464
                self.match(fugue_sqlParser.SET)
                self.state = 1465
                self.match(fugue_sqlParser.SERDEPROPERTIES)
                self.state = 1466
                self.tablePropertyList()
                pass

            elif la_ == 27:
                localctx = fugue_sqlParser.AddTablePartitionContext(self, localctx)
                self.enterOuterAlt(localctx, 27)
                self.state = 1468
                self.match(fugue_sqlParser.ALTER)
                self.state = 1469
                _la = self._input.LA(1)
                if not(_la==273 or _la==303):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1470
                self.multipartIdentifier()
                self.state = 1471
                self.match(fugue_sqlParser.ADD)
                self.state = 1475
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==156:
                    self.state = 1472
                    self.match(fugue_sqlParser.IF)
                    self.state = 1473
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1474
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1478 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1477
                    self.partitionSpecLocation()
                    self.state = 1480 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==216):
                        break

                pass

            elif la_ == 28:
                localctx = fugue_sqlParser.RenameTablePartitionContext(self, localctx)
                self.enterOuterAlt(localctx, 28)
                self.state = 1482
                self.match(fugue_sqlParser.ALTER)
                self.state = 1483
                self.match(fugue_sqlParser.TABLE)
                self.state = 1484
                self.multipartIdentifier()
                self.state = 1485
                localctx.ifrom = self.partitionSpec()
                self.state = 1486
                self.match(fugue_sqlParser.RENAME)
                self.state = 1487
                self.match(fugue_sqlParser.TO)
                self.state = 1488
                localctx.to = self.partitionSpec()
                pass

            elif la_ == 29:
                localctx = fugue_sqlParser.DropTablePartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 29)
                self.state = 1490
                self.match(fugue_sqlParser.ALTER)
                self.state = 1491
                _la = self._input.LA(1)
                if not(_la==273 or _la==303):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1492
                self.multipartIdentifier()
                self.state = 1493
                self.match(fugue_sqlParser.DROP)
                self.state = 1496
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==156:
                    self.state = 1494
                    self.match(fugue_sqlParser.IF)
                    self.state = 1495
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1498
                self.partitionSpec()
                self.state = 1503
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1499
                    self.match(fugue_sqlParser.T__1)
                    self.state = 1500
                    self.partitionSpec()
                    self.state = 1505
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1507
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1506
                    self.match(fugue_sqlParser.PURGE)


                pass

            elif la_ == 30:
                localctx = fugue_sqlParser.SetTableLocationContext(self, localctx)
                self.enterOuterAlt(localctx, 30)
                self.state = 1509
                self.match(fugue_sqlParser.ALTER)
                self.state = 1510
                self.match(fugue_sqlParser.TABLE)
                self.state = 1511
                self.multipartIdentifier()
                self.state = 1513
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1512
                    self.partitionSpec()


                self.state = 1515
                self.match(fugue_sqlParser.SET)
                self.state = 1516
                self.locationSpec()
                pass

            elif la_ == 31:
                localctx = fugue_sqlParser.RecoverPartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 31)
                self.state = 1518
                self.match(fugue_sqlParser.ALTER)
                self.state = 1519
                self.match(fugue_sqlParser.TABLE)
                self.state = 1520
                self.multipartIdentifier()
                self.state = 1521
                self.match(fugue_sqlParser.RECOVER)
                self.state = 1522
                self.match(fugue_sqlParser.PARTITIONS)
                pass

            elif la_ == 32:
                localctx = fugue_sqlParser.DropTableContext(self, localctx)
                self.enterOuterAlt(localctx, 32)
                self.state = 1524
                self.match(fugue_sqlParser.DROP)
                self.state = 1525
                self.match(fugue_sqlParser.TABLE)
                self.state = 1528
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
                if la_ == 1:
                    self.state = 1526
                    self.match(fugue_sqlParser.IF)
                    self.state = 1527
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1530
                self.multipartIdentifier()
                self.state = 1532
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1531
                    self.match(fugue_sqlParser.PURGE)


                pass

            elif la_ == 33:
                localctx = fugue_sqlParser.DropViewContext(self, localctx)
                self.enterOuterAlt(localctx, 33)
                self.state = 1534
                self.match(fugue_sqlParser.DROP)
                self.state = 1535
                self.match(fugue_sqlParser.VIEW)
                self.state = 1538
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,177,self._ctx)
                if la_ == 1:
                    self.state = 1536
                    self.match(fugue_sqlParser.IF)
                    self.state = 1537
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1540
                self.multipartIdentifier()
                pass

            elif la_ == 34:
                localctx = fugue_sqlParser.CreateViewContext(self, localctx)
                self.enterOuterAlt(localctx, 34)
                self.state = 1541
                self.match(fugue_sqlParser.CREATE)
                self.state = 1544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==207:
                    self.state = 1542
                    self.match(fugue_sqlParser.OR)
                    self.state = 1543
                    self.match(fugue_sqlParser.REPLACE)


                self.state = 1550
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==150 or _la==277:
                    self.state = 1547
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==150:
                        self.state = 1546
                        self.match(fugue_sqlParser.GLOBAL)


                    self.state = 1549
                    self.match(fugue_sqlParser.TEMPORARY)


                self.state = 1552
                self.match(fugue_sqlParser.VIEW)
                self.state = 1556
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
                if la_ == 1:
                    self.state = 1553
                    self.match(fugue_sqlParser.IF)
                    self.state = 1554
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1555
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1558
                self.multipartIdentifier()
                self.state = 1560
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 1559
                    self.identifierCommentList()


                self.state = 1570
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==91 or _la==217 or _la==276:
                    self.state = 1568
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [91]:
                        self.state = 1562
                        self.commentSpec()
                        pass
                    elif token in [217]:
                        self.state = 1563
                        self.match(fugue_sqlParser.PARTITIONED)
                        self.state = 1564
                        self.match(fugue_sqlParser.ON)
                        self.state = 1565
                        self.identifierList()
                        pass
                    elif token in [276]:
                        self.state = 1566
                        self.match(fugue_sqlParser.TBLPROPERTIES)
                        self.state = 1567
                        self.tablePropertyList()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 1572
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1573
                self.match(fugue_sqlParser.AS)
                self.state = 1574
                self.query()
                pass

            elif la_ == 35:
                localctx = fugue_sqlParser.CreateTempViewUsingContext(self, localctx)
                self.enterOuterAlt(localctx, 35)
                self.state = 1576
                self.match(fugue_sqlParser.CREATE)
                self.state = 1579
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==207:
                    self.state = 1577
                    self.match(fugue_sqlParser.OR)
                    self.state = 1578
                    self.match(fugue_sqlParser.REPLACE)


                self.state = 1582
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==150:
                    self.state = 1581
                    self.match(fugue_sqlParser.GLOBAL)


                self.state = 1584
                self.match(fugue_sqlParser.TEMPORARY)
                self.state = 1585
                self.match(fugue_sqlParser.VIEW)
                self.state = 1586
                self.tableIdentifier()
                self.state = 1591
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 1587
                    self.match(fugue_sqlParser.T__4)
                    self.state = 1588
                    self.colTypeList()
                    self.state = 1589
                    self.match(fugue_sqlParser.T__5)


                self.state = 1593
                self.tableProvider()
                self.state = 1596
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==206:
                    self.state = 1594
                    self.match(fugue_sqlParser.OPTIONS)
                    self.state = 1595
                    self.tablePropertyList()


                pass

            elif la_ == 36:
                localctx = fugue_sqlParser.AlterViewQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 36)
                self.state = 1598
                self.match(fugue_sqlParser.ALTER)
                self.state = 1599
                self.match(fugue_sqlParser.VIEW)
                self.state = 1600
                self.multipartIdentifier()
                self.state = 1602
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==68:
                    self.state = 1601
                    self.match(fugue_sqlParser.AS)


                self.state = 1604
                self.query()
                pass

            elif la_ == 37:
                localctx = fugue_sqlParser.CreateFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 37)
                self.state = 1606
                self.match(fugue_sqlParser.CREATE)
                self.state = 1609
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==207:
                    self.state = 1607
                    self.match(fugue_sqlParser.OR)
                    self.state = 1608
                    self.match(fugue_sqlParser.REPLACE)


                self.state = 1612
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==277:
                    self.state = 1611
                    self.match(fugue_sqlParser.TEMPORARY)


                self.state = 1614
                self.match(fugue_sqlParser.FUNCTION)
                self.state = 1618
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,192,self._ctx)
                if la_ == 1:
                    self.state = 1615
                    self.match(fugue_sqlParser.IF)
                    self.state = 1616
                    self.match(fugue_sqlParser.NOT)
                    self.state = 1617
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1620
                self.multipartIdentifier()
                self.state = 1621
                self.match(fugue_sqlParser.AS)
                self.state = 1622
                localctx.className = self.match(fugue_sqlParser.STRING)
                self.state = 1632
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==301:
                    self.state = 1623
                    self.match(fugue_sqlParser.USING)
                    self.state = 1624
                    self.resource()
                    self.state = 1629
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==2:
                        self.state = 1625
                        self.match(fugue_sqlParser.T__1)
                        self.state = 1626
                        self.resource()
                        self.state = 1631
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                pass

            elif la_ == 38:
                localctx = fugue_sqlParser.DropFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 38)
                self.state = 1634
                self.match(fugue_sqlParser.DROP)
                self.state = 1636
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==277:
                    self.state = 1635
                    self.match(fugue_sqlParser.TEMPORARY)


                self.state = 1638
                self.match(fugue_sqlParser.FUNCTION)
                self.state = 1641
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
                if la_ == 1:
                    self.state = 1639
                    self.match(fugue_sqlParser.IF)
                    self.state = 1640
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1643
                self.multipartIdentifier()
                pass

            elif la_ == 39:
                localctx = fugue_sqlParser.ExplainContext(self, localctx)
                self.enterOuterAlt(localctx, 39)
                self.state = 1644
                self.match(fugue_sqlParser.EXPLAIN)
                self.state = 1646
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & 576531121047605249) != 0 or _la==187:
                    self.state = 1645
                    _la = self._input.LA(1)
                    if not((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & 576531121047605249) != 0 or _la==187):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1648
                self.statement()
                pass

            elif la_ == 40:
                localctx = fugue_sqlParser.ShowTablesContext(self, localctx)
                self.enterOuterAlt(localctx, 40)
                self.state = 1649
                self.match(fugue_sqlParser.SHOW)
                self.state = 1650
                self.match(fugue_sqlParser.TABLES)
                self.state = 1653
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==146 or _la==159:
                    self.state = 1651
                    _la = self._input.LA(1)
                    if not(_la==146 or _la==159):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1652
                    self.multipartIdentifier()


                self.state = 1659
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==178 or _la==330:
                    self.state = 1656
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==178:
                        self.state = 1655
                        self.match(fugue_sqlParser.LIKE)


                    self.state = 1658
                    localctx.pattern = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 41:
                localctx = fugue_sqlParser.ShowTableContext(self, localctx)
                self.enterOuterAlt(localctx, 41)
                self.state = 1661
                self.match(fugue_sqlParser.SHOW)
                self.state = 1662
                self.match(fugue_sqlParser.TABLE)
                self.state = 1663
                self.match(fugue_sqlParser.EXTENDED)
                self.state = 1666
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==146 or _la==159:
                    self.state = 1664
                    _la = self._input.LA(1)
                    if not(_la==146 or _la==159):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1665
                    localctx.ns = self.multipartIdentifier()


                self.state = 1668
                self.match(fugue_sqlParser.LIKE)
                self.state = 1669
                localctx.pattern = self.match(fugue_sqlParser.STRING)
                self.state = 1671
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1670
                    self.partitionSpec()


                pass

            elif la_ == 42:
                localctx = fugue_sqlParser.ShowTblPropertiesContext(self, localctx)
                self.enterOuterAlt(localctx, 42)
                self.state = 1673
                self.match(fugue_sqlParser.SHOW)
                self.state = 1674
                self.match(fugue_sqlParser.TBLPROPERTIES)
                self.state = 1675
                localctx.table = self.multipartIdentifier()
                self.state = 1680
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 1676
                    self.match(fugue_sqlParser.T__4)
                    self.state = 1677
                    localctx.key = self.tablePropertyKey()
                    self.state = 1678
                    self.match(fugue_sqlParser.T__5)


                pass

            elif la_ == 43:
                localctx = fugue_sqlParser.ShowColumnsContext(self, localctx)
                self.enterOuterAlt(localctx, 43)
                self.state = 1682
                self.match(fugue_sqlParser.SHOW)
                self.state = 1683
                self.match(fugue_sqlParser.COLUMNS)
                self.state = 1684
                _la = self._input.LA(1)
                if not(_la==146 or _la==159):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1685
                localctx.table = self.multipartIdentifier()
                self.state = 1688
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==146 or _la==159:
                    self.state = 1686
                    _la = self._input.LA(1)
                    if not(_la==146 or _la==159):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1687
                    localctx.ns = self.multipartIdentifier()


                pass

            elif la_ == 44:
                localctx = fugue_sqlParser.ShowViewsContext(self, localctx)
                self.enterOuterAlt(localctx, 44)
                self.state = 1690
                self.match(fugue_sqlParser.SHOW)
                self.state = 1691
                self.match(fugue_sqlParser.VIEWS)
                self.state = 1694
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==146 or _la==159:
                    self.state = 1692
                    _la = self._input.LA(1)
                    if not(_la==146 or _la==159):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1693
                    self.multipartIdentifier()


                self.state = 1700
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==178 or _la==330:
                    self.state = 1697
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==178:
                        self.state = 1696
                        self.match(fugue_sqlParser.LIKE)


                    self.state = 1699
                    localctx.pattern = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 45:
                localctx = fugue_sqlParser.ShowPartitionsContext(self, localctx)
                self.enterOuterAlt(localctx, 45)
                self.state = 1702
                self.match(fugue_sqlParser.SHOW)
                self.state = 1703
                self.match(fugue_sqlParser.PARTITIONS)
                self.state = 1704
                self.multipartIdentifier()
                self.state = 1706
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1705
                    self.partitionSpec()


                pass

            elif la_ == 46:
                localctx = fugue_sqlParser.ShowFunctionsContext(self, localctx)
                self.enterOuterAlt(localctx, 46)
                self.state = 1708
                self.match(fugue_sqlParser.SHOW)
                self.state = 1710
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
                if la_ == 1:
                    self.state = 1709
                    self.identifier()


                self.state = 1712
                self.match(fugue_sqlParser.FUNCTIONS)
                self.state = 1720
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & -1) != 0 or (((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & -1) != 0 or (((_la - 186)) & ~0x3f) == 0 and ((1 << (_la - 186)) & -1) != 0 or (((_la - 250)) & ~0x3f) == 0 and ((1 << (_la - 250)) & 1152921504606846975) != 0 or (((_la - 324)) & ~0x3f) == 0 and ((1 << (_la - 324)) & 98369) != 0:
                    self.state = 1714
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,210,self._ctx)
                    if la_ == 1:
                        self.state = 1713
                        self.match(fugue_sqlParser.LIKE)


                    self.state = 1718
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                        self.state = 1716
                        self.multipartIdentifier()
                        pass
                    elif token in [330]:
                        self.state = 1717
                        localctx.pattern = self.match(fugue_sqlParser.STRING)
                        pass
                    else:
                        raise NoViableAltException(self)



                pass

            elif la_ == 47:
                localctx = fugue_sqlParser.ShowCreateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 47)
                self.state = 1722
                self.match(fugue_sqlParser.SHOW)
                self.state = 1723
                self.match(fugue_sqlParser.CREATE)
                self.state = 1724
                self.match(fugue_sqlParser.TABLE)
                self.state = 1725
                self.multipartIdentifier()
                self.state = 1728
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==68:
                    self.state = 1726
                    self.match(fugue_sqlParser.AS)
                    self.state = 1727
                    self.match(fugue_sqlParser.SERDE)


                pass

            elif la_ == 48:
                localctx = fugue_sqlParser.ShowCurrentNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 48)
                self.state = 1730
                self.match(fugue_sqlParser.SHOW)
                self.state = 1731
                self.match(fugue_sqlParser.CURRENT)
                self.state = 1732
                self.match(fugue_sqlParser.NAMESPACE)
                pass

            elif la_ == 49:
                localctx = fugue_sqlParser.DescribeFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 49)
                self.state = 1733
                _la = self._input.LA(1)
                if not(_la==115 or _la==116):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1734
                self.match(fugue_sqlParser.FUNCTION)
                self.state = 1736
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,214,self._ctx)
                if la_ == 1:
                    self.state = 1735
                    self.match(fugue_sqlParser.EXTENDED)


                self.state = 1738
                self.describeFuncName()
                pass

            elif la_ == 50:
                localctx = fugue_sqlParser.DescribeNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 50)
                self.state = 1739
                _la = self._input.LA(1)
                if not(_la==115 or _la==116):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1740
                self.theNamespace()
                self.state = 1742
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,215,self._ctx)
                if la_ == 1:
                    self.state = 1741
                    self.match(fugue_sqlParser.EXTENDED)


                self.state = 1744
                self.multipartIdentifier()
                pass

            elif la_ == 51:
                localctx = fugue_sqlParser.DescribeRelationContext(self, localctx)
                self.enterOuterAlt(localctx, 51)
                self.state = 1746
                _la = self._input.LA(1)
                if not(_la==115 or _la==116):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1748
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
                if la_ == 1:
                    self.state = 1747
                    self.match(fugue_sqlParser.TABLE)


                self.state = 1751
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,217,self._ctx)
                if la_ == 1:
                    self.state = 1750
                    localctx.option = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==132 or _la==145):
                        localctx.option = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1753
                self.multipartIdentifier()
                self.state = 1755
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,218,self._ctx)
                if la_ == 1:
                    self.state = 1754
                    self.partitionSpec()


                self.state = 1758
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & -1) != 0 or (((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & -1) != 0 or (((_la - 186)) & ~0x3f) == 0 and ((1 << (_la - 186)) & -1) != 0 or (((_la - 250)) & ~0x3f) == 0 and ((1 << (_la - 250)) & 1152921504606846975) != 0 or (((_la - 324)) & ~0x3f) == 0 and ((1 << (_la - 324)) & 98305) != 0:
                    self.state = 1757
                    self.describeColName()


                pass

            elif la_ == 52:
                localctx = fugue_sqlParser.DescribeQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 52)
                self.state = 1760
                _la = self._input.LA(1)
                if not(_la==115 or _la==116):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1762
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==228:
                    self.state = 1761
                    self.match(fugue_sqlParser.QUERY)


                self.state = 1764
                self.query()
                pass

            elif la_ == 53:
                localctx = fugue_sqlParser.CommentNamespaceContext(self, localctx)
                self.enterOuterAlt(localctx, 53)
                self.state = 1765
                self.match(fugue_sqlParser.COMMENT)
                self.state = 1766
                self.match(fugue_sqlParser.ON)
                self.state = 1767
                self.theNamespace()
                self.state = 1768
                self.multipartIdentifier()
                self.state = 1769
                self.match(fugue_sqlParser.IS)
                self.state = 1770
                localctx.comment = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==200 or _la==330):
                    localctx.comment = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 54:
                localctx = fugue_sqlParser.CommentTableContext(self, localctx)
                self.enterOuterAlt(localctx, 54)
                self.state = 1772
                self.match(fugue_sqlParser.COMMENT)
                self.state = 1773
                self.match(fugue_sqlParser.ON)
                self.state = 1774
                self.match(fugue_sqlParser.TABLE)
                self.state = 1775
                self.multipartIdentifier()
                self.state = 1776
                self.match(fugue_sqlParser.IS)
                self.state = 1777
                localctx.comment = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==200 or _la==330):
                    localctx.comment = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 55:
                localctx = fugue_sqlParser.RefreshTableContext(self, localctx)
                self.enterOuterAlt(localctx, 55)
                self.state = 1779
                self.match(fugue_sqlParser.REFRESH)
                self.state = 1780
                self.match(fugue_sqlParser.TABLE)
                self.state = 1781
                self.multipartIdentifier()
                pass

            elif la_ == 56:
                localctx = fugue_sqlParser.RefreshResourceContext(self, localctx)
                self.enterOuterAlt(localctx, 56)
                self.state = 1782
                self.match(fugue_sqlParser.REFRESH)
                self.state = 1790
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,222,self._ctx)
                if la_ == 1:
                    self.state = 1783
                    self.match(fugue_sqlParser.STRING)
                    pass

                elif la_ == 2:
                    self.state = 1787
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,221,self._ctx)
                    while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1+1:
                            self.state = 1784
                            self.matchWildcard() 
                        self.state = 1789
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,221,self._ctx)

                    pass


                pass

            elif la_ == 57:
                localctx = fugue_sqlParser.CacheTableContext(self, localctx)
                self.enterOuterAlt(localctx, 57)
                self.state = 1792
                self.match(fugue_sqlParser.CACHE)
                self.state = 1794
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==175:
                    self.state = 1793
                    self.match(fugue_sqlParser.LAZY)


                self.state = 1796
                self.match(fugue_sqlParser.TABLE)
                self.state = 1797
                self.multipartIdentifier()
                self.state = 1800
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==206:
                    self.state = 1798
                    self.match(fugue_sqlParser.OPTIONS)
                    self.state = 1799
                    localctx.options = self.tablePropertyList()


                self.state = 1806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & 2269395221545987) != 0 or (((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 140737496743937) != 0 or (((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & 20266198323167361) != 0 or (((_la - 252)) & ~0x3f) == 0 and ((1 << (_la - 252)) & 73183502536802305) != 0:
                    self.state = 1803
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==68:
                        self.state = 1802
                        self.match(fugue_sqlParser.AS)


                    self.state = 1805
                    self.query()


                pass

            elif la_ == 58:
                localctx = fugue_sqlParser.UncacheTableContext(self, localctx)
                self.enterOuterAlt(localctx, 58)
                self.state = 1808
                self.match(fugue_sqlParser.UNCACHE)
                self.state = 1809
                self.match(fugue_sqlParser.TABLE)
                self.state = 1812
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,227,self._ctx)
                if la_ == 1:
                    self.state = 1810
                    self.match(fugue_sqlParser.IF)
                    self.state = 1811
                    self.match(fugue_sqlParser.EXISTS)


                self.state = 1814
                self.multipartIdentifier()
                pass

            elif la_ == 59:
                localctx = fugue_sqlParser.ClearCacheContext(self, localctx)
                self.enterOuterAlt(localctx, 59)
                self.state = 1815
                self.match(fugue_sqlParser.CLEAR)
                self.state = 1816
                self.match(fugue_sqlParser.CACHE)
                pass

            elif la_ == 60:
                localctx = fugue_sqlParser.LoadDataContext(self, localctx)
                self.enterOuterAlt(localctx, 60)
                self.state = 1817
                self.match(fugue_sqlParser.LOAD)
                self.state = 1818
                self.match(fugue_sqlParser.DATA)
                self.state = 1820
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 1819
                    self.match(fugue_sqlParser.LOCAL)


                self.state = 1822
                self.match(fugue_sqlParser.INPATH)
                self.state = 1823
                localctx.path = self.match(fugue_sqlParser.STRING)
                self.state = 1825
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==215:
                    self.state = 1824
                    self.match(fugue_sqlParser.OVERWRITE)


                self.state = 1827
                self.match(fugue_sqlParser.INTO)
                self.state = 1828
                self.match(fugue_sqlParser.TABLE)
                self.state = 1829
                self.multipartIdentifier()
                self.state = 1831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1830
                    self.partitionSpec()


                pass

            elif la_ == 61:
                localctx = fugue_sqlParser.TruncateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 61)
                self.state = 1833
                self.match(fugue_sqlParser.TRUNCATE)
                self.state = 1834
                self.match(fugue_sqlParser.TABLE)
                self.state = 1835
                self.multipartIdentifier()
                self.state = 1837
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 1836
                    self.partitionSpec()


                pass

            elif la_ == 62:
                localctx = fugue_sqlParser.RepairTableContext(self, localctx)
                self.enterOuterAlt(localctx, 62)
                self.state = 1839
                self.match(fugue_sqlParser.MSCK)
                self.state = 1840
                self.match(fugue_sqlParser.REPAIR)
                self.state = 1841
                self.match(fugue_sqlParser.TABLE)
                self.state = 1842
                self.multipartIdentifier()
                pass

            elif la_ == 63:
                localctx = fugue_sqlParser.ManageResourceContext(self, localctx)
                self.enterOuterAlt(localctx, 63)
                self.state = 1843
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==58 or _la==181):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1844
                self.identifier()
                self.state = 1852
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
                if la_ == 1:
                    self.state = 1845
                    self.match(fugue_sqlParser.STRING)
                    pass

                elif la_ == 2:
                    self.state = 1849
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,232,self._ctx)
                    while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1+1:
                            self.state = 1846
                            self.matchWildcard() 
                        self.state = 1851
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,232,self._ctx)

                    pass


                pass

            elif la_ == 64:
                localctx = fugue_sqlParser.FailNativeCommandContext(self, localctx)
                self.enterOuterAlt(localctx, 64)
                self.state = 1854
                self.match(fugue_sqlParser.SET)
                self.state = 1855
                self.match(fugue_sqlParser.ROLE)
                self.state = 1859
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,234,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 1856
                        self.matchWildcard() 
                    self.state = 1861
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,234,self._ctx)

                pass

            elif la_ == 65:
                localctx = fugue_sqlParser.SetConfigurationContext(self, localctx)
                self.enterOuterAlt(localctx, 65)
                self.state = 1862
                self.match(fugue_sqlParser.SET)
                self.state = 1866
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,235,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 1863
                        self.matchWildcard() 
                    self.state = 1868
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,235,self._ctx)

                pass

            elif la_ == 66:
                localctx = fugue_sqlParser.ResetConfigurationContext(self, localctx)
                self.enterOuterAlt(localctx, 66)
                self.state = 1869
                self.match(fugue_sqlParser.RESET)
                pass

            elif la_ == 67:
                localctx = fugue_sqlParser.FailNativeCommandContext(self, localctx)
                self.enterOuterAlt(localctx, 67)
                self.state = 1870
                self.unsupportedHiveNativeCommands()
                self.state = 1874
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,236,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 1871
                        self.matchWildcard() 
                    self.state = 1876
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,236,self._ctx)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnsupportedHiveNativeCommandsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.kw1 = None # Token
            self.kw2 = None # Token
            self.kw3 = None # Token
            self.kw4 = None # Token
            self.kw5 = None # Token
            self.kw6 = None # Token

        def CREATE(self):
            return self.getToken(fugue_sqlParser.CREATE, 0)

        def ROLE(self):
            return self.getToken(fugue_sqlParser.ROLE, 0)

        def DROP(self):
            return self.getToken(fugue_sqlParser.DROP, 0)

        def GRANT(self):
            return self.getToken(fugue_sqlParser.GRANT, 0)

        def REVOKE(self):
            return self.getToken(fugue_sqlParser.REVOKE, 0)

        def SHOW(self):
            return self.getToken(fugue_sqlParser.SHOW, 0)

        def PRINCIPALS(self):
            return self.getToken(fugue_sqlParser.PRINCIPALS, 0)

        def ROLES(self):
            return self.getToken(fugue_sqlParser.ROLES, 0)

        def CURRENT(self):
            return self.getToken(fugue_sqlParser.CURRENT, 0)

        def EXPORT(self):
            return self.getToken(fugue_sqlParser.EXPORT, 0)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)

        def IMPORT(self):
            return self.getToken(fugue_sqlParser.IMPORT, 0)

        def COMPACTIONS(self):
            return self.getToken(fugue_sqlParser.COMPACTIONS, 0)

        def TRANSACTIONS(self):
            return self.getToken(fugue_sqlParser.TRANSACTIONS, 0)

        def INDEXES(self):
            return self.getToken(fugue_sqlParser.INDEXES, 0)

        def LOCKS(self):
            return self.getToken(fugue_sqlParser.LOCKS, 0)

        def INDEX(self):
            return self.getToken(fugue_sqlParser.INDEX, 0)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)

        def LOCK(self):
            return self.getToken(fugue_sqlParser.LOCK, 0)

        def DATABASE(self):
            return self.getToken(fugue_sqlParser.DATABASE, 0)

        def UNLOCK(self):
            return self.getToken(fugue_sqlParser.UNLOCK, 0)

        def TEMPORARY(self):
            return self.getToken(fugue_sqlParser.TEMPORARY, 0)

        def MACRO(self):
            return self.getToken(fugue_sqlParser.MACRO, 0)

        def tableIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableIdentifierContext,0)


        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def CLUSTERED(self):
            return self.getToken(fugue_sqlParser.CLUSTERED, 0)

        def BY(self):
            return self.getToken(fugue_sqlParser.BY, 0)

        def SORTED(self):
            return self.getToken(fugue_sqlParser.SORTED, 0)

        def SKEWED(self):
            return self.getToken(fugue_sqlParser.SKEWED, 0)

        def STORED(self):
            return self.getToken(fugue_sqlParser.STORED, 0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def DIRECTORIES(self):
            return self.getToken(fugue_sqlParser.DIRECTORIES, 0)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)

        def LOCATION(self):
            return self.getToken(fugue_sqlParser.LOCATION, 0)

        def EXCHANGE(self):
            return self.getToken(fugue_sqlParser.EXCHANGE, 0)

        def PARTITION(self):
            return self.getToken(fugue_sqlParser.PARTITION, 0)

        def ARCHIVE(self):
            return self.getToken(fugue_sqlParser.ARCHIVE, 0)

        def UNARCHIVE(self):
            return self.getToken(fugue_sqlParser.UNARCHIVE, 0)

        def TOUCH(self):
            return self.getToken(fugue_sqlParser.TOUCH, 0)

        def COMPACT(self):
            return self.getToken(fugue_sqlParser.COMPACT, 0)

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,0)


        def CONCATENATE(self):
            return self.getToken(fugue_sqlParser.CONCATENATE, 0)

        def FILEFORMAT(self):
            return self.getToken(fugue_sqlParser.FILEFORMAT, 0)

        def REPLACE(self):
            return self.getToken(fugue_sqlParser.REPLACE, 0)

        def COLUMNS(self):
            return self.getToken(fugue_sqlParser.COLUMNS, 0)

        def START(self):
            return self.getToken(fugue_sqlParser.START, 0)

        def TRANSACTION(self):
            return self.getToken(fugue_sqlParser.TRANSACTION, 0)

        def COMMIT(self):
            return self.getToken(fugue_sqlParser.COMMIT, 0)

        def ROLLBACK(self):
            return self.getToken(fugue_sqlParser.ROLLBACK, 0)

        def DFS(self):
            return self.getToken(fugue_sqlParser.DFS, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_unsupportedHiveNativeCommands

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnsupportedHiveNativeCommands" ):
                return visitor.visitUnsupportedHiveNativeCommands(self)
            else:
                return visitor.visitChildren(self)




    def unsupportedHiveNativeCommands(self):

        localctx = fugue_sqlParser.UnsupportedHiveNativeCommandsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_unsupportedHiveNativeCommands)
        self._la = 0 # Token type
        try:
            self.state = 2047
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1879
                localctx.kw1 = self.match(fugue_sqlParser.CREATE)
                self.state = 1880
                localctx.kw2 = self.match(fugue_sqlParser.ROLE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1881
                localctx.kw1 = self.match(fugue_sqlParser.DROP)
                self.state = 1882
                localctx.kw2 = self.match(fugue_sqlParser.ROLE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1883
                localctx.kw1 = self.match(fugue_sqlParser.GRANT)
                self.state = 1885
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
                if la_ == 1:
                    self.state = 1884
                    localctx.kw2 = self.match(fugue_sqlParser.ROLE)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1887
                localctx.kw1 = self.match(fugue_sqlParser.REVOKE)
                self.state = 1889
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,239,self._ctx)
                if la_ == 1:
                    self.state = 1888
                    localctx.kw2 = self.match(fugue_sqlParser.ROLE)


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1891
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1892
                localctx.kw2 = self.match(fugue_sqlParser.GRANT)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1893
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1894
                localctx.kw2 = self.match(fugue_sqlParser.ROLE)
                self.state = 1896
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,240,self._ctx)
                if la_ == 1:
                    self.state = 1895
                    localctx.kw3 = self.match(fugue_sqlParser.GRANT)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1898
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1899
                localctx.kw2 = self.match(fugue_sqlParser.PRINCIPALS)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1900
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1901
                localctx.kw2 = self.match(fugue_sqlParser.ROLES)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1902
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1903
                localctx.kw2 = self.match(fugue_sqlParser.CURRENT)
                self.state = 1904
                localctx.kw3 = self.match(fugue_sqlParser.ROLES)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1905
                localctx.kw1 = self.match(fugue_sqlParser.EXPORT)
                self.state = 1906
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1907
                localctx.kw1 = self.match(fugue_sqlParser.IMPORT)
                self.state = 1908
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1909
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1910
                localctx.kw2 = self.match(fugue_sqlParser.COMPACTIONS)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1911
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1912
                localctx.kw2 = self.match(fugue_sqlParser.CREATE)
                self.state = 1913
                localctx.kw3 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1914
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1915
                localctx.kw2 = self.match(fugue_sqlParser.TRANSACTIONS)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1916
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1917
                localctx.kw2 = self.match(fugue_sqlParser.INDEXES)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1918
                localctx.kw1 = self.match(fugue_sqlParser.SHOW)
                self.state = 1919
                localctx.kw2 = self.match(fugue_sqlParser.LOCKS)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1920
                localctx.kw1 = self.match(fugue_sqlParser.CREATE)
                self.state = 1921
                localctx.kw2 = self.match(fugue_sqlParser.INDEX)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1922
                localctx.kw1 = self.match(fugue_sqlParser.DROP)
                self.state = 1923
                localctx.kw2 = self.match(fugue_sqlParser.INDEX)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1924
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1925
                localctx.kw2 = self.match(fugue_sqlParser.INDEX)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 1926
                localctx.kw1 = self.match(fugue_sqlParser.LOCK)
                self.state = 1927
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 1928
                localctx.kw1 = self.match(fugue_sqlParser.LOCK)
                self.state = 1929
                localctx.kw2 = self.match(fugue_sqlParser.DATABASE)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 1930
                localctx.kw1 = self.match(fugue_sqlParser.UNLOCK)
                self.state = 1931
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 1932
                localctx.kw1 = self.match(fugue_sqlParser.UNLOCK)
                self.state = 1933
                localctx.kw2 = self.match(fugue_sqlParser.DATABASE)
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 1934
                localctx.kw1 = self.match(fugue_sqlParser.CREATE)
                self.state = 1935
                localctx.kw2 = self.match(fugue_sqlParser.TEMPORARY)
                self.state = 1936
                localctx.kw3 = self.match(fugue_sqlParser.MACRO)
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 1937
                localctx.kw1 = self.match(fugue_sqlParser.DROP)
                self.state = 1938
                localctx.kw2 = self.match(fugue_sqlParser.TEMPORARY)
                self.state = 1939
                localctx.kw3 = self.match(fugue_sqlParser.MACRO)
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 1940
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1941
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1942
                self.tableIdentifier()
                self.state = 1943
                localctx.kw3 = self.match(fugue_sqlParser.NOT)
                self.state = 1944
                localctx.kw4 = self.match(fugue_sqlParser.CLUSTERED)
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 1946
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1947
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1948
                self.tableIdentifier()
                self.state = 1949
                localctx.kw3 = self.match(fugue_sqlParser.CLUSTERED)
                self.state = 1950
                localctx.kw4 = self.match(fugue_sqlParser.BY)
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 1952
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1953
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1954
                self.tableIdentifier()
                self.state = 1955
                localctx.kw3 = self.match(fugue_sqlParser.NOT)
                self.state = 1956
                localctx.kw4 = self.match(fugue_sqlParser.SORTED)
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 1958
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1959
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1960
                self.tableIdentifier()
                self.state = 1961
                localctx.kw3 = self.match(fugue_sqlParser.SKEWED)
                self.state = 1962
                localctx.kw4 = self.match(fugue_sqlParser.BY)
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 1964
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1965
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1966
                self.tableIdentifier()
                self.state = 1967
                localctx.kw3 = self.match(fugue_sqlParser.NOT)
                self.state = 1968
                localctx.kw4 = self.match(fugue_sqlParser.SKEWED)
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 1970
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1971
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1972
                self.tableIdentifier()
                self.state = 1973
                localctx.kw3 = self.match(fugue_sqlParser.NOT)
                self.state = 1974
                localctx.kw4 = self.match(fugue_sqlParser.STORED)
                self.state = 1975
                localctx.kw5 = self.match(fugue_sqlParser.AS)
                self.state = 1976
                localctx.kw6 = self.match(fugue_sqlParser.DIRECTORIES)
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 1978
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1979
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1980
                self.tableIdentifier()
                self.state = 1981
                localctx.kw3 = self.match(fugue_sqlParser.SET)
                self.state = 1982
                localctx.kw4 = self.match(fugue_sqlParser.SKEWED)
                self.state = 1983
                localctx.kw5 = self.match(fugue_sqlParser.LOCATION)
                pass

            elif la_ == 33:
                self.enterOuterAlt(localctx, 33)
                self.state = 1985
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1986
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1987
                self.tableIdentifier()
                self.state = 1988
                localctx.kw3 = self.match(fugue_sqlParser.EXCHANGE)
                self.state = 1989
                localctx.kw4 = self.match(fugue_sqlParser.PARTITION)
                pass

            elif la_ == 34:
                self.enterOuterAlt(localctx, 34)
                self.state = 1991
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1992
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1993
                self.tableIdentifier()
                self.state = 1994
                localctx.kw3 = self.match(fugue_sqlParser.ARCHIVE)
                self.state = 1995
                localctx.kw4 = self.match(fugue_sqlParser.PARTITION)
                pass

            elif la_ == 35:
                self.enterOuterAlt(localctx, 35)
                self.state = 1997
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 1998
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 1999
                self.tableIdentifier()
                self.state = 2000
                localctx.kw3 = self.match(fugue_sqlParser.UNARCHIVE)
                self.state = 2001
                localctx.kw4 = self.match(fugue_sqlParser.PARTITION)
                pass

            elif la_ == 36:
                self.enterOuterAlt(localctx, 36)
                self.state = 2003
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 2004
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 2005
                self.tableIdentifier()
                self.state = 2006
                localctx.kw3 = self.match(fugue_sqlParser.TOUCH)
                pass

            elif la_ == 37:
                self.enterOuterAlt(localctx, 37)
                self.state = 2008
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 2009
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 2010
                self.tableIdentifier()
                self.state = 2012
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 2011
                    self.partitionSpec()


                self.state = 2014
                localctx.kw3 = self.match(fugue_sqlParser.COMPACT)
                pass

            elif la_ == 38:
                self.enterOuterAlt(localctx, 38)
                self.state = 2016
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 2017
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 2018
                self.tableIdentifier()
                self.state = 2020
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 2019
                    self.partitionSpec()


                self.state = 2022
                localctx.kw3 = self.match(fugue_sqlParser.CONCATENATE)
                pass

            elif la_ == 39:
                self.enterOuterAlt(localctx, 39)
                self.state = 2024
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 2025
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 2026
                self.tableIdentifier()
                self.state = 2028
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 2027
                    self.partitionSpec()


                self.state = 2030
                localctx.kw3 = self.match(fugue_sqlParser.SET)
                self.state = 2031
                localctx.kw4 = self.match(fugue_sqlParser.FILEFORMAT)
                pass

            elif la_ == 40:
                self.enterOuterAlt(localctx, 40)
                self.state = 2033
                localctx.kw1 = self.match(fugue_sqlParser.ALTER)
                self.state = 2034
                localctx.kw2 = self.match(fugue_sqlParser.TABLE)
                self.state = 2035
                self.tableIdentifier()
                self.state = 2037
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 2036
                    self.partitionSpec()


                self.state = 2039
                localctx.kw3 = self.match(fugue_sqlParser.REPLACE)
                self.state = 2040
                localctx.kw4 = self.match(fugue_sqlParser.COLUMNS)
                pass

            elif la_ == 41:
                self.enterOuterAlt(localctx, 41)
                self.state = 2042
                localctx.kw1 = self.match(fugue_sqlParser.START)
                self.state = 2043
                localctx.kw2 = self.match(fugue_sqlParser.TRANSACTION)
                pass

            elif la_ == 42:
                self.enterOuterAlt(localctx, 42)
                self.state = 2044
                localctx.kw1 = self.match(fugue_sqlParser.COMMIT)
                pass

            elif la_ == 43:
                self.enterOuterAlt(localctx, 43)
                self.state = 2045
                localctx.kw1 = self.match(fugue_sqlParser.ROLLBACK)
                pass

            elif la_ == 44:
                self.enterOuterAlt(localctx, 44)
                self.state = 2046
                localctx.kw1 = self.match(fugue_sqlParser.DFS)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateTableHeaderContext(ParserRuleContext):
        __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(fugue_sqlParser.CREATE, 0)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)


        def TEMPORARY(self):
            return self.getToken(fugue_sqlParser.TEMPORARY, 0)

        def EXTERNAL(self):
            return self.getToken(fugue_sqlParser.EXTERNAL, 0)

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)

        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_createTableHeader

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateTableHeader" ):
                return visitor.visitCreateTableHeader(self)
            else:
                return visitor.visitChildren(self)




    def createTableHeader(self):

        localctx = fugue_sqlParser.CreateTableHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_createTableHeader)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2049
            self.match(fugue_sqlParser.CREATE)
            self.state = 2051
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==277:
                self.state = 2050
                self.match(fugue_sqlParser.TEMPORARY)


            self.state = 2054
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==133:
                self.state = 2053
                self.match(fugue_sqlParser.EXTERNAL)


            self.state = 2056
            self.match(fugue_sqlParser.TABLE)
            self.state = 2060
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,248,self._ctx)
            if la_ == 1:
                self.state = 2057
                self.match(fugue_sqlParser.IF)
                self.state = 2058
                self.match(fugue_sqlParser.NOT)
                self.state = 2059
                self.match(fugue_sqlParser.EXISTS)


            self.state = 2062
            self.multipartIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReplaceTableHeaderContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REPLACE(self):
            return self.getToken(fugue_sqlParser.REPLACE, 0)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)


        def CREATE(self):
            return self.getToken(fugue_sqlParser.CREATE, 0)

        def OR(self):
            return self.getToken(fugue_sqlParser.OR, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_replaceTableHeader

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReplaceTableHeader" ):
                return visitor.visitReplaceTableHeader(self)
            else:
                return visitor.visitChildren(self)




    def replaceTableHeader(self):

        localctx = fugue_sqlParser.ReplaceTableHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_replaceTableHeader)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2066
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 2064
                self.match(fugue_sqlParser.CREATE)
                self.state = 2065
                self.match(fugue_sqlParser.OR)


            self.state = 2068
            self.match(fugue_sqlParser.REPLACE)
            self.state = 2069
            self.match(fugue_sqlParser.TABLE)
            self.state = 2070
            self.multipartIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BucketSpecContext(ParserRuleContext):
        __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(fugue_sqlParser.CLUSTERED, 0)

        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.BY)
            else:
                return self.getToken(fugue_sqlParser.BY, i)

        def identifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierListContext,0)


        def INTO(self):
            return self.getToken(fugue_sqlParser.INTO, 0)

        def INTEGER_VALUE(self):
            return self.getToken(fugue_sqlParser.INTEGER_VALUE, 0)

        def BUCKETS(self):
            return self.getToken(fugue_sqlParser.BUCKETS, 0)

        def SORTED(self):
            return self.getToken(fugue_sqlParser.SORTED, 0)

        def orderedIdentifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.OrderedIdentifierListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_bucketSpec

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBucketSpec" ):
                return visitor.visitBucketSpec(self)
            else:
                return visitor.visitChildren(self)




    def bucketSpec(self):

        localctx = fugue_sqlParser.BucketSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_bucketSpec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2072
            self.match(fugue_sqlParser.CLUSTERED)
            self.state = 2073
            self.match(fugue_sqlParser.BY)
            self.state = 2074
            self.identifierList()
            self.state = 2078
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==265:
                self.state = 2075
                self.match(fugue_sqlParser.SORTED)
                self.state = 2076
                self.match(fugue_sqlParser.BY)
                self.state = 2077
                self.orderedIdentifierList()


            self.state = 2080
            self.match(fugue_sqlParser.INTO)
            self.state = 2081
            self.match(fugue_sqlParser.INTEGER_VALUE)
            self.state = 2082
            self.match(fugue_sqlParser.BUCKETS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SkewSpecContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SKEWED(self):
            return self.getToken(fugue_sqlParser.SKEWED, 0)

        def BY(self):
            return self.getToken(fugue_sqlParser.BY, 0)

        def identifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierListContext,0)


        def ON(self):
            return self.getToken(fugue_sqlParser.ON, 0)

        def constantList(self):
            return self.getTypedRuleContext(fugue_sqlParser.ConstantListContext,0)


        def nestedConstantList(self):
            return self.getTypedRuleContext(fugue_sqlParser.NestedConstantListContext,0)


        def STORED(self):
            return self.getToken(fugue_sqlParser.STORED, 0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def DIRECTORIES(self):
            return self.getToken(fugue_sqlParser.DIRECTORIES, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_skewSpec

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSkewSpec" ):
                return visitor.visitSkewSpec(self)
            else:
                return visitor.visitChildren(self)




    def skewSpec(self):

        localctx = fugue_sqlParser.SkewSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_skewSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2084
            self.match(fugue_sqlParser.SKEWED)
            self.state = 2085
            self.match(fugue_sqlParser.BY)
            self.state = 2086
            self.identifierList()
            self.state = 2087
            self.match(fugue_sqlParser.ON)
            self.state = 2090
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,251,self._ctx)
            if la_ == 1:
                self.state = 2088
                self.constantList()
                pass

            elif la_ == 2:
                self.state = 2089
                self.nestedConstantList()
                pass


            self.state = 2095
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
            if la_ == 1:
                self.state = 2092
                self.match(fugue_sqlParser.STORED)
                self.state = 2093
                self.match(fugue_sqlParser.AS)
                self.state = 2094
                self.match(fugue_sqlParser.DIRECTORIES)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LocationSpecContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LOCATION(self):
            return self.getToken(fugue_sqlParser.LOCATION, 0)

        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_locationSpec

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLocationSpec" ):
                return visitor.visitLocationSpec(self)
            else:
                return visitor.visitChildren(self)




    def locationSpec(self):

        localctx = fugue_sqlParser.LocationSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_locationSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2097
            self.match(fugue_sqlParser.LOCATION)
            self.state = 2098
            self.match(fugue_sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CommentSpecContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COMMENT(self):
            return self.getToken(fugue_sqlParser.COMMENT, 0)

        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_commentSpec

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCommentSpec" ):
                return visitor.visitCommentSpec(self)
            else:
                return visitor.visitChildren(self)




    def commentSpec(self):

        localctx = fugue_sqlParser.CommentSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_commentSpec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2100
            self.match(fugue_sqlParser.COMMENT)
            self.state = 2101
            self.match(fugue_sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def queryTerm(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryTermContext,0)


        def queryOrganization(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryOrganizationContext,0)


        def fugueSqlEngine(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueSqlEngineContext,0)


        def ctes(self):
            return self.getTypedRuleContext(fugue_sqlParser.CtesContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_query

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuery" ):
                return visitor.visitQuery(self)
            else:
                return visitor.visitChildren(self)




    def query(self):

        localctx = fugue_sqlParser.QueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_query)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2104
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==47:
                self.state = 2103
                self.fugueSqlEngine()


            self.state = 2107
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==308:
                self.state = 2106
                self.ctes()


            self.state = 2109
            self.queryTerm(0)
            self.state = 2110
            self.queryOrganization()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InsertIntoContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_insertInto

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class InsertOverwriteHiveDirContext(InsertIntoContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.InsertIntoContext
            super().__init__(parser)
            self.path = None # Token
            self.copyFrom(ctx)

        def INSERT(self):
            return self.getToken(fugue_sqlParser.INSERT, 0)
        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)
        def DIRECTORY(self):
            return self.getToken(fugue_sqlParser.DIRECTORY, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def LOCAL(self):
            return self.getToken(fugue_sqlParser.LOCAL, 0)
        def rowFormat(self):
            return self.getTypedRuleContext(fugue_sqlParser.RowFormatContext,0)

        def createFileFormat(self):
            return self.getTypedRuleContext(fugue_sqlParser.CreateFileFormatContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInsertOverwriteHiveDir" ):
                return visitor.visitInsertOverwriteHiveDir(self)
            else:
                return visitor.visitChildren(self)


    class InsertOverwriteDirContext(InsertIntoContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.InsertIntoContext
            super().__init__(parser)
            self.path = None # Token
            self.options = None # TablePropertyListContext
            self.copyFrom(ctx)

        def INSERT(self):
            return self.getToken(fugue_sqlParser.INSERT, 0)
        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)
        def DIRECTORY(self):
            return self.getToken(fugue_sqlParser.DIRECTORY, 0)
        def tableProvider(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableProviderContext,0)

        def LOCAL(self):
            return self.getToken(fugue_sqlParser.LOCAL, 0)
        def OPTIONS(self):
            return self.getToken(fugue_sqlParser.OPTIONS, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInsertOverwriteDir" ):
                return visitor.visitInsertOverwriteDir(self)
            else:
                return visitor.visitChildren(self)


    class InsertOverwriteTableContext(InsertIntoContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.InsertIntoContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def INSERT(self):
            return self.getToken(fugue_sqlParser.INSERT, 0)
        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,0)

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInsertOverwriteTable" ):
                return visitor.visitInsertOverwriteTable(self)
            else:
                return visitor.visitChildren(self)


    class InsertIntoTableContext(InsertIntoContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.InsertIntoContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def INSERT(self):
            return self.getToken(fugue_sqlParser.INSERT, 0)
        def INTO(self):
            return self.getToken(fugue_sqlParser.INTO, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,0)

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)
        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInsertIntoTable" ):
                return visitor.visitInsertIntoTable(self)
            else:
                return visitor.visitChildren(self)



    def insertInto(self):

        localctx = fugue_sqlParser.InsertIntoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_insertInto)
        self._la = 0 # Token type
        try:
            self.state = 2167
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,267,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.InsertOverwriteTableContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2112
                self.match(fugue_sqlParser.INSERT)
                self.state = 2113
                self.match(fugue_sqlParser.OVERWRITE)
                self.state = 2115
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,255,self._ctx)
                if la_ == 1:
                    self.state = 2114
                    self.match(fugue_sqlParser.TABLE)


                self.state = 2117
                self.multipartIdentifier()
                self.state = 2124
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 2118
                    self.partitionSpec()
                    self.state = 2122
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==156:
                        self.state = 2119
                        self.match(fugue_sqlParser.IF)
                        self.state = 2120
                        self.match(fugue_sqlParser.NOT)
                        self.state = 2121
                        self.match(fugue_sqlParser.EXISTS)




                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.InsertIntoTableContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2126
                self.match(fugue_sqlParser.INSERT)
                self.state = 2127
                self.match(fugue_sqlParser.INTO)
                self.state = 2129
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
                if la_ == 1:
                    self.state = 2128
                    self.match(fugue_sqlParser.TABLE)


                self.state = 2131
                self.multipartIdentifier()
                self.state = 2133
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==216:
                    self.state = 2132
                    self.partitionSpec()


                self.state = 2138
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==156:
                    self.state = 2135
                    self.match(fugue_sqlParser.IF)
                    self.state = 2136
                    self.match(fugue_sqlParser.NOT)
                    self.state = 2137
                    self.match(fugue_sqlParser.EXISTS)


                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.InsertOverwriteHiveDirContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2140
                self.match(fugue_sqlParser.INSERT)
                self.state = 2141
                self.match(fugue_sqlParser.OVERWRITE)
                self.state = 2143
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 2142
                    self.match(fugue_sqlParser.LOCAL)


                self.state = 2145
                self.match(fugue_sqlParser.DIRECTORY)
                self.state = 2146
                localctx.path = self.match(fugue_sqlParser.STRING)
                self.state = 2148
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==248:
                    self.state = 2147
                    self.rowFormat()


                self.state = 2151
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==268:
                    self.state = 2150
                    self.createFileFormat()


                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.InsertOverwriteDirContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2153
                self.match(fugue_sqlParser.INSERT)
                self.state = 2154
                self.match(fugue_sqlParser.OVERWRITE)
                self.state = 2156
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 2155
                    self.match(fugue_sqlParser.LOCAL)


                self.state = 2158
                self.match(fugue_sqlParser.DIRECTORY)
                self.state = 2160
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==330:
                    self.state = 2159
                    localctx.path = self.match(fugue_sqlParser.STRING)


                self.state = 2162
                self.tableProvider()
                self.state = 2165
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==206:
                    self.state = 2163
                    self.match(fugue_sqlParser.OPTIONS)
                    self.state = 2164
                    localctx.options = self.tablePropertyList()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartitionSpecLocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def partitionSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.PartitionSpecContext,0)


        def locationSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.LocationSpecContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_partitionSpecLocation

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartitionSpecLocation" ):
                return visitor.visitPartitionSpecLocation(self)
            else:
                return visitor.visitChildren(self)




    def partitionSpecLocation(self):

        localctx = fugue_sqlParser.PartitionSpecLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_partitionSpecLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2169
            self.partitionSpec()
            self.state = 2171
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==184:
                self.state = 2170
                self.locationSpec()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartitionSpecContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PARTITION(self):
            return self.getToken(fugue_sqlParser.PARTITION, 0)

        def partitionVal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.PartitionValContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.PartitionValContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_partitionSpec

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartitionSpec" ):
                return visitor.visitPartitionSpec(self)
            else:
                return visitor.visitChildren(self)




    def partitionSpec(self):

        localctx = fugue_sqlParser.PartitionSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_partitionSpec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2173
            self.match(fugue_sqlParser.PARTITION)
            self.state = 2174
            self.match(fugue_sqlParser.T__4)
            self.state = 2175
            self.partitionVal()
            self.state = 2180
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2176
                self.match(fugue_sqlParser.T__1)
                self.state = 2177
                self.partitionVal()
                self.state = 2182
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2183
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PartitionValContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def constant(self):
            return self.getTypedRuleContext(fugue_sqlParser.ConstantContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_partitionVal

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPartitionVal" ):
                return visitor.visitPartitionVal(self)
            else:
                return visitor.visitChildren(self)




    def partitionVal(self):

        localctx = fugue_sqlParser.PartitionValContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_partitionVal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2185
            self.identifier()
            self.state = 2188
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==310:
                self.state = 2186
                self.match(fugue_sqlParser.EQUAL)
                self.state = 2187
                self.constant()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TheNamespaceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NAMESPACE(self):
            return self.getToken(fugue_sqlParser.NAMESPACE, 0)

        def DATABASE(self):
            return self.getToken(fugue_sqlParser.DATABASE, 0)

        def SCHEMA(self):
            return self.getToken(fugue_sqlParser.SCHEMA, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_theNamespace

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTheNamespace" ):
                return visitor.visitTheNamespace(self)
            else:
                return visitor.visitChildren(self)




    def theNamespace(self):

        localctx = fugue_sqlParser.TheNamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_theNamespace)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2190
            _la = self._input.LA(1)
            if not(_la==108 or _la==195 or _la==250):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DescribeFuncNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,0)


        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def comparisonOperator(self):
            return self.getTypedRuleContext(fugue_sqlParser.ComparisonOperatorContext,0)


        def arithmeticOperator(self):
            return self.getTypedRuleContext(fugue_sqlParser.ArithmeticOperatorContext,0)


        def predicateOperator(self):
            return self.getTypedRuleContext(fugue_sqlParser.PredicateOperatorContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_describeFuncName

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescribeFuncName" ):
                return visitor.visitDescribeFuncName(self)
            else:
                return visitor.visitChildren(self)




    def describeFuncName(self):

        localctx = fugue_sqlParser.DescribeFuncNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_describeFuncName)
        try:
            self.state = 2197
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,271,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2192
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2193
                self.match(fugue_sqlParser.STRING)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2194
                self.comparisonOperator()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2195
                self.arithmeticOperator()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2196
                self.predicateOperator()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DescribeColNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._identifier = None # IdentifierContext
            self.nameParts = list() # of IdentifierContexts

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_describeColName

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescribeColName" ):
                return visitor.visitDescribeColName(self)
            else:
                return visitor.visitChildren(self)




    def describeColName(self):

        localctx = fugue_sqlParser.DescribeColNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_describeColName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2199
            localctx._identifier = self.identifier()
            localctx.nameParts.append(localctx._identifier)
            self.state = 2204
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==7:
                self.state = 2200
                self.match(fugue_sqlParser.T__6)
                self.state = 2201
                localctx._identifier = self.identifier()
                localctx.nameParts.append(localctx._identifier)
                self.state = 2206
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CtesContext(ParserRuleContext):
        __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(fugue_sqlParser.WITH, 0)

        def namedQuery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NamedQueryContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.NamedQueryContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_ctes

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCtes" ):
                return visitor.visitCtes(self)
            else:
                return visitor.visitChildren(self)




    def ctes(self):

        localctx = fugue_sqlParser.CtesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_ctes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2207
            self.match(fugue_sqlParser.WITH)
            self.state = 2208
            self.namedQuery()
            self.state = 2213
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2209
                self.match(fugue_sqlParser.T__1)
                self.state = 2210
                self.namedQuery()
                self.state = 2215
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamedQueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.name = None # ErrorCapturingIdentifierContext
            self.columnAliases = None # IdentifierListContext

        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)


        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def identifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_namedQuery

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamedQuery" ):
                return visitor.visitNamedQuery(self)
            else:
                return visitor.visitChildren(self)




    def namedQuery(self):

        localctx = fugue_sqlParser.NamedQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_namedQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2216
            localctx.name = self.errorCapturingIdentifier()
            self.state = 2218
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
            if la_ == 1:
                self.state = 2217
                localctx.columnAliases = self.identifierList()


            self.state = 2221
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==68:
                self.state = 2220
                self.match(fugue_sqlParser.AS)


            self.state = 2223
            self.match(fugue_sqlParser.T__4)
            self.state = 2224
            self.query()
            self.state = 2225
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableProviderContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def USING(self):
            return self.getToken(fugue_sqlParser.USING, 0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_tableProvider

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableProvider" ):
                return visitor.visitTableProvider(self)
            else:
                return visitor.visitChildren(self)




    def tableProvider(self):

        localctx = fugue_sqlParser.TableProviderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_tableProvider)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2227
            self.match(fugue_sqlParser.USING)
            self.state = 2228
            self.multipartIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateTableClausesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.options = None # TablePropertyListContext
            self.partitioning = None # TransformListContext
            self.tableProps = None # TablePropertyListContext

        def bucketSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.BucketSpecContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.BucketSpecContext,i)


        def locationSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.LocationSpecContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.LocationSpecContext,i)


        def commentSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.CommentSpecContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,i)


        def OPTIONS(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.OPTIONS)
            else:
                return self.getToken(fugue_sqlParser.OPTIONS, i)

        def PARTITIONED(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.PARTITIONED)
            else:
                return self.getToken(fugue_sqlParser.PARTITIONED, i)

        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.BY)
            else:
                return self.getToken(fugue_sqlParser.BY, i)

        def TBLPROPERTIES(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.TBLPROPERTIES)
            else:
                return self.getToken(fugue_sqlParser.TBLPROPERTIES, i)

        def tablePropertyList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TablePropertyListContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,i)


        def transformList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TransformListContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TransformListContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_createTableClauses

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateTableClauses" ):
                return visitor.visitCreateTableClauses(self)
            else:
                return visitor.visitChildren(self)




    def createTableClauses(self):

        localctx = fugue_sqlParser.CreateTableClausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_createTableClauses)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2242
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==85 or _la==91 or (((_la - 184)) & ~0x3f) == 0 and ((1 << (_la - 184)) & 8594128897) != 0 or _la==276:
                self.state = 2240
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [206]:
                    self.state = 2230
                    self.match(fugue_sqlParser.OPTIONS)
                    self.state = 2231
                    localctx.options = self.tablePropertyList()
                    pass
                elif token in [217]:
                    self.state = 2232
                    self.match(fugue_sqlParser.PARTITIONED)
                    self.state = 2233
                    self.match(fugue_sqlParser.BY)
                    self.state = 2234
                    localctx.partitioning = self.transformList()
                    pass
                elif token in [85]:
                    self.state = 2235
                    self.bucketSpec()
                    pass
                elif token in [184]:
                    self.state = 2236
                    self.locationSpec()
                    pass
                elif token in [91]:
                    self.state = 2237
                    self.commentSpec()
                    pass
                elif token in [276]:
                    self.state = 2238
                    self.match(fugue_sqlParser.TBLPROPERTIES)
                    self.state = 2239
                    localctx.tableProps = self.tablePropertyList()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2244
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TablePropertyListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def tableProperty(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TablePropertyContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TablePropertyContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_tablePropertyList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTablePropertyList" ):
                return visitor.visitTablePropertyList(self)
            else:
                return visitor.visitChildren(self)




    def tablePropertyList(self):

        localctx = fugue_sqlParser.TablePropertyListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_tablePropertyList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2245
            self.match(fugue_sqlParser.T__4)
            self.state = 2246
            self.tableProperty()
            self.state = 2251
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2247
                self.match(fugue_sqlParser.T__1)
                self.state = 2248
                self.tableProperty()
                self.state = 2253
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2254
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TablePropertyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.key = None # TablePropertyKeyContext
            self.value = None # TablePropertyValueContext

        def tablePropertyKey(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyKeyContext,0)


        def tablePropertyValue(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyValueContext,0)


        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_tableProperty

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableProperty" ):
                return visitor.visitTableProperty(self)
            else:
                return visitor.visitChildren(self)




    def tableProperty(self):

        localctx = fugue_sqlParser.TablePropertyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_tableProperty)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2256
            localctx.key = self.tablePropertyKey()
            self.state = 2261
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==135 or (((_la - 287)) & ~0x3f) == 0 and ((1 << (_la - 287)) & 712483543187457) != 0:
                self.state = 2258
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==310:
                    self.state = 2257
                    self.match(fugue_sqlParser.EQUAL)


                self.state = 2260
                localctx.value = self.tablePropertyValue()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TablePropertyKeyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_tablePropertyKey

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTablePropertyKey" ):
                return visitor.visitTablePropertyKey(self)
            else:
                return visitor.visitChildren(self)




    def tablePropertyKey(self):

        localctx = fugue_sqlParser.TablePropertyKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_tablePropertyKey)
        self._la = 0 # Token type
        try:
            self.state = 2272
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2263
                self.identifier()
                self.state = 2268
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==7:
                    self.state = 2264
                    self.match(fugue_sqlParser.T__6)
                    self.state = 2265
                    self.identifier()
                    self.state = 2270
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [330]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2271
                self.match(fugue_sqlParser.STRING)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TablePropertyValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTEGER_VALUE(self):
            return self.getToken(fugue_sqlParser.INTEGER_VALUE, 0)

        def DECIMAL_VALUE(self):
            return self.getToken(fugue_sqlParser.DECIMAL_VALUE, 0)

        def booleanValue(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanValueContext,0)


        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_tablePropertyValue

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTablePropertyValue" ):
                return visitor.visitTablePropertyValue(self)
            else:
                return visitor.visitChildren(self)




    def tablePropertyValue(self):

        localctx = fugue_sqlParser.TablePropertyValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_tablePropertyValue)
        try:
            self.state = 2278
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [334]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2274
                self.match(fugue_sqlParser.INTEGER_VALUE)
                pass
            elif token in [336]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2275
                self.match(fugue_sqlParser.DECIMAL_VALUE)
                pass
            elif token in [135, 287]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2276
                self.booleanValue()
                pass
            elif token in [330]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2277
                self.match(fugue_sqlParser.STRING)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstantListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ConstantContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ConstantContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_constantList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstantList" ):
                return visitor.visitConstantList(self)
            else:
                return visitor.visitChildren(self)




    def constantList(self):

        localctx = fugue_sqlParser.ConstantListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_constantList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2280
            self.match(fugue_sqlParser.T__4)
            self.state = 2281
            self.constant()
            self.state = 2286
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2282
                self.match(fugue_sqlParser.T__1)
                self.state = 2283
                self.constant()
                self.state = 2288
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2289
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NestedConstantListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constantList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ConstantListContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ConstantListContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_nestedConstantList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNestedConstantList" ):
                return visitor.visitNestedConstantList(self)
            else:
                return visitor.visitChildren(self)




    def nestedConstantList(self):

        localctx = fugue_sqlParser.NestedConstantListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_nestedConstantList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2291
            self.match(fugue_sqlParser.T__4)
            self.state = 2292
            self.constantList()
            self.state = 2297
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2293
                self.match(fugue_sqlParser.T__1)
                self.state = 2294
                self.constantList()
                self.state = 2299
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2300
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateFileFormatContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STORED(self):
            return self.getToken(fugue_sqlParser.STORED, 0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def fileFormat(self):
            return self.getTypedRuleContext(fugue_sqlParser.FileFormatContext,0)


        def BY(self):
            return self.getToken(fugue_sqlParser.BY, 0)

        def storageHandler(self):
            return self.getTypedRuleContext(fugue_sqlParser.StorageHandlerContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_createFileFormat

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCreateFileFormat" ):
                return visitor.visitCreateFileFormat(self)
            else:
                return visitor.visitChildren(self)




    def createFileFormat(self):

        localctx = fugue_sqlParser.CreateFileFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_createFileFormat)
        try:
            self.state = 2308
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,286,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2302
                self.match(fugue_sqlParser.STORED)
                self.state = 2303
                self.match(fugue_sqlParser.AS)
                self.state = 2304
                self.fileFormat()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2305
                self.match(fugue_sqlParser.STORED)
                self.state = 2306
                self.match(fugue_sqlParser.BY)
                self.state = 2307
                self.storageHandler()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FileFormatContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fileFormat

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class TableFileFormatContext(FileFormatContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.FileFormatContext
            super().__init__(parser)
            self.inFmt = None # Token
            self.outFmt = None # Token
            self.copyFrom(ctx)

        def INPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.INPUTFORMAT, 0)
        def OUTPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.OUTPUTFORMAT, 0)
        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.STRING)
            else:
                return self.getToken(fugue_sqlParser.STRING, i)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableFileFormat" ):
                return visitor.visitTableFileFormat(self)
            else:
                return visitor.visitChildren(self)


    class GenericFileFormatContext(FileFormatContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.FileFormatContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGenericFileFormat" ):
                return visitor.visitGenericFileFormat(self)
            else:
                return visitor.visitChildren(self)



    def fileFormat(self):

        localctx = fugue_sqlParser.FileFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_fileFormat)
        try:
            self.state = 2315
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,287,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.TableFileFormatContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2310
                self.match(fugue_sqlParser.INPUTFORMAT)
                self.state = 2311
                localctx.inFmt = self.match(fugue_sqlParser.STRING)
                self.state = 2312
                self.match(fugue_sqlParser.OUTPUTFORMAT)
                self.state = 2313
                localctx.outFmt = self.match(fugue_sqlParser.STRING)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.GenericFileFormatContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2314
                self.identifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StorageHandlerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def WITH(self):
            return self.getToken(fugue_sqlParser.WITH, 0)

        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)

        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_storageHandler

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStorageHandler" ):
                return visitor.visitStorageHandler(self)
            else:
                return visitor.visitChildren(self)




    def storageHandler(self):

        localctx = fugue_sqlParser.StorageHandlerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_storageHandler)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2317
            self.match(fugue_sqlParser.STRING)
            self.state = 2321
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,288,self._ctx)
            if la_ == 1:
                self.state = 2318
                self.match(fugue_sqlParser.WITH)
                self.state = 2319
                self.match(fugue_sqlParser.SERDEPROPERTIES)
                self.state = 2320
                self.tablePropertyList()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ResourceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_resource

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitResource" ):
                return visitor.visitResource(self)
            else:
                return visitor.visitChildren(self)




    def resource(self):

        localctx = fugue_sqlParser.ResourceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_resource)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2323
            self.identifier()
            self.state = 2324
            self.match(fugue_sqlParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DmlStatementNoWithContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_dmlStatementNoWith

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class DeleteFromTableContext(DmlStatementNoWithContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DELETE(self):
            return self.getToken(fugue_sqlParser.DELETE, 0)
        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def whereClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WhereClauseContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeleteFromTable" ):
                return visitor.visitDeleteFromTable(self)
            else:
                return visitor.visitChildren(self)


    class SingleInsertQueryContext(DmlStatementNoWithContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def insertInto(self):
            return self.getTypedRuleContext(fugue_sqlParser.InsertIntoContext,0)

        def queryTerm(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryTermContext,0)

        def queryOrganization(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryOrganizationContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSingleInsertQuery" ):
                return visitor.visitSingleInsertQuery(self)
            else:
                return visitor.visitChildren(self)


    class MultiInsertQueryContext(DmlStatementNoWithContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def fromClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.FromClauseContext,0)

        def multiInsertQueryBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultiInsertQueryBodyContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultiInsertQueryBodyContext,i)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultiInsertQuery" ):
                return visitor.visitMultiInsertQuery(self)
            else:
                return visitor.visitChildren(self)


    class UpdateTableContext(DmlStatementNoWithContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def UPDATE(self):
            return self.getToken(fugue_sqlParser.UPDATE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def setClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.SetClauseContext,0)

        def whereClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WhereClauseContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUpdateTable" ):
                return visitor.visitUpdateTable(self)
            else:
                return visitor.visitChildren(self)


    class MergeIntoTableContext(DmlStatementNoWithContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.DmlStatementNoWithContext
            super().__init__(parser)
            self.target = None # MultipartIdentifierContext
            self.targetAlias = None # TableAliasContext
            self.source = None # MultipartIdentifierContext
            self.sourceQuery = None # QueryContext
            self.sourceAlias = None # TableAliasContext
            self.mergeCondition = None # BooleanExpressionContext
            self.copyFrom(ctx)

        def MERGE(self):
            return self.getToken(fugue_sqlParser.MERGE, 0)
        def INTO(self):
            return self.getToken(fugue_sqlParser.INTO, 0)
        def USING(self):
            return self.getToken(fugue_sqlParser.USING, 0)
        def ON(self):
            return self.getToken(fugue_sqlParser.ON, 0)
        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,i)

        def tableAlias(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TableAliasContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,i)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)

        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)

        def matchedClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MatchedClauseContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MatchedClauseContext,i)

        def notMatchedClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NotMatchedClauseContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.NotMatchedClauseContext,i)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMergeIntoTable" ):
                return visitor.visitMergeIntoTable(self)
            else:
                return visitor.visitChildren(self)



    def dmlStatementNoWith(self):

        localctx = fugue_sqlParser.DmlStatementNoWithContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_dmlStatementNoWith)
        self._la = 0 # Token type
        try:
            self.state = 2377
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [165]:
                localctx = fugue_sqlParser.SingleInsertQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2326
                self.insertInto()
                self.state = 2327
                self.queryTerm(0)
                self.state = 2328
                self.queryOrganization()
                pass
            elif token in [146]:
                localctx = fugue_sqlParser.MultiInsertQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2330
                self.fromClause()
                self.state = 2332 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2331
                    self.multiInsertQueryBody()
                    self.state = 2334 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==165):
                        break

                pass
            elif token in [113]:
                localctx = fugue_sqlParser.DeleteFromTableContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2336
                self.match(fugue_sqlParser.DELETE)
                self.state = 2337
                self.match(fugue_sqlParser.FROM)
                self.state = 2338
                self.multipartIdentifier()
                self.state = 2339
                self.tableAlias()
                self.state = 2341
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==306:
                    self.state = 2340
                    self.whereClause()


                pass
            elif token in [298]:
                localctx = fugue_sqlParser.UpdateTableContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2343
                self.match(fugue_sqlParser.UPDATE)
                self.state = 2344
                self.multipartIdentifier()
                self.state = 2345
                self.tableAlias()
                self.state = 2346
                self.setClause()
                self.state = 2348
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==306:
                    self.state = 2347
                    self.whereClause()


                pass
            elif token in [191]:
                localctx = fugue_sqlParser.MergeIntoTableContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 2350
                self.match(fugue_sqlParser.MERGE)
                self.state = 2351
                self.match(fugue_sqlParser.INTO)
                self.state = 2352
                localctx.target = self.multipartIdentifier()
                self.state = 2353
                localctx.targetAlias = self.tableAlias()
                self.state = 2354
                self.match(fugue_sqlParser.USING)
                self.state = 2360
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                    self.state = 2355
                    localctx.source = self.multipartIdentifier()
                    pass
                elif token in [5]:
                    self.state = 2356
                    self.match(fugue_sqlParser.T__4)
                    self.state = 2357
                    localctx.sourceQuery = self.query()
                    self.state = 2358
                    self.match(fugue_sqlParser.T__5)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2362
                localctx.sourceAlias = self.tableAlias()
                self.state = 2363
                self.match(fugue_sqlParser.ON)
                self.state = 2364
                localctx.mergeCondition = self.booleanExpression(0)
                self.state = 2368
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,293,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2365
                        self.matchedClause() 
                    self.state = 2370
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,293,self._ctx)

                self.state = 2374
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==305:
                    self.state = 2371
                    self.notMatchedClause()
                    self.state = 2376
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryOrganizationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._sortItem = None # SortItemContext
            self.order = list() # of SortItemContexts
            self._expression = None # ExpressionContext
            self.clusterBy = list() # of ExpressionContexts
            self.distributeBy = list() # of ExpressionContexts
            self.sort = list() # of SortItemContexts
            self.limit = None # ExpressionContext

        def ORDER(self):
            return self.getToken(fugue_sqlParser.ORDER, 0)

        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.BY)
            else:
                return self.getToken(fugue_sqlParser.BY, i)

        def CLUSTER(self):
            return self.getToken(fugue_sqlParser.CLUSTER, 0)

        def DISTRIBUTE(self):
            return self.getToken(fugue_sqlParser.DISTRIBUTE, 0)

        def SORT(self):
            return self.getToken(fugue_sqlParser.SORT, 0)

        def windowClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowClauseContext,0)


        def LIMIT(self):
            return self.getToken(fugue_sqlParser.LIMIT, 0)

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.SortItemContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.SortItemContext,i)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def ALL(self):
            return self.getToken(fugue_sqlParser.ALL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_queryOrganization

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQueryOrganization" ):
                return visitor.visitQueryOrganization(self)
            else:
                return visitor.visitChildren(self)




    def queryOrganization(self):

        localctx = fugue_sqlParser.QueryOrganizationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_queryOrganization)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2389
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,297,self._ctx)
            if la_ == 1:
                self.state = 2379
                self.match(fugue_sqlParser.ORDER)
                self.state = 2380
                self.match(fugue_sqlParser.BY)
                self.state = 2381
                localctx._sortItem = self.sortItem()
                localctx.order.append(localctx._sortItem)
                self.state = 2386
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,296,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2382
                        self.match(fugue_sqlParser.T__1)
                        self.state = 2383
                        localctx._sortItem = self.sortItem()
                        localctx.order.append(localctx._sortItem) 
                    self.state = 2388
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,296,self._ctx)



            self.state = 2401
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,299,self._ctx)
            if la_ == 1:
                self.state = 2391
                self.match(fugue_sqlParser.CLUSTER)
                self.state = 2392
                self.match(fugue_sqlParser.BY)
                self.state = 2393
                localctx._expression = self.expression()
                localctx.clusterBy.append(localctx._expression)
                self.state = 2398
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,298,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2394
                        self.match(fugue_sqlParser.T__1)
                        self.state = 2395
                        localctx._expression = self.expression()
                        localctx.clusterBy.append(localctx._expression) 
                    self.state = 2400
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,298,self._ctx)



            self.state = 2413
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,301,self._ctx)
            if la_ == 1:
                self.state = 2403
                self.match(fugue_sqlParser.DISTRIBUTE)
                self.state = 2404
                self.match(fugue_sqlParser.BY)
                self.state = 2405
                localctx._expression = self.expression()
                localctx.distributeBy.append(localctx._expression)
                self.state = 2410
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,300,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2406
                        self.match(fugue_sqlParser.T__1)
                        self.state = 2407
                        localctx._expression = self.expression()
                        localctx.distributeBy.append(localctx._expression) 
                    self.state = 2412
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,300,self._ctx)



            self.state = 2425
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,303,self._ctx)
            if la_ == 1:
                self.state = 2415
                self.match(fugue_sqlParser.SORT)
                self.state = 2416
                self.match(fugue_sqlParser.BY)
                self.state = 2417
                localctx._sortItem = self.sortItem()
                localctx.sort.append(localctx._sortItem)
                self.state = 2422
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,302,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2418
                        self.match(fugue_sqlParser.T__1)
                        self.state = 2419
                        localctx._sortItem = self.sortItem()
                        localctx.sort.append(localctx._sortItem) 
                    self.state = 2424
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,302,self._ctx)



            self.state = 2428
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,304,self._ctx)
            if la_ == 1:
                self.state = 2427
                self.windowClause()


            self.state = 2435
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,306,self._ctx)
            if la_ == 1:
                self.state = 2430
                self.match(fugue_sqlParser.LIMIT)
                self.state = 2433
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,305,self._ctx)
                if la_ == 1:
                    self.state = 2431
                    self.match(fugue_sqlParser.ALL)
                    pass

                elif la_ == 2:
                    self.state = 2432
                    localctx.limit = self.expression()
                    pass




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MultiInsertQueryBodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def insertInto(self):
            return self.getTypedRuleContext(fugue_sqlParser.InsertIntoContext,0)


        def fromStatementBody(self):
            return self.getTypedRuleContext(fugue_sqlParser.FromStatementBodyContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_multiInsertQueryBody

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultiInsertQueryBody" ):
                return visitor.visitMultiInsertQueryBody(self)
            else:
                return visitor.visitChildren(self)




    def multiInsertQueryBody(self):

        localctx = fugue_sqlParser.MultiInsertQueryBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_multiInsertQueryBody)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2437
            self.insertInto()
            self.state = 2438
            self.fromStatementBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QueryTermContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_queryTerm

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class QueryTermDefaultContext(QueryTermContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QueryTermContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def queryPrimary(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryPrimaryContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQueryTermDefault" ):
                return visitor.visitQueryTermDefault(self)
            else:
                return visitor.visitChildren(self)


    class FugueTermContext(QueryTermContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QueryTermContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def fugueNestableTaskCollectionNoSelect(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueNestableTaskCollectionNoSelectContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFugueTerm" ):
                return visitor.visitFugueTerm(self)
            else:
                return visitor.visitChildren(self)


    class SetOperationContext(QueryTermContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QueryTermContext
            super().__init__(parser)
            self.left = None # QueryTermContext
            self.theOperator = None # Token
            self.right = None # QueryTermContext
            self.copyFrom(ctx)

        def queryTerm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.QueryTermContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.QueryTermContext,i)

        def INTERSECT(self):
            return self.getToken(fugue_sqlParser.INTERSECT, 0)
        def UNION(self):
            return self.getToken(fugue_sqlParser.UNION, 0)
        def EXCEPT(self):
            return self.getToken(fugue_sqlParser.EXCEPT, 0)
        def SETMINUS(self):
            return self.getToken(fugue_sqlParser.SETMINUS, 0)
        def setQuantifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.SetQuantifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetOperation" ):
                return visitor.visitSetOperation(self)
            else:
                return visitor.visitChildren(self)



    def queryTerm(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = fugue_sqlParser.QueryTermContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 232
        self.enterRecursionRule(localctx, 232, self.RULE_queryTerm, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2443
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [146, 189, 233, 252, 273, 302]:
                localctx = fugue_sqlParser.QueryTermDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 2441
                self.queryPrimary()
                pass
            elif token in [17, 18, 27, 33, 36, 48, 61, 99, 122, 182, 236, 285]:
                localctx = fugue_sqlParser.FugueTermContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 2442
                self.fugueNestableTaskCollectionNoSelect()
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 2465
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,312,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 = 2463
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,311,self._ctx)
                    if la_ == 1:
                        localctx = fugue_sqlParser.SetOperationContext(self, fugue_sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 2445
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 2446
                        localctx.theOperator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==127 or _la==166 or _la==259 or _la==293):
                            localctx.theOperator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2448
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==60 or _la==120:
                            self.state = 2447
                            self.setQuantifier()


                        self.state = 2450
                        localctx.right = self.queryTerm(4)
                        pass

                    elif la_ == 2:
                        localctx = fugue_sqlParser.SetOperationContext(self, fugue_sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 2451
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 2452
                        localctx.theOperator = self.match(fugue_sqlParser.INTERSECT)
                        self.state = 2454
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==60 or _la==120:
                            self.state = 2453
                            self.setQuantifier()


                        self.state = 2456
                        localctx.right = self.queryTerm(3)
                        pass

                    elif la_ == 3:
                        localctx = fugue_sqlParser.SetOperationContext(self, fugue_sqlParser.QueryTermContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_queryTerm)
                        self.state = 2457
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 2458
                        localctx.theOperator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==127 or _la==259 or _la==293):
                            localctx.theOperator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 2460
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==60 or _la==120:
                            self.state = 2459
                            self.setQuantifier()


                        self.state = 2462
                        localctx.right = self.queryTerm(2)
                        pass

             
                self.state = 2467
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,312,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class QueryPrimaryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_queryPrimary

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class QueryPrimaryDefaultContext(QueryPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def querySpecification(self):
            return self.getTypedRuleContext(fugue_sqlParser.QuerySpecificationContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQueryPrimaryDefault" ):
                return visitor.visitQueryPrimaryDefault(self)
            else:
                return visitor.visitChildren(self)


    class InlineTableDefault1Context(QueryPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def inlineTable(self):
            return self.getTypedRuleContext(fugue_sqlParser.InlineTableContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineTableDefault1" ):
                return visitor.visitInlineTableDefault1(self)
            else:
                return visitor.visitChildren(self)


    class FromStmtContext(QueryPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def fromStatement(self):
            return self.getTypedRuleContext(fugue_sqlParser.FromStatementContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFromStmt" ):
                return visitor.visitFromStmt(self)
            else:
                return visitor.visitChildren(self)


    class TableContext(QueryPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QueryPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)
        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTable" ):
                return visitor.visitTable(self)
            else:
                return visitor.visitChildren(self)



    def queryPrimary(self):

        localctx = fugue_sqlParser.QueryPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_queryPrimary)
        try:
            self.state = 2473
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [189, 233, 252]:
                localctx = fugue_sqlParser.QueryPrimaryDefaultContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2468
                self.querySpecification()
                pass
            elif token in [146]:
                localctx = fugue_sqlParser.FromStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2469
                self.fromStatement()
                pass
            elif token in [273]:
                localctx = fugue_sqlParser.TableContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2470
                self.match(fugue_sqlParser.TABLE)
                self.state = 2471
                self.multipartIdentifier()
                pass
            elif token in [302]:
                localctx = fugue_sqlParser.InlineTableDefault1Context(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2472
                self.inlineTable()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SortItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.ordering = None # Token
            self.nullOrder = None # Token

        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)


        def THENULLS(self):
            return self.getToken(fugue_sqlParser.THENULLS, 0)

        def ASC(self):
            return self.getToken(fugue_sqlParser.ASC, 0)

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_sortItem

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSortItem" ):
                return visitor.visitSortItem(self)
            else:
                return visitor.visitChildren(self)




    def sortItem(self):

        localctx = fugue_sqlParser.SortItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_sortItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2475
            self.expression()
            self.state = 2477
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,314,self._ctx)
            if la_ == 1:
                self.state = 2476
                localctx.ordering = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==69 or _la==115):
                    localctx.ordering = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2481
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,315,self._ctx)
            if la_ == 1:
                self.state = 2479
                self.match(fugue_sqlParser.THENULLS)
                self.state = 2480
                localctx.nullOrder = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==140 or _la==173):
                    localctx.nullOrder = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FromStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fromClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.FromClauseContext,0)


        def fromStatementBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FromStatementBodyContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FromStatementBodyContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fromStatement

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFromStatement" ):
                return visitor.visitFromStatement(self)
            else:
                return visitor.visitChildren(self)




    def fromStatement(self):

        localctx = fugue_sqlParser.FromStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_fromStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2483
            self.fromClause()
            self.state = 2485 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2484
                    self.fromStatementBody()

                else:
                    raise NoViableAltException(self)
                self.state = 2487 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,316,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FromStatementBodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def transformClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.TransformClauseContext,0)


        def queryOrganization(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryOrganizationContext,0)


        def whereClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WhereClauseContext,0)


        def selectClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.SelectClauseContext,0)


        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.LateralViewContext,i)


        def aggregationClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.AggregationClauseContext,0)


        def havingClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.HavingClauseContext,0)


        def windowClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowClauseContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fromStatementBody

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFromStatementBody" ):
                return visitor.visitFromStatementBody(self)
            else:
                return visitor.visitChildren(self)




    def fromStatementBody(self):

        localctx = fugue_sqlParser.FromStatementBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_fromStatementBody)
        try:
            self.state = 2516
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,323,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2489
                self.transformClause()
                self.state = 2491
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,317,self._ctx)
                if la_ == 1:
                    self.state = 2490
                    self.whereClause()


                self.state = 2493
                self.queryOrganization()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2495
                self.selectClause()
                self.state = 2499
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,318,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2496
                        self.lateralView() 
                    self.state = 2501
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,318,self._ctx)

                self.state = 2503
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,319,self._ctx)
                if la_ == 1:
                    self.state = 2502
                    self.whereClause()


                self.state = 2506
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,320,self._ctx)
                if la_ == 1:
                    self.state = 2505
                    self.aggregationClause()


                self.state = 2509
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,321,self._ctx)
                if la_ == 1:
                    self.state = 2508
                    self.havingClause()


                self.state = 2512
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,322,self._ctx)
                if la_ == 1:
                    self.state = 2511
                    self.windowClause()


                self.state = 2514
                self.queryOrganization()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QuerySpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_querySpecification

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class RegularQuerySpecificationContext(QuerySpecificationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QuerySpecificationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def selectClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.SelectClauseContext,0)

        def optionalFromClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.OptionalFromClauseContext,0)

        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.LateralViewContext,i)

        def whereClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WhereClauseContext,0)

        def aggregationClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.AggregationClauseContext,0)

        def havingClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.HavingClauseContext,0)

        def windowClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowClauseContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRegularQuerySpecification" ):
                return visitor.visitRegularQuerySpecification(self)
            else:
                return visitor.visitChildren(self)


    class TransformQuerySpecificationContext(QuerySpecificationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.QuerySpecificationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def transformClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.TransformClauseContext,0)

        def optionalFromClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.OptionalFromClauseContext,0)

        def whereClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.WhereClauseContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTransformQuerySpecification" ):
                return visitor.visitTransformQuerySpecification(self)
            else:
                return visitor.visitChildren(self)



    def querySpecification(self):

        localctx = fugue_sqlParser.QuerySpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_querySpecification)
        try:
            self.state = 2543
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,330,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.TransformQuerySpecificationContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2518
                self.transformClause()
                self.state = 2519
                self.optionalFromClause()
                self.state = 2521
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,324,self._ctx)
                if la_ == 1:
                    self.state = 2520
                    self.whereClause()


                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.RegularQuerySpecificationContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2523
                self.selectClause()
                self.state = 2524
                self.optionalFromClause()
                self.state = 2528
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,325,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2525
                        self.lateralView() 
                    self.state = 2530
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,325,self._ctx)

                self.state = 2532
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,326,self._ctx)
                if la_ == 1:
                    self.state = 2531
                    self.whereClause()


                self.state = 2535
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,327,self._ctx)
                if la_ == 1:
                    self.state = 2534
                    self.aggregationClause()


                self.state = 2538
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,328,self._ctx)
                if la_ == 1:
                    self.state = 2537
                    self.havingClause()


                self.state = 2541
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,329,self._ctx)
                if la_ == 1:
                    self.state = 2540
                    self.windowClause()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OptionalFromClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fromClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.FromClauseContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_optionalFromClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOptionalFromClause" ):
                return visitor.visitOptionalFromClause(self)
            else:
                return visitor.visitChildren(self)




    def optionalFromClause(self):

        localctx = fugue_sqlParser.OptionalFromClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_optionalFromClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2546
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,331,self._ctx)
            if la_ == 1:
                self.state = 2545
                self.fromClause()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TransformClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.kind = None # Token
            self.inRowFormat = None # RowFormatContext
            self.recordWriter = None # Token
            self.script = None # Token
            self.outRowFormat = None # RowFormatContext
            self.recordReader = None # Token

        def USING(self):
            return self.getToken(fugue_sqlParser.USING, 0)

        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.STRING)
            else:
                return self.getToken(fugue_sqlParser.STRING, i)

        def SELECT(self):
            return self.getToken(fugue_sqlParser.SELECT, 0)

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionSeqContext,0)


        def TRANSFORM(self):
            return self.getToken(fugue_sqlParser.TRANSFORM, 0)

        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)

        def REDUCE(self):
            return self.getToken(fugue_sqlParser.REDUCE, 0)

        def RECORDWRITER(self):
            return self.getToken(fugue_sqlParser.RECORDWRITER, 0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def RECORDREADER(self):
            return self.getToken(fugue_sqlParser.RECORDREADER, 0)

        def rowFormat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.RowFormatContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.RowFormatContext,i)


        def identifierSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierSeqContext,0)


        def colTypeList(self):
            return self.getTypedRuleContext(fugue_sqlParser.ColTypeListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_transformClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTransformClause" ):
                return visitor.visitTransformClause(self)
            else:
                return visitor.visitChildren(self)




    def transformClause(self):

        localctx = fugue_sqlParser.TransformClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_transformClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2558
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [252]:
                self.state = 2548
                self.match(fugue_sqlParser.SELECT)
                self.state = 2549
                localctx.kind = self.match(fugue_sqlParser.TRANSFORM)
                self.state = 2550
                self.match(fugue_sqlParser.T__4)
                self.state = 2551
                self.namedExpressionSeq()
                self.state = 2552
                self.match(fugue_sqlParser.T__5)
                pass
            elif token in [189]:
                self.state = 2554
                localctx.kind = self.match(fugue_sqlParser.MAP)
                self.state = 2555
                self.namedExpressionSeq()
                pass
            elif token in [233]:
                self.state = 2556
                localctx.kind = self.match(fugue_sqlParser.REDUCE)
                self.state = 2557
                self.namedExpressionSeq()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 2561
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==248:
                self.state = 2560
                localctx.inRowFormat = self.rowFormat()


            self.state = 2565
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==231:
                self.state = 2563
                self.match(fugue_sqlParser.RECORDWRITER)
                self.state = 2564
                localctx.recordWriter = self.match(fugue_sqlParser.STRING)


            self.state = 2567
            self.match(fugue_sqlParser.USING)
            self.state = 2568
            localctx.script = self.match(fugue_sqlParser.STRING)
            self.state = 2581
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,337,self._ctx)
            if la_ == 1:
                self.state = 2569
                self.match(fugue_sqlParser.AS)
                self.state = 2579
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,336,self._ctx)
                if la_ == 1:
                    self.state = 2570
                    self.identifierSeq()
                    pass

                elif la_ == 2:
                    self.state = 2571
                    self.colTypeList()
                    pass

                elif la_ == 3:
                    self.state = 2572
                    self.match(fugue_sqlParser.T__4)
                    self.state = 2575
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,335,self._ctx)
                    if la_ == 1:
                        self.state = 2573
                        self.identifierSeq()
                        pass

                    elif la_ == 2:
                        self.state = 2574
                        self.colTypeList()
                        pass


                    self.state = 2577
                    self.match(fugue_sqlParser.T__5)
                    pass




            self.state = 2584
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,338,self._ctx)
            if la_ == 1:
                self.state = 2583
                localctx.outRowFormat = self.rowFormat()


            self.state = 2588
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,339,self._ctx)
            if la_ == 1:
                self.state = 2586
                self.match(fugue_sqlParser.RECORDREADER)
                self.state = 2587
                localctx.recordReader = self.match(fugue_sqlParser.STRING)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._hint = None # HintContext
            self.hints = list() # of HintContexts

        def SELECT(self):
            return self.getToken(fugue_sqlParser.SELECT, 0)

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionSeqContext,0)


        def setQuantifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.SetQuantifierContext,0)


        def hint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.HintContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.HintContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_selectClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelectClause" ):
                return visitor.visitSelectClause(self)
            else:
                return visitor.visitChildren(self)




    def selectClause(self):

        localctx = fugue_sqlParser.SelectClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_selectClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2590
            self.match(fugue_sqlParser.SELECT)
            self.state = 2594
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==14:
                self.state = 2591
                localctx._hint = self.hint()
                localctx.hints.append(localctx._hint)
                self.state = 2596
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2598
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,341,self._ctx)
            if la_ == 1:
                self.state = 2597
                self.setQuantifier()


            self.state = 2600
            self.namedExpressionSeq()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SetClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)

        def assignmentList(self):
            return self.getTypedRuleContext(fugue_sqlParser.AssignmentListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_setClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetClause" ):
                return visitor.visitSetClause(self)
            else:
                return visitor.visitChildren(self)




    def setClause(self):

        localctx = fugue_sqlParser.SetClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_setClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2602
            self.match(fugue_sqlParser.SET)
            self.state = 2603
            self.assignmentList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MatchedClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.matchedCond = None # BooleanExpressionContext

        def WHEN(self):
            return self.getToken(fugue_sqlParser.WHEN, 0)

        def MATCHED(self):
            return self.getToken(fugue_sqlParser.MATCHED, 0)

        def THEN(self):
            return self.getToken(fugue_sqlParser.THEN, 0)

        def matchedAction(self):
            return self.getTypedRuleContext(fugue_sqlParser.MatchedActionContext,0)


        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_matchedClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMatchedClause" ):
                return visitor.visitMatchedClause(self)
            else:
                return visitor.visitChildren(self)




    def matchedClause(self):

        localctx = fugue_sqlParser.MatchedClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_matchedClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2605
            self.match(fugue_sqlParser.WHEN)
            self.state = 2606
            self.match(fugue_sqlParser.MATCHED)
            self.state = 2609
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==63:
                self.state = 2607
                self.match(fugue_sqlParser.AND)
                self.state = 2608
                localctx.matchedCond = self.booleanExpression(0)


            self.state = 2611
            self.match(fugue_sqlParser.THEN)
            self.state = 2612
            self.matchedAction()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NotMatchedClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.notMatchedCond = None # BooleanExpressionContext

        def WHEN(self):
            return self.getToken(fugue_sqlParser.WHEN, 0)

        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def MATCHED(self):
            return self.getToken(fugue_sqlParser.MATCHED, 0)

        def THEN(self):
            return self.getToken(fugue_sqlParser.THEN, 0)

        def notMatchedAction(self):
            return self.getTypedRuleContext(fugue_sqlParser.NotMatchedActionContext,0)


        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_notMatchedClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNotMatchedClause" ):
                return visitor.visitNotMatchedClause(self)
            else:
                return visitor.visitChildren(self)




    def notMatchedClause(self):

        localctx = fugue_sqlParser.NotMatchedClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_notMatchedClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2614
            self.match(fugue_sqlParser.WHEN)
            self.state = 2615
            self.match(fugue_sqlParser.NOT)
            self.state = 2616
            self.match(fugue_sqlParser.MATCHED)
            self.state = 2619
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==63:
                self.state = 2617
                self.match(fugue_sqlParser.AND)
                self.state = 2618
                localctx.notMatchedCond = self.booleanExpression(0)


            self.state = 2621
            self.match(fugue_sqlParser.THEN)
            self.state = 2622
            self.notMatchedAction()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MatchedActionContext(ParserRuleContext):
        __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(fugue_sqlParser.DELETE, 0)

        def UPDATE(self):
            return self.getToken(fugue_sqlParser.UPDATE, 0)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)

        def assignmentList(self):
            return self.getTypedRuleContext(fugue_sqlParser.AssignmentListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_matchedAction

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMatchedAction" ):
                return visitor.visitMatchedAction(self)
            else:
                return visitor.visitChildren(self)




    def matchedAction(self):

        localctx = fugue_sqlParser.MatchedActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_matchedAction)
        try:
            self.state = 2631
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,344,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2624
                self.match(fugue_sqlParser.DELETE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2625
                self.match(fugue_sqlParser.UPDATE)
                self.state = 2626
                self.match(fugue_sqlParser.SET)
                self.state = 2627
                self.match(fugue_sqlParser.ASTERISK)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2628
                self.match(fugue_sqlParser.UPDATE)
                self.state = 2629
                self.match(fugue_sqlParser.SET)
                self.state = 2630
                self.assignmentList()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NotMatchedActionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.columns = None # MultipartIdentifierListContext

        def INSERT(self):
            return self.getToken(fugue_sqlParser.INSERT, 0)

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)

        def VALUES(self):
            return self.getToken(fugue_sqlParser.VALUES, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def multipartIdentifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_notMatchedAction

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNotMatchedAction" ):
                return visitor.visitNotMatchedAction(self)
            else:
                return visitor.visitChildren(self)




    def notMatchedAction(self):

        localctx = fugue_sqlParser.NotMatchedActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_notMatchedAction)
        self._la = 0 # Token type
        try:
            self.state = 2651
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,346,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2633
                self.match(fugue_sqlParser.INSERT)
                self.state = 2634
                self.match(fugue_sqlParser.ASTERISK)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2635
                self.match(fugue_sqlParser.INSERT)
                self.state = 2636
                self.match(fugue_sqlParser.T__4)
                self.state = 2637
                localctx.columns = self.multipartIdentifierList()
                self.state = 2638
                self.match(fugue_sqlParser.T__5)
                self.state = 2639
                self.match(fugue_sqlParser.VALUES)
                self.state = 2640
                self.match(fugue_sqlParser.T__4)
                self.state = 2641
                self.expression()
                self.state = 2646
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 2642
                    self.match(fugue_sqlParser.T__1)
                    self.state = 2643
                    self.expression()
                    self.state = 2648
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2649
                self.match(fugue_sqlParser.T__5)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignmentListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assignment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.AssignmentContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.AssignmentContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_assignmentList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignmentList" ):
                return visitor.visitAssignmentList(self)
            else:
                return visitor.visitChildren(self)




    def assignmentList(self):

        localctx = fugue_sqlParser.AssignmentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_assignmentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2653
            self.assignment()
            self.state = 2658
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2654
                self.match(fugue_sqlParser.T__1)
                self.state = 2655
                self.assignment()
                self.state = 2660
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.key = None # MultipartIdentifierContext
            self.value = None # ExpressionContext

        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)


        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_assignment

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignment" ):
                return visitor.visitAssignment(self)
            else:
                return visitor.visitChildren(self)




    def assignment(self):

        localctx = fugue_sqlParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2661
            localctx.key = self.multipartIdentifier()
            self.state = 2662
            self.match(fugue_sqlParser.EQUAL)
            self.state = 2663
            localctx.value = self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhereClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WHERE(self):
            return self.getToken(fugue_sqlParser.WHERE, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_whereClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhereClause" ):
                return visitor.visitWhereClause(self)
            else:
                return visitor.visitChildren(self)




    def whereClause(self):

        localctx = fugue_sqlParser.WhereClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_whereClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2665
            self.match(fugue_sqlParser.WHERE)
            self.state = 2666
            self.booleanExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HavingClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def HAVING(self):
            return self.getToken(fugue_sqlParser.HAVING, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_havingClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHavingClause" ):
                return visitor.visitHavingClause(self)
            else:
                return visitor.visitChildren(self)




    def havingClause(self):

        localctx = fugue_sqlParser.HavingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_havingClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2668
            self.match(fugue_sqlParser.HAVING)
            self.state = 2669
            self.booleanExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HintContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._hintStatement = None # HintStatementContext
            self.hintStatements = list() # of HintStatementContexts

        def hintStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.HintStatementContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.HintStatementContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_hint

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHint" ):
                return visitor.visitHint(self)
            else:
                return visitor.visitChildren(self)




    def hint(self):

        localctx = fugue_sqlParser.HintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_hint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2671
            self.match(fugue_sqlParser.T__13)
            self.state = 2672
            localctx._hintStatement = self.hintStatement()
            localctx.hintStatements.append(localctx._hintStatement)
            self.state = 2679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((_la) & ~0x3f) == 0 and ((1 << _la) & -288230376151711740) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0 or (((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0 or (((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & 18014398509481983) != 0 or (((_la - 324)) & ~0x3f) == 0 and ((1 << (_la - 324)) & 98305) != 0:
                self.state = 2674
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==2:
                    self.state = 2673
                    self.match(fugue_sqlParser.T__1)


                self.state = 2676
                localctx._hintStatement = self.hintStatement()
                localctx.hintStatements.append(localctx._hintStatement)
                self.state = 2681
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2682
            self.match(fugue_sqlParser.T__14)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HintStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.hintName = None # IdentifierContext
            self._primaryExpression = None # PrimaryExpressionContext
            self.parameters = list() # of PrimaryExpressionContexts

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def primaryExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.PrimaryExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.PrimaryExpressionContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_hintStatement

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHintStatement" ):
                return visitor.visitHintStatement(self)
            else:
                return visitor.visitChildren(self)




    def hintStatement(self):

        localctx = fugue_sqlParser.HintStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_hintStatement)
        self._la = 0 # Token type
        try:
            self.state = 2697
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,351,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2684
                localctx.hintName = self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2685
                localctx.hintName = self.identifier()
                self.state = 2686
                self.match(fugue_sqlParser.T__4)
                self.state = 2687
                localctx._primaryExpression = self.primaryExpression(0)
                localctx.parameters.append(localctx._primaryExpression)
                self.state = 2692
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 2688
                    self.match(fugue_sqlParser.T__1)
                    self.state = 2689
                    localctx._primaryExpression = self.primaryExpression(0)
                    localctx.parameters.append(localctx._primaryExpression)
                    self.state = 2694
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2695
                self.match(fugue_sqlParser.T__5)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FromClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)

        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.RelationContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.RelationContext,i)


        def lateralView(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.LateralViewContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.LateralViewContext,i)


        def pivotClause(self):
            return self.getTypedRuleContext(fugue_sqlParser.PivotClauseContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_fromClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFromClause" ):
                return visitor.visitFromClause(self)
            else:
                return visitor.visitChildren(self)




    def fromClause(self):

        localctx = fugue_sqlParser.FromClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_fromClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2699
            self.match(fugue_sqlParser.FROM)
            self.state = 2700
            self.relation()
            self.state = 2705
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,352,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2701
                    self.match(fugue_sqlParser.T__1)
                    self.state = 2702
                    self.relation() 
                self.state = 2707
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,352,self._ctx)

            self.state = 2711
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,353,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2708
                    self.lateralView() 
                self.state = 2713
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,353,self._ctx)

            self.state = 2715
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,354,self._ctx)
            if la_ == 1:
                self.state = 2714
                self.pivotClause()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AggregationClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._expression = None # ExpressionContext
            self.groupingExpressions = list() # of ExpressionContexts
            self.kind = None # Token

        def GROUP(self):
            return self.getToken(fugue_sqlParser.GROUP, 0)

        def BY(self):
            return self.getToken(fugue_sqlParser.BY, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def WITH(self):
            return self.getToken(fugue_sqlParser.WITH, 0)

        def SETS(self):
            return self.getToken(fugue_sqlParser.SETS, 0)

        def groupingSet(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.GroupingSetContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.GroupingSetContext,i)


        def ROLLUP(self):
            return self.getToken(fugue_sqlParser.ROLLUP, 0)

        def CUBE(self):
            return self.getToken(fugue_sqlParser.CUBE, 0)

        def GROUPING(self):
            return self.getToken(fugue_sqlParser.GROUPING, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_aggregationClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAggregationClause" ):
                return visitor.visitAggregationClause(self)
            else:
                return visitor.visitChildren(self)




    def aggregationClause(self):

        localctx = fugue_sqlParser.AggregationClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_aggregationClause)
        self._la = 0 # Token type
        try:
            self.state = 2761
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,359,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2717
                self.match(fugue_sqlParser.GROUP)
                self.state = 2718
                self.match(fugue_sqlParser.BY)
                self.state = 2719
                localctx._expression = self.expression()
                localctx.groupingExpressions.append(localctx._expression)
                self.state = 2724
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,355,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2720
                        self.match(fugue_sqlParser.T__1)
                        self.state = 2721
                        localctx._expression = self.expression()
                        localctx.groupingExpressions.append(localctx._expression) 
                    self.state = 2726
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,355,self._ctx)

                self.state = 2744
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,357,self._ctx)
                if la_ == 1:
                    self.state = 2727
                    self.match(fugue_sqlParser.WITH)
                    self.state = 2728
                    localctx.kind = self.match(fugue_sqlParser.ROLLUP)

                elif la_ == 2:
                    self.state = 2729
                    self.match(fugue_sqlParser.WITH)
                    self.state = 2730
                    localctx.kind = self.match(fugue_sqlParser.CUBE)

                elif la_ == 3:
                    self.state = 2731
                    localctx.kind = self.match(fugue_sqlParser.GROUPING)
                    self.state = 2732
                    self.match(fugue_sqlParser.SETS)
                    self.state = 2733
                    self.match(fugue_sqlParser.T__4)
                    self.state = 2734
                    self.groupingSet()
                    self.state = 2739
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==2:
                        self.state = 2735
                        self.match(fugue_sqlParser.T__1)
                        self.state = 2736
                        self.groupingSet()
                        self.state = 2741
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2742
                    self.match(fugue_sqlParser.T__5)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2746
                self.match(fugue_sqlParser.GROUP)
                self.state = 2747
                self.match(fugue_sqlParser.BY)
                self.state = 2748
                localctx.kind = self.match(fugue_sqlParser.GROUPING)
                self.state = 2749
                self.match(fugue_sqlParser.SETS)
                self.state = 2750
                self.match(fugue_sqlParser.T__4)
                self.state = 2751
                self.groupingSet()
                self.state = 2756
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 2752
                    self.match(fugue_sqlParser.T__1)
                    self.state = 2753
                    self.groupingSet()
                    self.state = 2758
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2759
                self.match(fugue_sqlParser.T__5)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GroupingSetContext(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(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_groupingSet

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGroupingSet" ):
                return visitor.visitGroupingSet(self)
            else:
                return visitor.visitChildren(self)




    def groupingSet(self):

        localctx = fugue_sqlParser.GroupingSetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_groupingSet)
        self._la = 0 # Token type
        try:
            self.state = 2776
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,362,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2763
                self.match(fugue_sqlParser.T__4)
                self.state = 2772
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & -288230376151711712) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0 or (((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0 or (((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & -9205357638345293825) != 0 or (((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & 2096179) != 0:
                    self.state = 2764
                    self.expression()
                    self.state = 2769
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==2:
                        self.state = 2765
                        self.match(fugue_sqlParser.T__1)
                        self.state = 2766
                        self.expression()
                        self.state = 2771
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2774
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2775
                self.expression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PivotClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.aggregates = None # NamedExpressionSeqContext
            self._pivotValue = None # PivotValueContext
            self.pivotValues = list() # of PivotValueContexts

        def PIVOT(self):
            return self.getToken(fugue_sqlParser.PIVOT, 0)

        def FOR(self):
            return self.getToken(fugue_sqlParser.FOR, 0)

        def pivotColumn(self):
            return self.getTypedRuleContext(fugue_sqlParser.PivotColumnContext,0)


        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)

        def namedExpressionSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionSeqContext,0)


        def pivotValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.PivotValueContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.PivotValueContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_pivotClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPivotClause" ):
                return visitor.visitPivotClause(self)
            else:
                return visitor.visitChildren(self)




    def pivotClause(self):

        localctx = fugue_sqlParser.PivotClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_pivotClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2778
            self.match(fugue_sqlParser.PIVOT)
            self.state = 2779
            self.match(fugue_sqlParser.T__4)
            self.state = 2780
            localctx.aggregates = self.namedExpressionSeq()
            self.state = 2781
            self.match(fugue_sqlParser.FOR)
            self.state = 2782
            self.pivotColumn()
            self.state = 2783
            self.match(fugue_sqlParser.IN)
            self.state = 2784
            self.match(fugue_sqlParser.T__4)
            self.state = 2785
            localctx._pivotValue = self.pivotValue()
            localctx.pivotValues.append(localctx._pivotValue)
            self.state = 2790
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2786
                self.match(fugue_sqlParser.T__1)
                self.state = 2787
                localctx._pivotValue = self.pivotValue()
                localctx.pivotValues.append(localctx._pivotValue)
                self.state = 2792
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2793
            self.match(fugue_sqlParser.T__5)
            self.state = 2794
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PivotColumnContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._identifier = None # IdentifierContext
            self.identifiers = list() # of IdentifierContexts

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_pivotColumn

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPivotColumn" ):
                return visitor.visitPivotColumn(self)
            else:
                return visitor.visitChildren(self)




    def pivotColumn(self):

        localctx = fugue_sqlParser.PivotColumnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_pivotColumn)
        self._la = 0 # Token type
        try:
            self.state = 2808
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2796
                localctx._identifier = self.identifier()
                localctx.identifiers.append(localctx._identifier)
                pass
            elif token in [5]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2797
                self.match(fugue_sqlParser.T__4)
                self.state = 2798
                localctx._identifier = self.identifier()
                localctx.identifiers.append(localctx._identifier)
                self.state = 2803
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 2799
                    self.match(fugue_sqlParser.T__1)
                    self.state = 2800
                    localctx._identifier = self.identifier()
                    localctx.identifiers.append(localctx._identifier)
                    self.state = 2805
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2806
                self.match(fugue_sqlParser.T__5)
                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 PivotValueContext(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(fugue_sqlParser.ExpressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_pivotValue

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPivotValue" ):
                return visitor.visitPivotValue(self)
            else:
                return visitor.visitChildren(self)




    def pivotValue(self):

        localctx = fugue_sqlParser.PivotValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_pivotValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2810
            self.expression()
            self.state = 2815
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & -1) != 0 or (((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & -1) != 0 or (((_la - 186)) & ~0x3f) == 0 and ((1 << (_la - 186)) & -1) != 0 or (((_la - 250)) & ~0x3f) == 0 and ((1 << (_la - 250)) & 1152921504606846975) != 0 or (((_la - 324)) & ~0x3f) == 0 and ((1 << (_la - 324)) & 98305) != 0:
                self.state = 2812
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,366,self._ctx)
                if la_ == 1:
                    self.state = 2811
                    self.match(fugue_sqlParser.AS)


                self.state = 2814
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LateralViewContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.tblName = None # IdentifierContext
            self._identifier = None # IdentifierContext
            self.colName = list() # of IdentifierContexts

        def LATERAL(self):
            return self.getToken(fugue_sqlParser.LATERAL, 0)

        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,0)


        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def OUTER(self):
            return self.getToken(fugue_sqlParser.OUTER, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_lateralView

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLateralView" ):
                return visitor.visitLateralView(self)
            else:
                return visitor.visitChildren(self)




    def lateralView(self):

        localctx = fugue_sqlParser.LateralViewContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_lateralView)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2817
            self.match(fugue_sqlParser.LATERAL)
            self.state = 2818
            self.match(fugue_sqlParser.VIEW)
            self.state = 2820
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,368,self._ctx)
            if la_ == 1:
                self.state = 2819
                self.match(fugue_sqlParser.OUTER)


            self.state = 2822
            self.qualifiedName()
            self.state = 2823
            self.match(fugue_sqlParser.T__4)
            self.state = 2832
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -288230376151711712) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0 or (((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0 or (((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & -9205357638345293825) != 0 or (((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & 2096179) != 0:
                self.state = 2824
                self.expression()
                self.state = 2829
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 2825
                    self.match(fugue_sqlParser.T__1)
                    self.state = 2826
                    self.expression()
                    self.state = 2831
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 2834
            self.match(fugue_sqlParser.T__5)
            self.state = 2835
            localctx.tblName = self.identifier()
            self.state = 2847
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,373,self._ctx)
            if la_ == 1:
                self.state = 2837
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,371,self._ctx)
                if la_ == 1:
                    self.state = 2836
                    self.match(fugue_sqlParser.AS)


                self.state = 2839
                localctx._identifier = self.identifier()
                localctx.colName.append(localctx._identifier)
                self.state = 2844
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,372,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2840
                        self.match(fugue_sqlParser.T__1)
                        self.state = 2841
                        localctx._identifier = self.identifier()
                        localctx.colName.append(localctx._identifier) 
                    self.state = 2846
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,372,self._ctx)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SetQuantifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DISTINCT(self):
            return self.getToken(fugue_sqlParser.DISTINCT, 0)

        def ALL(self):
            return self.getToken(fugue_sqlParser.ALL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_setQuantifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSetQuantifier" ):
                return visitor.visitSetQuantifier(self)
            else:
                return visitor.visitChildren(self)




    def setQuantifier(self):

        localctx = fugue_sqlParser.SetQuantifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_setQuantifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2849
            _la = self._input.LA(1)
            if not(_la==60 or _la==120):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def relationPrimary(self):
            return self.getTypedRuleContext(fugue_sqlParser.RelationPrimaryContext,0)


        def joinRelation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.JoinRelationContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.JoinRelationContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_relation

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelation" ):
                return visitor.visitRelation(self)
            else:
                return visitor.visitChildren(self)




    def relation(self):

        localctx = fugue_sqlParser.RelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_relation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2851
            self.relationPrimary()
            self.state = 2855
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,374,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2852
                    self.joinRelation() 
                self.state = 2857
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,374,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JoinRelationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.right = None # RelationPrimaryContext

        def joinType(self):
            return self.getTypedRuleContext(fugue_sqlParser.JoinTypeContext,0)


        def JOIN(self):
            return self.getToken(fugue_sqlParser.JOIN, 0)

        def relationPrimary(self):
            return self.getTypedRuleContext(fugue_sqlParser.RelationPrimaryContext,0)


        def joinCriteria(self):
            return self.getTypedRuleContext(fugue_sqlParser.JoinCriteriaContext,0)


        def NATURAL(self):
            return self.getToken(fugue_sqlParser.NATURAL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_joinRelation

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJoinRelation" ):
                return visitor.visitJoinRelation(self)
            else:
                return visitor.visitChildren(self)




    def joinRelation(self):

        localctx = fugue_sqlParser.JoinRelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_joinRelation)
        try:
            self.state = 2869
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [64, 100, 147, 162, 171, 177, 242, 253]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2858
                self.joinType()
                self.state = 2859
                self.match(fugue_sqlParser.JOIN)
                self.state = 2860
                localctx.right = self.relationPrimary()
                self.state = 2862
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,375,self._ctx)
                if la_ == 1:
                    self.state = 2861
                    self.joinCriteria()


                pass
            elif token in [197]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2864
                self.match(fugue_sqlParser.NATURAL)
                self.state = 2865
                self.joinType()
                self.state = 2866
                self.match(fugue_sqlParser.JOIN)
                self.state = 2867
                localctx.right = self.relationPrimary()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JoinTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INNER(self):
            return self.getToken(fugue_sqlParser.INNER, 0)

        def CROSS(self):
            return self.getToken(fugue_sqlParser.CROSS, 0)

        def LEFT(self):
            return self.getToken(fugue_sqlParser.LEFT, 0)

        def OUTER(self):
            return self.getToken(fugue_sqlParser.OUTER, 0)

        def SEMI(self):
            return self.getToken(fugue_sqlParser.SEMI, 0)

        def RIGHT(self):
            return self.getToken(fugue_sqlParser.RIGHT, 0)

        def FULL(self):
            return self.getToken(fugue_sqlParser.FULL, 0)

        def ANTI(self):
            return self.getToken(fugue_sqlParser.ANTI, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_joinType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJoinType" ):
                return visitor.visitJoinType(self)
            else:
                return visitor.visitChildren(self)




    def joinType(self):

        localctx = fugue_sqlParser.JoinTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_joinType)
        self._la = 0 # Token type
        try:
            self.state = 2895
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,383,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2872
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==162:
                    self.state = 2871
                    self.match(fugue_sqlParser.INNER)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2874
                self.match(fugue_sqlParser.CROSS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2875
                self.match(fugue_sqlParser.LEFT)
                self.state = 2877
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==210:
                    self.state = 2876
                    self.match(fugue_sqlParser.OUTER)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2880
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==177:
                    self.state = 2879
                    self.match(fugue_sqlParser.LEFT)


                self.state = 2882
                self.match(fugue_sqlParser.SEMI)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2883
                self.match(fugue_sqlParser.RIGHT)
                self.state = 2885
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==210:
                    self.state = 2884
                    self.match(fugue_sqlParser.OUTER)


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2887
                self.match(fugue_sqlParser.FULL)
                self.state = 2889
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==210:
                    self.state = 2888
                    self.match(fugue_sqlParser.OUTER)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2892
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==177:
                    self.state = 2891
                    self.match(fugue_sqlParser.LEFT)


                self.state = 2894
                self.match(fugue_sqlParser.ANTI)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JoinCriteriaContext(ParserRuleContext):
        __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(fugue_sqlParser.ON, 0)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def USING(self):
            return self.getToken(fugue_sqlParser.USING, 0)

        def identifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_joinCriteria

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJoinCriteria" ):
                return visitor.visitJoinCriteria(self)
            else:
                return visitor.visitChildren(self)




    def joinCriteria(self):

        localctx = fugue_sqlParser.JoinCriteriaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_joinCriteria)
        try:
            self.state = 2901
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [203]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2897
                self.match(fugue_sqlParser.ON)
                self.state = 2898
                self.booleanExpression(0)
                pass
            elif token in [301]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2899
                self.match(fugue_sqlParser.USING)
                self.state = 2900
                self.identifierList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SampleContext(ParserRuleContext):
        __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(fugue_sqlParser.TABLESAMPLE, 0)

        def sampleMethod(self):
            return self.getTypedRuleContext(fugue_sqlParser.SampleMethodContext,0)


        def SYSTEM(self):
            return self.getToken(fugue_sqlParser.SYSTEM, 0)

        def BERNOULLI(self):
            return self.getToken(fugue_sqlParser.BERNOULLI, 0)

        def RESERVOIR(self):
            return self.getToken(fugue_sqlParser.RESERVOIR, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_sample

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSample" ):
                return visitor.visitSample(self)
            else:
                return visitor.visitChildren(self)




    def sample(self):

        localctx = fugue_sqlParser.SampleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_sample)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2903
            self.match(fugue_sqlParser.TABLESAMPLE)
            self.state = 2905
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 15762598695796736) != 0:
                self.state = 2904
                _la = self._input.LA(1)
                if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 15762598695796736) != 0):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2907
            self.match(fugue_sqlParser.T__4)
            self.state = 2909
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -288230376151711712) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0 or (((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0 or (((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & -9205357638345293825) != 0 or (((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & 2096179) != 0:
                self.state = 2908
                self.sampleMethod()


            self.state = 2911
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SampleMethodContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_sampleMethod

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class SampleByRowsContext(SampleMethodContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.SampleMethodContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSampleByRows" ):
                return visitor.visitSampleByRows(self)
            else:
                return visitor.visitChildren(self)


    class SampleByPercentileContext(SampleMethodContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.SampleMethodContext
            super().__init__(parser)
            self.negativeSign = None # Token
            self.percentage = None # Token
            self.copyFrom(ctx)

        def PERCENTLIT(self):
            return self.getToken(fugue_sqlParser.PERCENTLIT, 0)
        def PERCENT(self):
            return self.getToken(fugue_sqlParser.PERCENT, 0)
        def INTEGER_VALUE(self):
            return self.getToken(fugue_sqlParser.INTEGER_VALUE, 0)
        def DECIMAL_VALUE(self):
            return self.getToken(fugue_sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSampleByPercentile" ):
                return visitor.visitSampleByPercentile(self)
            else:
                return visitor.visitChildren(self)


    class SampleByBucketContext(SampleMethodContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.SampleMethodContext
            super().__init__(parser)
            self.sampleType = None # Token
            self.numerator = None # Token
            self.denominator = None # Token
            self.copyFrom(ctx)

        def OUT(self):
            return self.getToken(fugue_sqlParser.OUT, 0)
        def OF(self):
            return self.getToken(fugue_sqlParser.OF, 0)
        def BUCKET(self):
            return self.getToken(fugue_sqlParser.BUCKET, 0)
        def INTEGER_VALUE(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.INTEGER_VALUE)
            else:
                return self.getToken(fugue_sqlParser.INTEGER_VALUE, i)
        def ON(self):
            return self.getToken(fugue_sqlParser.ON, 0)
        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)

        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSampleByBucket" ):
                return visitor.visitSampleByBucket(self)
            else:
                return visitor.visitChildren(self)


    class SampleByBytesContext(SampleMethodContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.SampleMethodContext
            super().__init__(parser)
            self.bytes = None # ExpressionContext
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSampleByBytes" ):
                return visitor.visitSampleByBytes(self)
            else:
                return visitor.visitChildren(self)



    def sampleMethod(self):

        localctx = fugue_sqlParser.SampleMethodContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_sampleMethod)
        self._la = 0 # Token type
        try:
            self.state = 2937
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,390,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.SampleByPercentileContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2914
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 2913
                    localctx.negativeSign = self.match(fugue_sqlParser.MINUS)


                self.state = 2916
                localctx.percentage = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==334 or _la==336):
                    localctx.percentage = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2917
                _la = self._input.LA(1)
                if not(_la==219 or _la==323):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.SampleByRowsContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2918
                self.expression()
                self.state = 2919
                self.match(fugue_sqlParser.ROWS)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.SampleByBucketContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2921
                localctx.sampleType = self.match(fugue_sqlParser.BUCKET)
                self.state = 2922
                localctx.numerator = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 2923
                self.match(fugue_sqlParser.OUT)
                self.state = 2924
                self.match(fugue_sqlParser.OF)
                self.state = 2925
                localctx.denominator = self.match(fugue_sqlParser.INTEGER_VALUE)
                self.state = 2934
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==203:
                    self.state = 2926
                    self.match(fugue_sqlParser.ON)
                    self.state = 2932
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,388,self._ctx)
                    if la_ == 1:
                        self.state = 2927
                        self.identifier()
                        pass

                    elif la_ == 2:
                        self.state = 2928
                        self.qualifiedName()
                        self.state = 2929
                        self.match(fugue_sqlParser.T__4)
                        self.state = 2930
                        self.match(fugue_sqlParser.T__5)
                        pass




                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.SampleByBytesContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 2936
                localctx.bytes = self.expression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifierSeq(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierSeqContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_identifierList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifierList" ):
                return visitor.visitIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def identifierList(self):

        localctx = fugue_sqlParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_identifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2939
            self.match(fugue_sqlParser.T__4)
            self.state = 2940
            self.identifierSeq()
            self.state = 2941
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._errorCapturingIdentifier = None # ErrorCapturingIdentifierContext
            self.ident = list() # of ErrorCapturingIdentifierContexts

        def errorCapturingIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_identifierSeq

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifierSeq" ):
                return visitor.visitIdentifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def identifierSeq(self):

        localctx = fugue_sqlParser.IdentifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_identifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2943
            localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
            localctx.ident.append(localctx._errorCapturingIdentifier)
            self.state = 2948
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,391,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2944
                    self.match(fugue_sqlParser.T__1)
                    self.state = 2945
                    localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
                    localctx.ident.append(localctx._errorCapturingIdentifier) 
                self.state = 2950
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,391,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OrderedIdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def orderedIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.OrderedIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.OrderedIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_orderedIdentifierList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOrderedIdentifierList" ):
                return visitor.visitOrderedIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def orderedIdentifierList(self):

        localctx = fugue_sqlParser.OrderedIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_orderedIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2951
            self.match(fugue_sqlParser.T__4)
            self.state = 2952
            self.orderedIdentifier()
            self.state = 2957
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2953
                self.match(fugue_sqlParser.T__1)
                self.state = 2954
                self.orderedIdentifier()
                self.state = 2959
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2960
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OrderedIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.ident = None # ErrorCapturingIdentifierContext
            self.ordering = None # Token

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def ASC(self):
            return self.getToken(fugue_sqlParser.ASC, 0)

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_orderedIdentifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOrderedIdentifier" ):
                return visitor.visitOrderedIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def orderedIdentifier(self):

        localctx = fugue_sqlParser.OrderedIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_orderedIdentifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2962
            localctx.ident = self.errorCapturingIdentifier()
            self.state = 2964
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==69 or _la==115:
                self.state = 2963
                localctx.ordering = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==69 or _la==115):
                    localctx.ordering = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierCommentListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifierComment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierCommentContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierCommentContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_identifierCommentList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifierCommentList" ):
                return visitor.visitIdentifierCommentList(self)
            else:
                return visitor.visitChildren(self)




    def identifierCommentList(self):

        localctx = fugue_sqlParser.IdentifierCommentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_identifierCommentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2966
            self.match(fugue_sqlParser.T__4)
            self.state = 2967
            self.identifierComment()
            self.state = 2972
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 2968
                self.match(fugue_sqlParser.T__1)
                self.state = 2969
                self.identifierComment()
                self.state = 2974
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2975
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierCommentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_identifierComment

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifierComment" ):
                return visitor.visitIdentifierComment(self)
            else:
                return visitor.visitChildren(self)




    def identifierComment(self):

        localctx = fugue_sqlParser.IdentifierCommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_identifierComment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2977
            self.identifier()
            self.state = 2979
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==91:
                self.state = 2978
                self.commentSpec()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationPrimaryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_relationPrimary

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class TableValuedFunctionContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def functionTable(self):
            return self.getTypedRuleContext(fugue_sqlParser.FunctionTableContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableValuedFunction" ):
                return visitor.visitTableValuedFunction(self)
            else:
                return visitor.visitChildren(self)


    class InlineTableDefault2Context(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def inlineTable(self):
            return self.getTypedRuleContext(fugue_sqlParser.InlineTableContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineTableDefault2" ):
                return visitor.visitInlineTableDefault2(self)
            else:
                return visitor.visitChildren(self)


    class AliasedRelationContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def relation(self):
            return self.getTypedRuleContext(fugue_sqlParser.RelationContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def sample(self):
            return self.getTypedRuleContext(fugue_sqlParser.SampleContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAliasedRelation" ):
                return visitor.visitAliasedRelation(self)
            else:
                return visitor.visitChildren(self)


    class AliasedQueryContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def sample(self):
            return self.getTypedRuleContext(fugue_sqlParser.SampleContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAliasedQuery" ):
                return visitor.visitAliasedQuery(self)
            else:
                return visitor.visitChildren(self)


    class TableNameContext(RelationPrimaryContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.RelationPrimaryContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)

        def fugueDataFrameMember(self):
            return self.getTypedRuleContext(fugue_sqlParser.FugueDataFrameMemberContext,0)

        def sample(self):
            return self.getTypedRuleContext(fugue_sqlParser.SampleContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableName" ):
                return visitor.visitTableName(self)
            else:
                return visitor.visitChildren(self)



    def relationPrimary(self):

        localctx = fugue_sqlParser.RelationPrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_relationPrimary)
        try:
            self.state = 3008
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,400,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.TableNameContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2981
                self.multipartIdentifier()
                self.state = 2983
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,396,self._ctx)
                if la_ == 1:
                    self.state = 2982
                    self.fugueDataFrameMember()


                self.state = 2986
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,397,self._ctx)
                if la_ == 1:
                    self.state = 2985
                    self.sample()


                self.state = 2988
                self.tableAlias()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.AliasedQueryContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2990
                self.match(fugue_sqlParser.T__4)
                self.state = 2991
                self.query()
                self.state = 2992
                self.match(fugue_sqlParser.T__5)
                self.state = 2994
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,398,self._ctx)
                if la_ == 1:
                    self.state = 2993
                    self.sample()


                self.state = 2996
                self.tableAlias()
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.AliasedRelationContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2998
                self.match(fugue_sqlParser.T__4)
                self.state = 2999
                self.relation()
                self.state = 3000
                self.match(fugue_sqlParser.T__5)
                self.state = 3002
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,399,self._ctx)
                if la_ == 1:
                    self.state = 3001
                    self.sample()


                self.state = 3004
                self.tableAlias()
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.InlineTableDefault2Context(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 3006
                self.inlineTable()
                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.TableValuedFunctionContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 3007
                self.functionTable()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InlineTableContext(ParserRuleContext):
        __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(fugue_sqlParser.VALUES, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_inlineTable

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineTable" ):
                return visitor.visitInlineTable(self)
            else:
                return visitor.visitChildren(self)




    def inlineTable(self):

        localctx = fugue_sqlParser.InlineTableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_inlineTable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3010
            self.match(fugue_sqlParser.VALUES)
            self.state = 3011
            self.expression()
            self.state = 3016
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,401,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3012
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3013
                    self.expression() 
                self.state = 3018
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,401,self._ctx)

            self.state = 3019
            self.tableAlias()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTableContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.funcName = None # ErrorCapturingIdentifierContext

        def tableAlias(self):
            return self.getTypedRuleContext(fugue_sqlParser.TableAliasContext,0)


        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_functionTable

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTable" ):
                return visitor.visitFunctionTable(self)
            else:
                return visitor.visitChildren(self)




    def functionTable(self):

        localctx = fugue_sqlParser.FunctionTableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_functionTable)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3021
            localctx.funcName = self.errorCapturingIdentifier()
            self.state = 3022
            self.match(fugue_sqlParser.T__4)
            self.state = 3031
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -288230376151711712) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0 or (((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0 or (((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & -9205357638345293825) != 0 or (((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & 2096179) != 0:
                self.state = 3023
                self.expression()
                self.state = 3028
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 3024
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3025
                    self.expression()
                    self.state = 3030
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 3033
            self.match(fugue_sqlParser.T__5)
            self.state = 3034
            self.tableAlias()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableAliasContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def strictIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.StrictIdentifierContext,0)


        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def identifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierListContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_tableAlias

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableAlias" ):
                return visitor.visitTableAlias(self)
            else:
                return visitor.visitChildren(self)




    def tableAlias(self):

        localctx = fugue_sqlParser.TableAliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_tableAlias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3043
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,406,self._ctx)
            if la_ == 1:
                self.state = 3037
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,404,self._ctx)
                if la_ == 1:
                    self.state = 3036
                    self.match(fugue_sqlParser.AS)


                self.state = 3039
                self.strictIdentifier()
                self.state = 3041
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,405,self._ctx)
                if la_ == 1:
                    self.state = 3040
                    self.identifierList()




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RowFormatContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_rowFormat

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class RowFormatSerdeContext(RowFormatContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.RowFormatContext
            super().__init__(parser)
            self.name = None # Token
            self.props = None # TablePropertyListContext
            self.copyFrom(ctx)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)
        def FORMAT(self):
            return self.getToken(fugue_sqlParser.FORMAT, 0)
        def SERDE(self):
            return self.getToken(fugue_sqlParser.SERDE, 0)
        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)
        def WITH(self):
            return self.getToken(fugue_sqlParser.WITH, 0)
        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)
        def tablePropertyList(self):
            return self.getTypedRuleContext(fugue_sqlParser.TablePropertyListContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRowFormatSerde" ):
                return visitor.visitRowFormatSerde(self)
            else:
                return visitor.visitChildren(self)


    class RowFormatDelimitedContext(RowFormatContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.RowFormatContext
            super().__init__(parser)
            self.fieldsTerminatedBy = None # Token
            self.escapedBy = None # Token
            self.collectionItemsTerminatedBy = None # Token
            self.keysTerminatedBy = None # Token
            self.linesSeparatedBy = None # Token
            self.nullDefinedAs = None # Token
            self.copyFrom(ctx)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)
        def FORMAT(self):
            return self.getToken(fugue_sqlParser.FORMAT, 0)
        def DELIMITED(self):
            return self.getToken(fugue_sqlParser.DELIMITED, 0)
        def FIELDS(self):
            return self.getToken(fugue_sqlParser.FIELDS, 0)
        def TERMINATED(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.TERMINATED)
            else:
                return self.getToken(fugue_sqlParser.TERMINATED, i)
        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.BY)
            else:
                return self.getToken(fugue_sqlParser.BY, i)
        def COLLECTION(self):
            return self.getToken(fugue_sqlParser.COLLECTION, 0)
        def ITEMS(self):
            return self.getToken(fugue_sqlParser.ITEMS, 0)
        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)
        def KEYS(self):
            return self.getToken(fugue_sqlParser.KEYS, 0)
        def LINES(self):
            return self.getToken(fugue_sqlParser.LINES, 0)
        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)
        def DEFINED(self):
            return self.getToken(fugue_sqlParser.DEFINED, 0)
        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)
        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.STRING)
            else:
                return self.getToken(fugue_sqlParser.STRING, i)
        def ESCAPED(self):
            return self.getToken(fugue_sqlParser.ESCAPED, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRowFormatDelimited" ):
                return visitor.visitRowFormatDelimited(self)
            else:
                return visitor.visitChildren(self)



    def rowFormat(self):

        localctx = fugue_sqlParser.RowFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_rowFormat)
        try:
            self.state = 3094
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,414,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.RowFormatSerdeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3045
                self.match(fugue_sqlParser.ROW)
                self.state = 3046
                self.match(fugue_sqlParser.FORMAT)
                self.state = 3047
                self.match(fugue_sqlParser.SERDE)
                self.state = 3048
                localctx.name = self.match(fugue_sqlParser.STRING)
                self.state = 3052
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,407,self._ctx)
                if la_ == 1:
                    self.state = 3049
                    self.match(fugue_sqlParser.WITH)
                    self.state = 3050
                    self.match(fugue_sqlParser.SERDEPROPERTIES)
                    self.state = 3051
                    localctx.props = self.tablePropertyList()


                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.RowFormatDelimitedContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3054
                self.match(fugue_sqlParser.ROW)
                self.state = 3055
                self.match(fugue_sqlParser.FORMAT)
                self.state = 3056
                self.match(fugue_sqlParser.DELIMITED)
                self.state = 3066
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,409,self._ctx)
                if la_ == 1:
                    self.state = 3057
                    self.match(fugue_sqlParser.FIELDS)
                    self.state = 3058
                    self.match(fugue_sqlParser.TERMINATED)
                    self.state = 3059
                    self.match(fugue_sqlParser.BY)
                    self.state = 3060
                    localctx.fieldsTerminatedBy = self.match(fugue_sqlParser.STRING)
                    self.state = 3064
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,408,self._ctx)
                    if la_ == 1:
                        self.state = 3061
                        self.match(fugue_sqlParser.ESCAPED)
                        self.state = 3062
                        self.match(fugue_sqlParser.BY)
                        self.state = 3063
                        localctx.escapedBy = self.match(fugue_sqlParser.STRING)




                self.state = 3073
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,410,self._ctx)
                if la_ == 1:
                    self.state = 3068
                    self.match(fugue_sqlParser.COLLECTION)
                    self.state = 3069
                    self.match(fugue_sqlParser.ITEMS)
                    self.state = 3070
                    self.match(fugue_sqlParser.TERMINATED)
                    self.state = 3071
                    self.match(fugue_sqlParser.BY)
                    self.state = 3072
                    localctx.collectionItemsTerminatedBy = self.match(fugue_sqlParser.STRING)


                self.state = 3080
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,411,self._ctx)
                if la_ == 1:
                    self.state = 3075
                    self.match(fugue_sqlParser.MAP)
                    self.state = 3076
                    self.match(fugue_sqlParser.KEYS)
                    self.state = 3077
                    self.match(fugue_sqlParser.TERMINATED)
                    self.state = 3078
                    self.match(fugue_sqlParser.BY)
                    self.state = 3079
                    localctx.keysTerminatedBy = self.match(fugue_sqlParser.STRING)


                self.state = 3086
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,412,self._ctx)
                if la_ == 1:
                    self.state = 3082
                    self.match(fugue_sqlParser.LINES)
                    self.state = 3083
                    self.match(fugue_sqlParser.TERMINATED)
                    self.state = 3084
                    self.match(fugue_sqlParser.BY)
                    self.state = 3085
                    localctx.linesSeparatedBy = self.match(fugue_sqlParser.STRING)


                self.state = 3092
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,413,self._ctx)
                if la_ == 1:
                    self.state = 3088
                    self.match(fugue_sqlParser.THENULL)
                    self.state = 3089
                    self.match(fugue_sqlParser.DEFINED)
                    self.state = 3090
                    self.match(fugue_sqlParser.AS)
                    self.state = 3091
                    localctx.nullDefinedAs = self.match(fugue_sqlParser.STRING)


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MultipartIdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def multipartIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.MultipartIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_multipartIdentifierList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultipartIdentifierList" ):
                return visitor.visitMultipartIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def multipartIdentifierList(self):

        localctx = fugue_sqlParser.MultipartIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_multipartIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3096
            self.multipartIdentifier()
            self.state = 3101
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 3097
                self.match(fugue_sqlParser.T__1)
                self.state = 3098
                self.multipartIdentifier()
                self.state = 3103
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MultipartIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._errorCapturingIdentifier = None # ErrorCapturingIdentifierContext
            self.parts = list() # of ErrorCapturingIdentifierContexts

        def errorCapturingIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_multipartIdentifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultipartIdentifier" ):
                return visitor.visitMultipartIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def multipartIdentifier(self):

        localctx = fugue_sqlParser.MultipartIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_multipartIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3104
            localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
            localctx.parts.append(localctx._errorCapturingIdentifier)
            self.state = 3109
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,416,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3105
                    self.match(fugue_sqlParser.T__6)
                    self.state = 3106
                    localctx._errorCapturingIdentifier = self.errorCapturingIdentifier()
                    localctx.parts.append(localctx._errorCapturingIdentifier) 
                self.state = 3111
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,416,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TableIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.db = None # ErrorCapturingIdentifierContext
            self.table = None # ErrorCapturingIdentifierContext

        def errorCapturingIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_tableIdentifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTableIdentifier" ):
                return visitor.visitTableIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def tableIdentifier(self):

        localctx = fugue_sqlParser.TableIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_tableIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3115
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,417,self._ctx)
            if la_ == 1:
                self.state = 3112
                localctx.db = self.errorCapturingIdentifier()
                self.state = 3113
                self.match(fugue_sqlParser.T__6)


            self.state = 3117
            localctx.table = self.errorCapturingIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.db = None # ErrorCapturingIdentifierContext
            self.function = None # ErrorCapturingIdentifierContext

        def errorCapturingIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ErrorCapturingIdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_functionIdentifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionIdentifier" ):
                return visitor.visitFunctionIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def functionIdentifier(self):

        localctx = fugue_sqlParser.FunctionIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_functionIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3122
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,418,self._ctx)
            if la_ == 1:
                self.state = 3119
                localctx.db = self.errorCapturingIdentifier()
                self.state = 3120
                self.match(fugue_sqlParser.T__6)


            self.state = 3124
            localctx.function = self.errorCapturingIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamedExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.name = None # ErrorCapturingIdentifierContext

        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)


        def identifierList(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierListContext,0)


        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_namedExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamedExpression" ):
                return visitor.visitNamedExpression(self)
            else:
                return visitor.visitChildren(self)




    def namedExpression(self):

        localctx = fugue_sqlParser.NamedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_namedExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3126
            self.expression()
            self.state = 3134
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,421,self._ctx)
            if la_ == 1:
                self.state = 3128
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,419,self._ctx)
                if la_ == 1:
                    self.state = 3127
                    self.match(fugue_sqlParser.AS)


                self.state = 3132
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                    self.state = 3130
                    localctx.name = self.errorCapturingIdentifier()
                    pass
                elif token in [5]:
                    self.state = 3131
                    self.identifierList()
                    pass
                else:
                    raise NoViableAltException(self)



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamedExpressionSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namedExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_namedExpressionSeq

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamedExpressionSeq" ):
                return visitor.visitNamedExpressionSeq(self)
            else:
                return visitor.visitChildren(self)




    def namedExpressionSeq(self):

        localctx = fugue_sqlParser.NamedExpressionSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_namedExpressionSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3136
            self.namedExpression()
            self.state = 3141
            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 = 3137
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3138
                    self.namedExpression() 
                self.state = 3143
                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 TransformListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._transform = None # TransformContext
            self.transforms = list() # of TransformContexts

        def transform(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TransformContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TransformContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_transformList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTransformList" ):
                return visitor.visitTransformList(self)
            else:
                return visitor.visitChildren(self)




    def transformList(self):

        localctx = fugue_sqlParser.TransformListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_transformList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3144
            self.match(fugue_sqlParser.T__4)
            self.state = 3145
            localctx._transform = self.transform()
            localctx.transforms.append(localctx._transform)
            self.state = 3150
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 3146
                self.match(fugue_sqlParser.T__1)
                self.state = 3147
                localctx._transform = self.transform()
                localctx.transforms.append(localctx._transform)
                self.state = 3152
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 3153
            self.match(fugue_sqlParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TransformContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_transform

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class IdentityTransformContext(TransformContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.TransformContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentityTransform" ):
                return visitor.visitIdentityTransform(self)
            else:
                return visitor.visitChildren(self)


    class ApplyTransformContext(TransformContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.TransformContext
            super().__init__(parser)
            self.transformName = None # IdentifierContext
            self._transformArgument = None # TransformArgumentContext
            self.argument = list() # of TransformArgumentContexts
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)

        def transformArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.TransformArgumentContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.TransformArgumentContext,i)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApplyTransform" ):
                return visitor.visitApplyTransform(self)
            else:
                return visitor.visitChildren(self)



    def transform(self):

        localctx = fugue_sqlParser.TransformContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_transform)
        self._la = 0 # Token type
        try:
            self.state = 3168
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,425,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.IdentityTransformContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3155
                self.qualifiedName()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.ApplyTransformContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3156
                localctx.transformName = self.identifier()
                self.state = 3157
                self.match(fugue_sqlParser.T__4)
                self.state = 3158
                localctx._transformArgument = self.transformArgument()
                localctx.argument.append(localctx._transformArgument)
                self.state = 3163
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 3159
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3160
                    localctx._transformArgument = self.transformArgument()
                    localctx.argument.append(localctx._transformArgument)
                    self.state = 3165
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 3166
                self.match(fugue_sqlParser.T__5)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TransformArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,0)


        def constant(self):
            return self.getTypedRuleContext(fugue_sqlParser.ConstantContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_transformArgument

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTransformArgument" ):
                return visitor.visitTransformArgument(self)
            else:
                return visitor.visitChildren(self)




    def transformArgument(self):

        localctx = fugue_sqlParser.TransformArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_transformArgument)
        try:
            self.state = 3172
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,426,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3170
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3171
                self.constant()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_expression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpression" ):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)




    def expression(self):

        localctx = fugue_sqlParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3174
            self.booleanExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_booleanExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class LogicalNotContext(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.BooleanExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)
        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalNot" ):
                return visitor.visitLogicalNot(self)
            else:
                return visitor.visitChildren(self)


    class PredicatedContext(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.BooleanExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def valueExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,0)

        def predicate(self):
            return self.getTypedRuleContext(fugue_sqlParser.PredicateContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPredicated" ):
                return visitor.visitPredicated(self)
            else:
                return visitor.visitChildren(self)


    class ExistsContext(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.BooleanExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)
        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExists" ):
                return visitor.visitExists(self)
            else:
                return visitor.visitChildren(self)


    class LogicalBinaryContext(BooleanExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.BooleanExpressionContext
            super().__init__(parser)
            self.left = None # BooleanExpressionContext
            self.theOperator = None # Token
            self.right = None # BooleanExpressionContext
            self.copyFrom(ctx)

        def booleanExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.BooleanExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,i)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)
        def OR(self):
            return self.getToken(fugue_sqlParser.OR, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalBinary" ):
                return visitor.visitLogicalBinary(self)
            else:
                return visitor.visitChildren(self)



    def booleanExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = fugue_sqlParser.BooleanExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 342
        self.enterRecursionRule(localctx, 342, self.RULE_booleanExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3188
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,428,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.LogicalNotContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 3177
                self.match(fugue_sqlParser.NOT)
                self.state = 3178
                self.booleanExpression(5)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.ExistsContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3179
                self.match(fugue_sqlParser.EXISTS)
                self.state = 3180
                self.match(fugue_sqlParser.T__4)
                self.state = 3181
                self.query()
                self.state = 3182
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.PredicatedContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3184
                self.valueExpression(0)
                self.state = 3186
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,427,self._ctx)
                if la_ == 1:
                    self.state = 3185
                    self.predicate()


                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 3198
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,430,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 = 3196
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,429,self._ctx)
                    if la_ == 1:
                        localctx = fugue_sqlParser.LogicalBinaryContext(self, fugue_sqlParser.BooleanExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpression)
                        self.state = 3190
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 3191
                        localctx.theOperator = self.match(fugue_sqlParser.AND)
                        self.state = 3192
                        localctx.right = self.booleanExpression(3)
                        pass

                    elif la_ == 2:
                        localctx = fugue_sqlParser.LogicalBinaryContext(self, fugue_sqlParser.BooleanExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpression)
                        self.state = 3193
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 3194
                        localctx.theOperator = self.match(fugue_sqlParser.OR)
                        self.state = 3195
                        localctx.right = self.booleanExpression(2)
                        pass

             
                self.state = 3200
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,430,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
            self.kind = None # Token
            self.lower = None # ValueExpressionContext
            self.upper = None # ValueExpressionContext
            self.pattern = None # ValueExpressionContext
            self.quantifier = None # Token
            self.escapeChar = None # Token
            self.right = None # ValueExpressionContext

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def BETWEEN(self):
            return self.getToken(fugue_sqlParser.BETWEEN, 0)

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)


        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)

        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)


        def RLIKE(self):
            return self.getToken(fugue_sqlParser.RLIKE, 0)

        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)

        def ANY(self):
            return self.getToken(fugue_sqlParser.ANY, 0)

        def SOME(self):
            return self.getToken(fugue_sqlParser.SOME, 0)

        def ALL(self):
            return self.getToken(fugue_sqlParser.ALL, 0)

        def ESCAPE(self):
            return self.getToken(fugue_sqlParser.ESCAPE, 0)

        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def IS(self):
            return self.getToken(fugue_sqlParser.IS, 0)

        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)

        def TRUE(self):
            return self.getToken(fugue_sqlParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(fugue_sqlParser.FALSE, 0)

        def UNKNOWN(self):
            return self.getToken(fugue_sqlParser.UNKNOWN, 0)

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)

        def DISTINCT(self):
            return self.getToken(fugue_sqlParser.DISTINCT, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_predicate

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPredicate" ):
                return visitor.visitPredicate(self)
            else:
                return visitor.visitChildren(self)




    def predicate(self):

        localctx = fugue_sqlParser.PredicateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_predicate)
        self._la = 0 # Token type
        try:
            self.state = 3283
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,444,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3202
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3201
                    self.match(fugue_sqlParser.NOT)


                self.state = 3204
                localctx.kind = self.match(fugue_sqlParser.BETWEEN)
                self.state = 3205
                localctx.lower = self.valueExpression(0)
                self.state = 3206
                self.match(fugue_sqlParser.AND)
                self.state = 3207
                localctx.upper = self.valueExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3210
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3209
                    self.match(fugue_sqlParser.NOT)


                self.state = 3212
                localctx.kind = self.match(fugue_sqlParser.IN)
                self.state = 3213
                self.match(fugue_sqlParser.T__4)
                self.state = 3214
                self.expression()
                self.state = 3219
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 3215
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3216
                    self.expression()
                    self.state = 3221
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 3222
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3225
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3224
                    self.match(fugue_sqlParser.NOT)


                self.state = 3227
                localctx.kind = self.match(fugue_sqlParser.IN)
                self.state = 3228
                self.match(fugue_sqlParser.T__4)
                self.state = 3229
                self.query()
                self.state = 3230
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3233
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3232
                    self.match(fugue_sqlParser.NOT)


                self.state = 3235
                localctx.kind = self.match(fugue_sqlParser.RLIKE)
                self.state = 3236
                localctx.pattern = self.valueExpression(0)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 3238
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3237
                    self.match(fugue_sqlParser.NOT)


                self.state = 3240
                localctx.kind = self.match(fugue_sqlParser.LIKE)
                self.state = 3241
                localctx.quantifier = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==60 or _la==65 or _la==263):
                    localctx.quantifier = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3255
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,438,self._ctx)
                if la_ == 1:
                    self.state = 3242
                    self.match(fugue_sqlParser.T__4)
                    self.state = 3243
                    self.match(fugue_sqlParser.T__5)
                    pass

                elif la_ == 2:
                    self.state = 3244
                    self.match(fugue_sqlParser.T__4)
                    self.state = 3245
                    self.expression()
                    self.state = 3250
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==2:
                        self.state = 3246
                        self.match(fugue_sqlParser.T__1)
                        self.state = 3247
                        self.expression()
                        self.state = 3252
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 3253
                    self.match(fugue_sqlParser.T__5)
                    pass


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 3258
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3257
                    self.match(fugue_sqlParser.NOT)


                self.state = 3260
                localctx.kind = self.match(fugue_sqlParser.LIKE)
                self.state = 3261
                localctx.pattern = self.valueExpression(0)
                self.state = 3264
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,440,self._ctx)
                if la_ == 1:
                    self.state = 3262
                    self.match(fugue_sqlParser.ESCAPE)
                    self.state = 3263
                    localctx.escapeChar = self.match(fugue_sqlParser.STRING)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 3266
                self.match(fugue_sqlParser.IS)
                self.state = 3268
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3267
                    self.match(fugue_sqlParser.NOT)


                self.state = 3270
                localctx.kind = self.match(fugue_sqlParser.THENULL)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 3271
                self.match(fugue_sqlParser.IS)
                self.state = 3273
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3272
                    self.match(fugue_sqlParser.NOT)


                self.state = 3275
                localctx.kind = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==135 or _la==287 or _la==295):
                    localctx.kind = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 3276
                self.match(fugue_sqlParser.IS)
                self.state = 3278
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==199:
                    self.state = 3277
                    self.match(fugue_sqlParser.NOT)


                self.state = 3280
                localctx.kind = self.match(fugue_sqlParser.DISTINCT)
                self.state = 3281
                self.match(fugue_sqlParser.FROM)
                self.state = 3282
                localctx.right = self.valueExpression(0)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ValueExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_valueExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class ValueExpressionDefaultContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.PrimaryExpressionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitValueExpressionDefault" ):
                return visitor.visitValueExpressionDefault(self)
            else:
                return visitor.visitChildren(self)


    class ComparisonContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.left = None # ValueExpressionContext
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

        def comparisonOperator(self):
            return self.getTypedRuleContext(fugue_sqlParser.ComparisonOperatorContext,0)

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComparison" ):
                return visitor.visitComparison(self)
            else:
                return visitor.visitChildren(self)


    class ArithmeticBinaryContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.left = None # ValueExpressionContext
            self.theOperator = None # Token
            self.right = None # ValueExpressionContext
            self.copyFrom(ctx)

        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)
        def SLASH(self):
            return self.getToken(fugue_sqlParser.SLASH, 0)
        def PERCENT(self):
            return self.getToken(fugue_sqlParser.PERCENT, 0)
        def DIV(self):
            return self.getToken(fugue_sqlParser.DIV, 0)
        def PLUS(self):
            return self.getToken(fugue_sqlParser.PLUS, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)
        def CONCAT_PIPE(self):
            return self.getToken(fugue_sqlParser.CONCAT_PIPE, 0)
        def AMPERSAND(self):
            return self.getToken(fugue_sqlParser.AMPERSAND, 0)
        def HAT(self):
            return self.getToken(fugue_sqlParser.HAT, 0)
        def PIPE(self):
            return self.getToken(fugue_sqlParser.PIPE, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArithmeticBinary" ):
                return visitor.visitArithmeticBinary(self)
            else:
                return visitor.visitChildren(self)


    class ArithmeticUnaryContext(ValueExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ValueExpressionContext
            super().__init__(parser)
            self.theOperator = None # Token
            self.copyFrom(ctx)

        def valueExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,0)

        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)
        def PLUS(self):
            return self.getToken(fugue_sqlParser.PLUS, 0)
        def TILDE(self):
            return self.getToken(fugue_sqlParser.TILDE, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArithmeticUnary" ):
                return visitor.visitArithmeticUnary(self)
            else:
                return visitor.visitChildren(self)



    def valueExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = fugue_sqlParser.ValueExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 346
        self.enterRecursionRule(localctx, 346, self.RULE_valueExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3289
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,445,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.ValueExpressionDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 3286
                self.primaryExpression(0)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.ArithmeticUnaryContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3287
                localctx.theOperator = self._input.LT(1)
                _la = self._input.LA(1)
                if not((((_la - 319)) & ~0x3f) == 0 and ((1 << (_la - 319)) & 67) != 0):
                    localctx.theOperator = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3288
                self.valueExpression(7)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 3312
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,447,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 = 3310
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,446,self._ctx)
                    if la_ == 1:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3291
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 3292
                        localctx.theOperator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not((((_la - 321)) & ~0x3f) == 0 and ((1 << (_la - 321)) & 15) != 0):
                            localctx.theOperator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 3293
                        localctx.right = self.valueExpression(7)
                        pass

                    elif la_ == 2:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3294
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 3295
                        localctx.theOperator = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not((((_la - 319)) & ~0x3f) == 0 and ((1 << (_la - 319)) & 515) != 0):
                            localctx.theOperator = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 3296
                        localctx.right = self.valueExpression(6)
                        pass

                    elif la_ == 3:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3297
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 3298
                        localctx.theOperator = self.match(fugue_sqlParser.AMPERSAND)
                        self.state = 3299
                        localctx.right = self.valueExpression(5)
                        pass

                    elif la_ == 4:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3300
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 3301
                        localctx.theOperator = self.match(fugue_sqlParser.HAT)
                        self.state = 3302
                        localctx.right = self.valueExpression(4)
                        pass

                    elif la_ == 5:
                        localctx = fugue_sqlParser.ArithmeticBinaryContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3303
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 3304
                        localctx.theOperator = self.match(fugue_sqlParser.PIPE)
                        self.state = 3305
                        localctx.right = self.valueExpression(3)
                        pass

                    elif la_ == 6:
                        localctx = fugue_sqlParser.ComparisonContext(self, fugue_sqlParser.ValueExpressionContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpression)
                        self.state = 3306
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 3307
                        self.comparisonOperator()
                        self.state = 3308
                        localctx.right = self.valueExpression(2)
                        pass

             
                self.state = 3314
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,447,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_primaryExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class StructContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self._namedExpression = None # NamedExpressionContext
            self.argument = list() # of NamedExpressionContexts
            self.copyFrom(ctx)

        def STRUCT(self):
            return self.getToken(fugue_sqlParser.STRUCT, 0)
        def namedExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionContext,i)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStruct" ):
                return visitor.visitStruct(self)
            else:
                return visitor.visitChildren(self)


    class DereferenceContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.base = None # PrimaryExpressionContext
            self.fieldName = None # IdentifierContext
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.PrimaryExpressionContext,0)

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDereference" ):
                return visitor.visitDereference(self)
            else:
                return visitor.visitChildren(self)


    class SimpleCaseContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.value = None # ExpressionContext
            self.elseExpression = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(fugue_sqlParser.CASE, 0)
        def END(self):
            return self.getToken(fugue_sqlParser.END, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)

        def whenClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.WhenClauseContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.WhenClauseContext,i)

        def ELSE(self):
            return self.getToken(fugue_sqlParser.ELSE, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleCase" ):
                return visitor.visitSimpleCase(self)
            else:
                return visitor.visitChildren(self)


    class ColumnReferenceContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitColumnReference" ):
                return visitor.visitColumnReference(self)
            else:
                return visitor.visitChildren(self)


    class RowConstructorContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def namedExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NamedExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.NamedExpressionContext,i)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRowConstructor" ):
                return visitor.visitRowConstructor(self)
            else:
                return visitor.visitChildren(self)


    class LastContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)
        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)

        def IGNORE(self):
            return self.getToken(fugue_sqlParser.IGNORE, 0)
        def THENULLS(self):
            return self.getToken(fugue_sqlParser.THENULLS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLast" ):
                return visitor.visitLast(self)
            else:
                return visitor.visitChildren(self)


    class StarContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)
        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStar" ):
                return visitor.visitStar(self)
            else:
                return visitor.visitChildren(self)


    class OverlayContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.iinput = None # ValueExpressionContext
            self.replace = None # ValueExpressionContext
            self.position = None # ValueExpressionContext
            self.length = None # ValueExpressionContext
            self.copyFrom(ctx)

        def OVERLAY(self):
            return self.getToken(fugue_sqlParser.OVERLAY, 0)
        def PLACING(self):
            return self.getToken(fugue_sqlParser.PLACING, 0)
        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)

        def FOR(self):
            return self.getToken(fugue_sqlParser.FOR, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOverlay" ):
                return visitor.visitOverlay(self)
            else:
                return visitor.visitChildren(self)


    class SubscriptContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.value = None # PrimaryExpressionContext
            self.index = None # ValueExpressionContext
            self.copyFrom(ctx)

        def primaryExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.PrimaryExpressionContext,0)

        def valueExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubscript" ):
                return visitor.visitSubscript(self)
            else:
                return visitor.visitChildren(self)


    class SubqueryExpressionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def query(self):
            return self.getTypedRuleContext(fugue_sqlParser.QueryContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubqueryExpression" ):
                return visitor.visitSubqueryExpression(self)
            else:
                return visitor.visitChildren(self)


    class SubstringContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.istr = None # ValueExpressionContext
            self.pos = None # ValueExpressionContext
            self.ilen = None # ValueExpressionContext
            self.copyFrom(ctx)

        def SUBSTR(self):
            return self.getToken(fugue_sqlParser.SUBSTR, 0)
        def SUBSTRING(self):
            return self.getToken(fugue_sqlParser.SUBSTRING, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def FOR(self):
            return self.getToken(fugue_sqlParser.FOR, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubstring" ):
                return visitor.visitSubstring(self)
            else:
                return visitor.visitChildren(self)


    class CurrentDatetimeContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.name = None # Token
            self.copyFrom(ctx)

        def CURRENT_DATE(self):
            return self.getToken(fugue_sqlParser.CURRENT_DATE, 0)
        def CURRENT_TIMESTAMP(self):
            return self.getToken(fugue_sqlParser.CURRENT_TIMESTAMP, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCurrentDatetime" ):
                return visitor.visitCurrentDatetime(self)
            else:
                return visitor.visitChildren(self)


    class CastContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CAST(self):
            return self.getToken(fugue_sqlParser.CAST, 0)
        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)
        def dataType(self):
            return self.getTypedRuleContext(fugue_sqlParser.DataTypeContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCast" ):
                return visitor.visitCast(self)
            else:
                return visitor.visitChildren(self)


    class ConstantDefaultContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def constant(self):
            return self.getTypedRuleContext(fugue_sqlParser.ConstantContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstantDefault" ):
                return visitor.visitConstantDefault(self)
            else:
                return visitor.visitChildren(self)


    class LambdaContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)

        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambda" ):
                return visitor.visitLambda(self)
            else:
                return visitor.visitChildren(self)


    class ParenthesizedExpressionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParenthesizedExpression" ):
                return visitor.visitParenthesizedExpression(self)
            else:
                return visitor.visitChildren(self)


    class ExtractContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.field = None # IdentifierContext
            self.source = None # ValueExpressionContext
            self.copyFrom(ctx)

        def EXTRACT(self):
            return self.getToken(fugue_sqlParser.EXTRACT, 0)
        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)

        def valueExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExtract" ):
                return visitor.visitExtract(self)
            else:
                return visitor.visitChildren(self)


    class TrimContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.trimOption = None # Token
            self.trimStr = None # ValueExpressionContext
            self.srcStr = None # ValueExpressionContext
            self.copyFrom(ctx)

        def TRIM(self):
            return self.getToken(fugue_sqlParser.TRIM, 0)
        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)

        def BOTH(self):
            return self.getToken(fugue_sqlParser.BOTH, 0)
        def LEADING(self):
            return self.getToken(fugue_sqlParser.LEADING, 0)
        def TRAILING(self):
            return self.getToken(fugue_sqlParser.TRAILING, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrim" ):
                return visitor.visitTrim(self)
            else:
                return visitor.visitChildren(self)


    class FunctionCallContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self._expression = None # ExpressionContext
            self.argument = list() # of ExpressionContexts
            self.where = None # BooleanExpressionContext
            self.copyFrom(ctx)

        def functionName(self):
            return self.getTypedRuleContext(fugue_sqlParser.FunctionNameContext,0)

        def FILTER(self):
            return self.getToken(fugue_sqlParser.FILTER, 0)
        def WHERE(self):
            return self.getToken(fugue_sqlParser.WHERE, 0)
        def OVER(self):
            return self.getToken(fugue_sqlParser.OVER, 0)
        def windowSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowSpecContext,0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)

        def booleanExpression(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanExpressionContext,0)

        def setQuantifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.SetQuantifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionCall" ):
                return visitor.visitFunctionCall(self)
            else:
                return visitor.visitChildren(self)


    class SearchedCaseContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.elseExpression = None # ExpressionContext
            self.copyFrom(ctx)

        def CASE(self):
            return self.getToken(fugue_sqlParser.CASE, 0)
        def END(self):
            return self.getToken(fugue_sqlParser.END, 0)
        def whenClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.WhenClauseContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.WhenClauseContext,i)

        def ELSE(self):
            return self.getToken(fugue_sqlParser.ELSE, 0)
        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSearchedCase" ):
                return visitor.visitSearchedCase(self)
            else:
                return visitor.visitChildren(self)


    class PositionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.substr = None # ValueExpressionContext
            self.istr = None # ValueExpressionContext
            self.copyFrom(ctx)

        def POSITION(self):
            return self.getToken(fugue_sqlParser.POSITION, 0)
        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)
        def valueExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ValueExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ValueExpressionContext,i)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPosition" ):
                return visitor.visitPosition(self)
            else:
                return visitor.visitChildren(self)


    class FirstContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)
        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)

        def IGNORE(self):
            return self.getToken(fugue_sqlParser.IGNORE, 0)
        def THENULLS(self):
            return self.getToken(fugue_sqlParser.THENULLS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFirst" ):
                return visitor.visitFirst(self)
            else:
                return visitor.visitChildren(self)



    def primaryExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = fugue_sqlParser.PrimaryExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 348
        self.enterRecursionRule(localctx, 348, self.RULE_primaryExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3499
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,467,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.CurrentDatetimeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 3316
                localctx.name = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==103 or _la==105):
                    localctx.name = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.SearchedCaseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3317
                self.match(fugue_sqlParser.CASE)
                self.state = 3319 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 3318
                    self.whenClause()
                    self.state = 3321 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==305):
                        break

                self.state = 3325
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==123:
                    self.state = 3323
                    self.match(fugue_sqlParser.ELSE)
                    self.state = 3324
                    localctx.elseExpression = self.expression()


                self.state = 3327
                self.match(fugue_sqlParser.END)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.SimpleCaseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3329
                self.match(fugue_sqlParser.CASE)
                self.state = 3330
                localctx.value = self.expression()
                self.state = 3332 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 3331
                    self.whenClause()
                    self.state = 3334 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==305):
                        break

                self.state = 3338
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==123:
                    self.state = 3336
                    self.match(fugue_sqlParser.ELSE)
                    self.state = 3337
                    localctx.elseExpression = self.expression()


                self.state = 3340
                self.match(fugue_sqlParser.END)
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.CastContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3342
                self.match(fugue_sqlParser.CAST)
                self.state = 3343
                self.match(fugue_sqlParser.T__4)
                self.state = 3344
                self.expression()
                self.state = 3345
                self.match(fugue_sqlParser.AS)
                self.state = 3346
                self.dataType()
                self.state = 3347
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.StructContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3349
                self.match(fugue_sqlParser.STRUCT)
                self.state = 3350
                self.match(fugue_sqlParser.T__4)
                self.state = 3359
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & -288230376151711712) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0 or (((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0 or (((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & -9205357638345293825) != 0 or (((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & 2096179) != 0:
                    self.state = 3351
                    localctx._namedExpression = self.namedExpression()
                    localctx.argument.append(localctx._namedExpression)
                    self.state = 3356
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==2:
                        self.state = 3352
                        self.match(fugue_sqlParser.T__1)
                        self.state = 3353
                        localctx._namedExpression = self.namedExpression()
                        localctx.argument.append(localctx._namedExpression)
                        self.state = 3358
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 3361
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 6:
                localctx = fugue_sqlParser.FirstContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3362
                self.match(fugue_sqlParser.FIRST)
                self.state = 3363
                self.match(fugue_sqlParser.T__4)
                self.state = 3364
                self.expression()
                self.state = 3367
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==157:
                    self.state = 3365
                    self.match(fugue_sqlParser.IGNORE)
                    self.state = 3366
                    self.match(fugue_sqlParser.THENULLS)


                self.state = 3369
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 7:
                localctx = fugue_sqlParser.LastContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3371
                self.match(fugue_sqlParser.LAST)
                self.state = 3372
                self.match(fugue_sqlParser.T__4)
                self.state = 3373
                self.expression()
                self.state = 3376
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==157:
                    self.state = 3374
                    self.match(fugue_sqlParser.IGNORE)
                    self.state = 3375
                    self.match(fugue_sqlParser.THENULLS)


                self.state = 3378
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 8:
                localctx = fugue_sqlParser.PositionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3380
                self.match(fugue_sqlParser.POSITION)
                self.state = 3381
                self.match(fugue_sqlParser.T__4)
                self.state = 3382
                localctx.substr = self.valueExpression(0)
                self.state = 3383
                self.match(fugue_sqlParser.IN)
                self.state = 3384
                localctx.istr = self.valueExpression(0)
                self.state = 3385
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 9:
                localctx = fugue_sqlParser.ConstantDefaultContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3387
                self.constant()
                pass

            elif la_ == 10:
                localctx = fugue_sqlParser.StarContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3388
                self.match(fugue_sqlParser.ASTERISK)
                pass

            elif la_ == 11:
                localctx = fugue_sqlParser.StarContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3389
                self.qualifiedName()
                self.state = 3390
                self.match(fugue_sqlParser.T__6)
                self.state = 3391
                self.match(fugue_sqlParser.ASTERISK)
                pass

            elif la_ == 12:
                localctx = fugue_sqlParser.RowConstructorContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3393
                self.match(fugue_sqlParser.T__4)
                self.state = 3394
                self.namedExpression()
                self.state = 3397 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 3395
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3396
                    self.namedExpression()
                    self.state = 3399 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==2):
                        break

                self.state = 3401
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 13:
                localctx = fugue_sqlParser.SubqueryExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3403
                self.match(fugue_sqlParser.T__4)
                self.state = 3404
                self.query()
                self.state = 3405
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 14:
                localctx = fugue_sqlParser.FunctionCallContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3407
                self.functionName()
                self.state = 3408
                self.match(fugue_sqlParser.T__4)
                self.state = 3420
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & -288230376151711712) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1) != 0 or (((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & -1) != 0 or (((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & -9205357638345293825) != 0 or (((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & 2096179) != 0:
                    self.state = 3410
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,457,self._ctx)
                    if la_ == 1:
                        self.state = 3409
                        self.setQuantifier()


                    self.state = 3412
                    localctx._expression = self.expression()
                    localctx.argument.append(localctx._expression)
                    self.state = 3417
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==2:
                        self.state = 3413
                        self.match(fugue_sqlParser.T__1)
                        self.state = 3414
                        localctx._expression = self.expression()
                        localctx.argument.append(localctx._expression)
                        self.state = 3419
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 3422
                self.match(fugue_sqlParser.T__5)
                self.state = 3429
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,460,self._ctx)
                if la_ == 1:
                    self.state = 3423
                    self.match(fugue_sqlParser.FILTER)
                    self.state = 3424
                    self.match(fugue_sqlParser.T__4)
                    self.state = 3425
                    self.match(fugue_sqlParser.WHERE)
                    self.state = 3426
                    localctx.where = self.booleanExpression(0)
                    self.state = 3427
                    self.match(fugue_sqlParser.T__5)


                self.state = 3433
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,461,self._ctx)
                if la_ == 1:
                    self.state = 3431
                    self.match(fugue_sqlParser.OVER)
                    self.state = 3432
                    self.windowSpec()


                pass

            elif la_ == 15:
                localctx = fugue_sqlParser.LambdaContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3435
                self.identifier()
                self.state = 3436
                self.match(fugue_sqlParser.T__15)
                self.state = 3437
                self.expression()
                pass

            elif la_ == 16:
                localctx = fugue_sqlParser.LambdaContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3439
                self.match(fugue_sqlParser.T__4)
                self.state = 3440
                self.identifier()
                self.state = 3443 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 3441
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3442
                    self.identifier()
                    self.state = 3445 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==2):
                        break

                self.state = 3447
                self.match(fugue_sqlParser.T__5)
                self.state = 3448
                self.match(fugue_sqlParser.T__15)
                self.state = 3449
                self.expression()
                pass

            elif la_ == 17:
                localctx = fugue_sqlParser.ColumnReferenceContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3451
                self.identifier()
                pass

            elif la_ == 18:
                localctx = fugue_sqlParser.ParenthesizedExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3452
                self.match(fugue_sqlParser.T__4)
                self.state = 3453
                self.expression()
                self.state = 3454
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 19:
                localctx = fugue_sqlParser.ExtractContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3456
                self.match(fugue_sqlParser.EXTRACT)
                self.state = 3457
                self.match(fugue_sqlParser.T__4)
                self.state = 3458
                localctx.field = self.identifier()
                self.state = 3459
                self.match(fugue_sqlParser.FROM)
                self.state = 3460
                localctx.source = self.valueExpression(0)
                self.state = 3461
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 20:
                localctx = fugue_sqlParser.SubstringContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3463
                _la = self._input.LA(1)
                if not(_la==271 or _la==272):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3464
                self.match(fugue_sqlParser.T__4)
                self.state = 3465
                localctx.istr = self.valueExpression(0)
                self.state = 3466
                _la = self._input.LA(1)
                if not(_la==2 or _la==146):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3467
                localctx.pos = self.valueExpression(0)
                self.state = 3470
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==2 or _la==142:
                    self.state = 3468
                    _la = self._input.LA(1)
                    if not(_la==2 or _la==142):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 3469
                    localctx.ilen = self.valueExpression(0)


                self.state = 3472
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 21:
                localctx = fugue_sqlParser.TrimContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3474
                self.match(fugue_sqlParser.TRIM)
                self.state = 3475
                self.match(fugue_sqlParser.T__4)
                self.state = 3477
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,464,self._ctx)
                if la_ == 1:
                    self.state = 3476
                    localctx.trimOption = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==73 or _la==176 or _la==282):
                        localctx.trimOption = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 3480
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,465,self._ctx)
                if la_ == 1:
                    self.state = 3479
                    localctx.trimStr = self.valueExpression(0)


                self.state = 3482
                self.match(fugue_sqlParser.FROM)
                self.state = 3483
                localctx.srcStr = self.valueExpression(0)
                self.state = 3484
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 22:
                localctx = fugue_sqlParser.OverlayContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 3486
                self.match(fugue_sqlParser.OVERLAY)
                self.state = 3487
                self.match(fugue_sqlParser.T__4)
                self.state = 3488
                localctx.iinput = self.valueExpression(0)
                self.state = 3489
                self.match(fugue_sqlParser.PLACING)
                self.state = 3490
                localctx.replace = self.valueExpression(0)
                self.state = 3491
                self.match(fugue_sqlParser.FROM)
                self.state = 3492
                localctx.position = self.valueExpression(0)
                self.state = 3495
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==142:
                    self.state = 3493
                    self.match(fugue_sqlParser.FOR)
                    self.state = 3494
                    localctx.length = self.valueExpression(0)


                self.state = 3497
                self.match(fugue_sqlParser.T__5)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 3511
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,469,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 = 3509
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,468,self._ctx)
                    if la_ == 1:
                        localctx = fugue_sqlParser.SubscriptContext(self, fugue_sqlParser.PrimaryExpressionContext(self, _parentctx, _parentState))
                        localctx.value = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_primaryExpression)
                        self.state = 3501
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 3502
                        self.match(fugue_sqlParser.T__0)
                        self.state = 3503
                        localctx.index = self.valueExpression(0)
                        self.state = 3504
                        self.match(fugue_sqlParser.T__2)
                        pass

                    elif la_ == 2:
                        localctx = fugue_sqlParser.DereferenceContext(self, fugue_sqlParser.PrimaryExpressionContext(self, _parentctx, _parentState))
                        localctx.base = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_primaryExpression)
                        self.state = 3506
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 3507
                        self.match(fugue_sqlParser.T__6)
                        self.state = 3508
                        localctx.fieldName = self.identifier()
                        pass

             
                self.state = 3513
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,469,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class ConstantContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_constant

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class NullLiteralContext(ConstantContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNullLiteral" ):
                return visitor.visitNullLiteral(self)
            else:
                return visitor.visitChildren(self)


    class StringLiteralContext(ConstantContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.STRING)
            else:
                return self.getToken(fugue_sqlParser.STRING, i)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringLiteral" ):
                return visitor.visitStringLiteral(self)
            else:
                return visitor.visitChildren(self)


    class TypeConstructorContext(ConstantContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)

        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeConstructor" ):
                return visitor.visitTypeConstructor(self)
            else:
                return visitor.visitChildren(self)


    class IntervalLiteralContext(ConstantContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def interval(self):
            return self.getTypedRuleContext(fugue_sqlParser.IntervalContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntervalLiteral" ):
                return visitor.visitIntervalLiteral(self)
            else:
                return visitor.visitChildren(self)


    class NumericLiteralContext(ConstantContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def number(self):
            return self.getTypedRuleContext(fugue_sqlParser.NumberContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumericLiteral" ):
                return visitor.visitNumericLiteral(self)
            else:
                return visitor.visitChildren(self)


    class BooleanLiteralContext(ConstantContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ConstantContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def booleanValue(self):
            return self.getTypedRuleContext(fugue_sqlParser.BooleanValueContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBooleanLiteral" ):
                return visitor.visitBooleanLiteral(self)
            else:
                return visitor.visitChildren(self)



    def constant(self):

        localctx = fugue_sqlParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_constant)
        try:
            self.state = 3526
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,471,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.NullLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3514
                self.match(fugue_sqlParser.THENULL)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.IntervalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3515
                self.interval()
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.TypeConstructorContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3516
                self.identifier()
                self.state = 3517
                self.match(fugue_sqlParser.STRING)
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.NumericLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 3519
                self.number()
                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.BooleanLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 3520
                self.booleanValue()
                pass

            elif la_ == 6:
                localctx = fugue_sqlParser.StringLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 3522 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 3521
                        self.match(fugue_sqlParser.STRING)

                    else:
                        raise NoViableAltException(self)
                    self.state = 3524 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,470,self._ctx)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComparisonOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def comparisonEqualOperator(self):
            return self.getTypedRuleContext(fugue_sqlParser.ComparisonEqualOperatorContext,0)


        def NEQ(self):
            return self.getToken(fugue_sqlParser.NEQ, 0)

        def NEQJ(self):
            return self.getToken(fugue_sqlParser.NEQJ, 0)

        def LT(self):
            return self.getToken(fugue_sqlParser.LT, 0)

        def LTE(self):
            return self.getToken(fugue_sqlParser.LTE, 0)

        def GT(self):
            return self.getToken(fugue_sqlParser.GT, 0)

        def GTE(self):
            return self.getToken(fugue_sqlParser.GTE, 0)

        def NSEQ(self):
            return self.getToken(fugue_sqlParser.NSEQ, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_comparisonOperator

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComparisonOperator" ):
                return visitor.visitComparisonOperator(self)
            else:
                return visitor.visitChildren(self)




    def comparisonOperator(self):

        localctx = fugue_sqlParser.ComparisonOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_comparisonOperator)
        try:
            self.state = 3536
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [310, 311]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3528
                self.comparisonEqualOperator()
                pass
            elif token in [313]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3529
                self.match(fugue_sqlParser.NEQ)
                pass
            elif token in [314]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3530
                self.match(fugue_sqlParser.NEQJ)
                pass
            elif token in [315]:
                self.enterOuterAlt(localctx, 4)
                self.state = 3531
                self.match(fugue_sqlParser.LT)
                pass
            elif token in [316]:
                self.enterOuterAlt(localctx, 5)
                self.state = 3532
                self.match(fugue_sqlParser.LTE)
                pass
            elif token in [317]:
                self.enterOuterAlt(localctx, 6)
                self.state = 3533
                self.match(fugue_sqlParser.GT)
                pass
            elif token in [318]:
                self.enterOuterAlt(localctx, 7)
                self.state = 3534
                self.match(fugue_sqlParser.GTE)
                pass
            elif token in [312]:
                self.enterOuterAlt(localctx, 8)
                self.state = 3535
                self.match(fugue_sqlParser.NSEQ)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComparisonEqualOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DOUBLEEQUAL(self):
            return self.getToken(fugue_sqlParser.DOUBLEEQUAL, 0)

        def EQUAL(self):
            return self.getToken(fugue_sqlParser.EQUAL, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_comparisonEqualOperator

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComparisonEqualOperator" ):
                return visitor.visitComparisonEqualOperator(self)
            else:
                return visitor.visitChildren(self)




    def comparisonEqualOperator(self):

        localctx = fugue_sqlParser.ComparisonEqualOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_comparisonEqualOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3538
            _la = self._input.LA(1)
            if not(_la==310 or _la==311):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArithmeticOperatorContext(ParserRuleContext):
        __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(fugue_sqlParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def ASTERISK(self):
            return self.getToken(fugue_sqlParser.ASTERISK, 0)

        def SLASH(self):
            return self.getToken(fugue_sqlParser.SLASH, 0)

        def PERCENT(self):
            return self.getToken(fugue_sqlParser.PERCENT, 0)

        def DIV(self):
            return self.getToken(fugue_sqlParser.DIV, 0)

        def TILDE(self):
            return self.getToken(fugue_sqlParser.TILDE, 0)

        def AMPERSAND(self):
            return self.getToken(fugue_sqlParser.AMPERSAND, 0)

        def PIPE(self):
            return self.getToken(fugue_sqlParser.PIPE, 0)

        def CONCAT_PIPE(self):
            return self.getToken(fugue_sqlParser.CONCAT_PIPE, 0)

        def HAT(self):
            return self.getToken(fugue_sqlParser.HAT, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_arithmeticOperator

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArithmeticOperator" ):
                return visitor.visitArithmeticOperator(self)
            else:
                return visitor.visitChildren(self)




    def arithmeticOperator(self):

        localctx = fugue_sqlParser.ArithmeticOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_arithmeticOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3540
            _la = self._input.LA(1)
            if not((((_la - 319)) & ~0x3f) == 0 and ((1 << (_la - 319)) & 2047) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PredicateOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OR(self):
            return self.getToken(fugue_sqlParser.OR, 0)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)

        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_predicateOperator

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPredicateOperator" ):
                return visitor.visitPredicateOperator(self)
            else:
                return visitor.visitChildren(self)




    def predicateOperator(self):

        localctx = fugue_sqlParser.PredicateOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_predicateOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3542
            _la = self._input.LA(1)
            if not(_la==63 or (((_la - 159)) & ~0x3f) == 0 and ((1 << (_la - 159)) & 282574488338433) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TRUE(self):
            return self.getToken(fugue_sqlParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(fugue_sqlParser.FALSE, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_booleanValue

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBooleanValue" ):
                return visitor.visitBooleanValue(self)
            else:
                return visitor.visitChildren(self)




    def booleanValue(self):

        localctx = fugue_sqlParser.BooleanValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_booleanValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3544
            _la = self._input.LA(1)
            if not(_la==135 or _la==287):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntervalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTERVAL(self):
            return self.getToken(fugue_sqlParser.INTERVAL, 0)

        def errorCapturingMultiUnitsInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingMultiUnitsIntervalContext,0)


        def errorCapturingUnitToUnitInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingUnitToUnitIntervalContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_interval

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInterval" ):
                return visitor.visitInterval(self)
            else:
                return visitor.visitChildren(self)




    def interval(self):

        localctx = fugue_sqlParser.IntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_interval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3546
            self.match(fugue_sqlParser.INTERVAL)
            self.state = 3549
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,473,self._ctx)
            if la_ == 1:
                self.state = 3547
                self.errorCapturingMultiUnitsInterval()

            elif la_ == 2:
                self.state = 3548
                self.errorCapturingUnitToUnitInterval()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ErrorCapturingMultiUnitsIntervalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def multiUnitsInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultiUnitsIntervalContext,0)


        def unitToUnitInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.UnitToUnitIntervalContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_errorCapturingMultiUnitsInterval

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitErrorCapturingMultiUnitsInterval" ):
                return visitor.visitErrorCapturingMultiUnitsInterval(self)
            else:
                return visitor.visitChildren(self)




    def errorCapturingMultiUnitsInterval(self):

        localctx = fugue_sqlParser.ErrorCapturingMultiUnitsIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_errorCapturingMultiUnitsInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3551
            self.multiUnitsInterval()
            self.state = 3553
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,474,self._ctx)
            if la_ == 1:
                self.state = 3552
                self.unitToUnitInterval()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MultiUnitsIntervalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def intervalValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IntervalValueContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IntervalValueContext,i)


        def intervalUnit(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IntervalUnitContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IntervalUnitContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_multiUnitsInterval

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultiUnitsInterval" ):
                return visitor.visitMultiUnitsInterval(self)
            else:
                return visitor.visitChildren(self)




    def multiUnitsInterval(self):

        localctx = fugue_sqlParser.MultiUnitsIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_multiUnitsInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3558 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 3555
                    self.intervalValue()
                    self.state = 3556
                    self.intervalUnit()

                else:
                    raise NoViableAltException(self)
                self.state = 3560 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,475,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ErrorCapturingUnitToUnitIntervalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.body = None # UnitToUnitIntervalContext
            self.error1 = None # MultiUnitsIntervalContext
            self.error2 = None # UnitToUnitIntervalContext

        def unitToUnitInterval(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.UnitToUnitIntervalContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.UnitToUnitIntervalContext,i)


        def multiUnitsInterval(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultiUnitsIntervalContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_errorCapturingUnitToUnitInterval

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitErrorCapturingUnitToUnitInterval" ):
                return visitor.visitErrorCapturingUnitToUnitInterval(self)
            else:
                return visitor.visitChildren(self)




    def errorCapturingUnitToUnitInterval(self):

        localctx = fugue_sqlParser.ErrorCapturingUnitToUnitIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_errorCapturingUnitToUnitInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3562
            localctx.body = self.unitToUnitInterval()
            self.state = 3565
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,476,self._ctx)
            if la_ == 1:
                self.state = 3563
                localctx.error1 = self.multiUnitsInterval()

            elif la_ == 2:
                self.state = 3564
                localctx.error2 = self.unitToUnitInterval()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnitToUnitIntervalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.value = None # IntervalValueContext
            self.ifrom = None # IntervalUnitContext
            self.to = None # IntervalUnitContext

        def TO(self):
            return self.getToken(fugue_sqlParser.TO, 0)

        def intervalValue(self):
            return self.getTypedRuleContext(fugue_sqlParser.IntervalValueContext,0)


        def intervalUnit(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IntervalUnitContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IntervalUnitContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_unitToUnitInterval

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnitToUnitInterval" ):
                return visitor.visitUnitToUnitInterval(self)
            else:
                return visitor.visitChildren(self)




    def unitToUnitInterval(self):

        localctx = fugue_sqlParser.UnitToUnitIntervalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_unitToUnitInterval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3567
            localctx.value = self.intervalValue()
            self.state = 3568
            localctx.ifrom = self.intervalUnit()
            self.state = 3569
            self.match(fugue_sqlParser.TO)
            self.state = 3570
            localctx.to = self.intervalUnit()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntervalValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTEGER_VALUE(self):
            return self.getToken(fugue_sqlParser.INTEGER_VALUE, 0)

        def DECIMAL_VALUE(self):
            return self.getToken(fugue_sqlParser.DECIMAL_VALUE, 0)

        def PLUS(self):
            return self.getToken(fugue_sqlParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def STRING(self):
            return self.getToken(fugue_sqlParser.STRING, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_intervalValue

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntervalValue" ):
                return visitor.visitIntervalValue(self)
            else:
                return visitor.visitChildren(self)




    def intervalValue(self):

        localctx = fugue_sqlParser.IntervalValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_intervalValue)
        self._la = 0 # Token type
        try:
            self.state = 3577
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [319, 320, 334, 336]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3573
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==319 or _la==320:
                    self.state = 3572
                    _la = self._input.LA(1)
                    if not(_la==319 or _la==320):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 3575
                _la = self._input.LA(1)
                if not(_la==334 or _la==336):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [330]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3576
                self.match(fugue_sqlParser.STRING)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntervalUnitContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DAY(self):
            return self.getToken(fugue_sqlParser.DAY, 0)

        def HOUR(self):
            return self.getToken(fugue_sqlParser.HOUR, 0)

        def MINUTE(self):
            return self.getToken(fugue_sqlParser.MINUTE, 0)

        def MONTH(self):
            return self.getToken(fugue_sqlParser.MONTH, 0)

        def SECOND(self):
            return self.getToken(fugue_sqlParser.SECOND, 0)

        def YEAR(self):
            return self.getToken(fugue_sqlParser.YEAR, 0)

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_intervalUnit

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntervalUnit" ):
                return visitor.visitIntervalUnit(self)
            else:
                return visitor.visitChildren(self)




    def intervalUnit(self):

        localctx = fugue_sqlParser.IntervalUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_intervalUnit)
        try:
            self.state = 3586
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,479,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3579
                self.match(fugue_sqlParser.DAY)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3580
                self.match(fugue_sqlParser.HOUR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3581
                self.match(fugue_sqlParser.MINUTE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3582
                self.match(fugue_sqlParser.MONTH)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 3583
                self.match(fugue_sqlParser.SECOND)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 3584
                self.match(fugue_sqlParser.YEAR)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 3585
                self.identifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ColPositionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.position = None # Token
            self.afterCol = None # ErrorCapturingIdentifierContext

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)

        def AFTER(self):
            return self.getToken(fugue_sqlParser.AFTER, 0)

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_colPosition

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitColPosition" ):
                return visitor.visitColPosition(self)
            else:
                return visitor.visitChildren(self)




    def colPosition(self):

        localctx = fugue_sqlParser.ColPositionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_colPosition)
        try:
            self.state = 3591
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [140]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3588
                localctx.position = self.match(fugue_sqlParser.FIRST)
                pass
            elif token in [59]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3589
                localctx.position = self.match(fugue_sqlParser.AFTER)
                self.state = 3590
                localctx.afterCol = self.errorCapturingIdentifier()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DataTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_dataType

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ComplexDataTypeContext(DataTypeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.DataTypeContext
            super().__init__(parser)
            self.icomplex = None # Token
            self.copyFrom(ctx)

        def LT(self):
            return self.getToken(fugue_sqlParser.LT, 0)
        def dataType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.DataTypeContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.DataTypeContext,i)

        def GT(self):
            return self.getToken(fugue_sqlParser.GT, 0)
        def ARRAY(self):
            return self.getToken(fugue_sqlParser.ARRAY, 0)
        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)
        def STRUCT(self):
            return self.getToken(fugue_sqlParser.STRUCT, 0)
        def NEQ(self):
            return self.getToken(fugue_sqlParser.NEQ, 0)
        def complexColTypeList(self):
            return self.getTypedRuleContext(fugue_sqlParser.ComplexColTypeListContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComplexDataType" ):
                return visitor.visitComplexDataType(self)
            else:
                return visitor.visitChildren(self)


    class PrimitiveDataTypeContext(DataTypeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.DataTypeContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)

        def INTEGER_VALUE(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.INTEGER_VALUE)
            else:
                return self.getToken(fugue_sqlParser.INTEGER_VALUE, i)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrimitiveDataType" ):
                return visitor.visitPrimitiveDataType(self)
            else:
                return visitor.visitChildren(self)



    def dataType(self):

        localctx = fugue_sqlParser.DataTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_dataType)
        self._la = 0 # Token type
        try:
            self.state = 3627
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,485,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3593
                localctx.icomplex = self.match(fugue_sqlParser.ARRAY)
                self.state = 3594
                self.match(fugue_sqlParser.LT)
                self.state = 3595
                self.dataType()
                self.state = 3596
                self.match(fugue_sqlParser.GT)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3598
                localctx.icomplex = self.match(fugue_sqlParser.MAP)
                self.state = 3599
                self.match(fugue_sqlParser.LT)
                self.state = 3600
                self.dataType()
                self.state = 3601
                self.match(fugue_sqlParser.T__1)
                self.state = 3602
                self.dataType()
                self.state = 3603
                self.match(fugue_sqlParser.GT)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.ComplexDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3605
                localctx.icomplex = self.match(fugue_sqlParser.STRUCT)
                self.state = 3612
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [315]:
                    self.state = 3606
                    self.match(fugue_sqlParser.LT)
                    self.state = 3608
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & -1) != 0 or (((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & -1) != 0 or (((_la - 186)) & ~0x3f) == 0 and ((1 << (_la - 186)) & -1) != 0 or (((_la - 250)) & ~0x3f) == 0 and ((1 << (_la - 250)) & 1152921504606846975) != 0 or (((_la - 324)) & ~0x3f) == 0 and ((1 << (_la - 324)) & 98305) != 0:
                        self.state = 3607
                        self.complexColTypeList()


                    self.state = 3610
                    self.match(fugue_sqlParser.GT)
                    pass
                elif token in [313]:
                    self.state = 3611
                    self.match(fugue_sqlParser.NEQ)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.PrimitiveDataTypeContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 3614
                self.identifier()
                self.state = 3625
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,484,self._ctx)
                if la_ == 1:
                    self.state = 3615
                    self.match(fugue_sqlParser.T__4)
                    self.state = 3616
                    self.match(fugue_sqlParser.INTEGER_VALUE)
                    self.state = 3621
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==2:
                        self.state = 3617
                        self.match(fugue_sqlParser.T__1)
                        self.state = 3618
                        self.match(fugue_sqlParser.INTEGER_VALUE)
                        self.state = 3623
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 3624
                    self.match(fugue_sqlParser.T__5)


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedColTypeWithPositionListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedColTypeWithPosition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.QualifiedColTypeWithPositionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.QualifiedColTypeWithPositionContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_qualifiedColTypeWithPositionList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiedColTypeWithPositionList" ):
                return visitor.visitQualifiedColTypeWithPositionList(self)
            else:
                return visitor.visitChildren(self)




    def qualifiedColTypeWithPositionList(self):

        localctx = fugue_sqlParser.QualifiedColTypeWithPositionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_qualifiedColTypeWithPositionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3629
            self.qualifiedColTypeWithPosition()
            self.state = 3634
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 3630
                self.match(fugue_sqlParser.T__1)
                self.state = 3631
                self.qualifiedColTypeWithPosition()
                self.state = 3636
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedColTypeWithPositionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.name = None # MultipartIdentifierContext

        def dataType(self):
            return self.getTypedRuleContext(fugue_sqlParser.DataTypeContext,0)


        def multipartIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.MultipartIdentifierContext,0)


        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def colPosition(self):
            return self.getTypedRuleContext(fugue_sqlParser.ColPositionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_qualifiedColTypeWithPosition

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiedColTypeWithPosition" ):
                return visitor.visitQualifiedColTypeWithPosition(self)
            else:
                return visitor.visitChildren(self)




    def qualifiedColTypeWithPosition(self):

        localctx = fugue_sqlParser.QualifiedColTypeWithPositionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 382, self.RULE_qualifiedColTypeWithPosition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3637
            localctx.name = self.multipartIdentifier()
            self.state = 3638
            self.dataType()
            self.state = 3641
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==199:
                self.state = 3639
                self.match(fugue_sqlParser.NOT)
                self.state = 3640
                self.match(fugue_sqlParser.THENULL)


            self.state = 3644
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==91:
                self.state = 3643
                self.commentSpec()


            self.state = 3647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59 or _la==140:
                self.state = 3646
                self.colPosition()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ColTypeListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def colType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ColTypeContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ColTypeContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_colTypeList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitColTypeList" ):
                return visitor.visitColTypeList(self)
            else:
                return visitor.visitChildren(self)




    def colTypeList(self):

        localctx = fugue_sqlParser.ColTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 384, self.RULE_colTypeList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3649
            self.colType()
            self.state = 3654
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,490,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3650
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3651
                    self.colType() 
                self.state = 3656
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,490,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ColTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.colName = None # ErrorCapturingIdentifierContext

        def dataType(self):
            return self.getTypedRuleContext(fugue_sqlParser.DataTypeContext,0)


        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_colType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitColType" ):
                return visitor.visitColType(self)
            else:
                return visitor.visitChildren(self)




    def colType(self):

        localctx = fugue_sqlParser.ColTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 386, self.RULE_colType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3657
            localctx.colName = self.errorCapturingIdentifier()
            self.state = 3658
            self.dataType()
            self.state = 3661
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,491,self._ctx)
            if la_ == 1:
                self.state = 3659
                self.match(fugue_sqlParser.NOT)
                self.state = 3660
                self.match(fugue_sqlParser.THENULL)


            self.state = 3664
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,492,self._ctx)
            if la_ == 1:
                self.state = 3663
                self.commentSpec()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComplexColTypeListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def complexColType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ComplexColTypeContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ComplexColTypeContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_complexColTypeList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComplexColTypeList" ):
                return visitor.visitComplexColTypeList(self)
            else:
                return visitor.visitChildren(self)




    def complexColTypeList(self):

        localctx = fugue_sqlParser.ComplexColTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 388, self.RULE_complexColTypeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3666
            self.complexColType()
            self.state = 3671
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 3667
                self.match(fugue_sqlParser.T__1)
                self.state = 3668
                self.complexColType()
                self.state = 3673
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComplexColTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def dataType(self):
            return self.getTypedRuleContext(fugue_sqlParser.DataTypeContext,0)


        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)

        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_complexColType

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComplexColType" ):
                return visitor.visitComplexColType(self)
            else:
                return visitor.visitChildren(self)




    def complexColType(self):

        localctx = fugue_sqlParser.ComplexColTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 390, self.RULE_complexColType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3674
            self.identifier()
            self.state = 3675
            self.match(fugue_sqlParser.T__3)
            self.state = 3676
            self.dataType()
            self.state = 3679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==199:
                self.state = 3677
                self.match(fugue_sqlParser.NOT)
                self.state = 3678
                self.match(fugue_sqlParser.THENULL)


            self.state = 3682
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==91:
                self.state = 3681
                self.commentSpec()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhenClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.condition = None # ExpressionContext
            self.result = None # ExpressionContext

        def WHEN(self):
            return self.getToken(fugue_sqlParser.WHEN, 0)

        def THEN(self):
            return self.getToken(fugue_sqlParser.THEN, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_whenClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhenClause" ):
                return visitor.visitWhenClause(self)
            else:
                return visitor.visitChildren(self)




    def whenClause(self):

        localctx = fugue_sqlParser.WhenClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 392, self.RULE_whenClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3684
            self.match(fugue_sqlParser.WHEN)
            self.state = 3685
            localctx.condition = self.expression()
            self.state = 3686
            self.match(fugue_sqlParser.THEN)
            self.state = 3687
            localctx.result = self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WindowClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WINDOW(self):
            return self.getToken(fugue_sqlParser.WINDOW, 0)

        def namedWindow(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.NamedWindowContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.NamedWindowContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_windowClause

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWindowClause" ):
                return visitor.visitWindowClause(self)
            else:
                return visitor.visitChildren(self)




    def windowClause(self):

        localctx = fugue_sqlParser.WindowClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 394, self.RULE_windowClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3689
            self.match(fugue_sqlParser.WINDOW)
            self.state = 3690
            self.namedWindow()
            self.state = 3695
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,496,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3691
                    self.match(fugue_sqlParser.T__1)
                    self.state = 3692
                    self.namedWindow() 
                self.state = 3697
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,496,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamedWindowContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.name = None # ErrorCapturingIdentifierContext

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def windowSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowSpecContext,0)


        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_namedWindow

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamedWindow" ):
                return visitor.visitNamedWindow(self)
            else:
                return visitor.visitChildren(self)




    def namedWindow(self):

        localctx = fugue_sqlParser.NamedWindowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 396, self.RULE_namedWindow)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3698
            localctx.name = self.errorCapturingIdentifier()
            self.state = 3699
            self.match(fugue_sqlParser.AS)
            self.state = 3700
            self.windowSpec()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WindowSpecContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_windowSpec

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class WindowRefContext(WindowSpecContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.WindowSpecContext
            super().__init__(parser)
            self.name = None # ErrorCapturingIdentifierContext
            self.copyFrom(ctx)

        def errorCapturingIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.ErrorCapturingIdentifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWindowRef" ):
                return visitor.visitWindowRef(self)
            else:
                return visitor.visitChildren(self)


    class WindowDefContext(WindowSpecContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.WindowSpecContext
            super().__init__(parser)
            self._expression = None # ExpressionContext
            self.partition = list() # of ExpressionContexts
            self.copyFrom(ctx)

        def CLUSTER(self):
            return self.getToken(fugue_sqlParser.CLUSTER, 0)
        def BY(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.BY)
            else:
                return self.getToken(fugue_sqlParser.BY, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,i)

        def windowFrame(self):
            return self.getTypedRuleContext(fugue_sqlParser.WindowFrameContext,0)

        def sortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.SortItemContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.SortItemContext,i)

        def PARTITION(self):
            return self.getToken(fugue_sqlParser.PARTITION, 0)
        def DISTRIBUTE(self):
            return self.getToken(fugue_sqlParser.DISTRIBUTE, 0)
        def ORDER(self):
            return self.getToken(fugue_sqlParser.ORDER, 0)
        def SORT(self):
            return self.getToken(fugue_sqlParser.SORT, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWindowDef" ):
                return visitor.visitWindowDef(self)
            else:
                return visitor.visitChildren(self)



    def windowSpec(self):

        localctx = fugue_sqlParser.WindowSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 398, self.RULE_windowSpec)
        self._la = 0 # Token type
        try:
            self.state = 3748
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,504,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.WindowRefContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3702
                localctx.name = self.errorCapturingIdentifier()
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.WindowRefContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3703
                self.match(fugue_sqlParser.T__4)
                self.state = 3704
                localctx.name = self.errorCapturingIdentifier()
                self.state = 3705
                self.match(fugue_sqlParser.T__5)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.WindowDefContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3707
                self.match(fugue_sqlParser.T__4)
                self.state = 3742
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [84]:
                    self.state = 3708
                    self.match(fugue_sqlParser.CLUSTER)
                    self.state = 3709
                    self.match(fugue_sqlParser.BY)
                    self.state = 3710
                    localctx._expression = self.expression()
                    localctx.partition.append(localctx._expression)
                    self.state = 3715
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==2:
                        self.state = 3711
                        self.match(fugue_sqlParser.T__1)
                        self.state = 3712
                        localctx._expression = self.expression()
                        localctx.partition.append(localctx._expression)
                        self.state = 3717
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [6, 121, 208, 216, 229, 249, 264]:
                    self.state = 3728
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==121 or _la==216:
                        self.state = 3718
                        _la = self._input.LA(1)
                        if not(_la==121 or _la==216):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 3719
                        self.match(fugue_sqlParser.BY)
                        self.state = 3720
                        localctx._expression = self.expression()
                        localctx.partition.append(localctx._expression)
                        self.state = 3725
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==2:
                            self.state = 3721
                            self.match(fugue_sqlParser.T__1)
                            self.state = 3722
                            localctx._expression = self.expression()
                            localctx.partition.append(localctx._expression)
                            self.state = 3727
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    self.state = 3740
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==208 or _la==264:
                        self.state = 3730
                        _la = self._input.LA(1)
                        if not(_la==208 or _la==264):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 3731
                        self.match(fugue_sqlParser.BY)
                        self.state = 3732
                        self.sortItem()
                        self.state = 3737
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==2:
                            self.state = 3733
                            self.match(fugue_sqlParser.T__1)
                            self.state = 3734
                            self.sortItem()
                            self.state = 3739
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 3745
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==229 or _la==249:
                    self.state = 3744
                    self.windowFrame()


                self.state = 3747
                self.match(fugue_sqlParser.T__5)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WindowFrameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.frameType = None # Token
            self.start = None # FrameBoundContext
            self.end = None # FrameBoundContext

        def RANGE(self):
            return self.getToken(fugue_sqlParser.RANGE, 0)

        def frameBound(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.FrameBoundContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.FrameBoundContext,i)


        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

        def BETWEEN(self):
            return self.getToken(fugue_sqlParser.BETWEEN, 0)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_windowFrame

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWindowFrame" ):
                return visitor.visitWindowFrame(self)
            else:
                return visitor.visitChildren(self)




    def windowFrame(self):

        localctx = fugue_sqlParser.WindowFrameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 400, self.RULE_windowFrame)
        try:
            self.state = 3766
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,505,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3750
                localctx.frameType = self.match(fugue_sqlParser.RANGE)
                self.state = 3751
                localctx.start = self.frameBound()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3752
                localctx.frameType = self.match(fugue_sqlParser.ROWS)
                self.state = 3753
                localctx.start = self.frameBound()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3754
                localctx.frameType = self.match(fugue_sqlParser.RANGE)
                self.state = 3755
                self.match(fugue_sqlParser.BETWEEN)
                self.state = 3756
                localctx.start = self.frameBound()
                self.state = 3757
                self.match(fugue_sqlParser.AND)
                self.state = 3758
                localctx.end = self.frameBound()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3760
                localctx.frameType = self.match(fugue_sqlParser.ROWS)
                self.state = 3761
                self.match(fugue_sqlParser.BETWEEN)
                self.state = 3762
                localctx.start = self.frameBound()
                self.state = 3763
                self.match(fugue_sqlParser.AND)
                self.state = 3764
                localctx.end = self.frameBound()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FrameBoundContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.boundType = None # Token

        def UNBOUNDED(self):
            return self.getToken(fugue_sqlParser.UNBOUNDED, 0)

        def PRECEDING(self):
            return self.getToken(fugue_sqlParser.PRECEDING, 0)

        def FOLLOWING(self):
            return self.getToken(fugue_sqlParser.FOLLOWING, 0)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)

        def CURRENT(self):
            return self.getToken(fugue_sqlParser.CURRENT, 0)

        def expression(self):
            return self.getTypedRuleContext(fugue_sqlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_frameBound

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFrameBound" ):
                return visitor.visitFrameBound(self)
            else:
                return visitor.visitChildren(self)




    def frameBound(self):

        localctx = fugue_sqlParser.FrameBoundContext(self, self._ctx, self.state)
        self.enterRule(localctx, 402, self.RULE_frameBound)
        self._la = 0 # Token type
        try:
            self.state = 3775
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,506,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3768
                self.match(fugue_sqlParser.UNBOUNDED)
                self.state = 3769
                localctx.boundType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==141 or _la==223):
                    localctx.boundType = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3770
                localctx.boundType = self.match(fugue_sqlParser.CURRENT)
                self.state = 3771
                self.match(fugue_sqlParser.ROW)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3772
                self.expression()
                self.state = 3773
                localctx.boundType = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==141 or _la==223):
                    localctx.boundType = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedNameListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_qualifiedNameList

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiedNameList" ):
                return visitor.visitQualifiedNameList(self)
            else:
                return visitor.visitChildren(self)




    def qualifiedNameList(self):

        localctx = fugue_sqlParser.QualifiedNameListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 404, self.RULE_qualifiedNameList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3777
            self.qualifiedName()
            self.state = 3782
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 3778
                self.match(fugue_sqlParser.T__1)
                self.state = 3779
                self.qualifiedName()
                self.state = 3784
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedName(self):
            return self.getTypedRuleContext(fugue_sqlParser.QualifiedNameContext,0)


        def FILTER(self):
            return self.getToken(fugue_sqlParser.FILTER, 0)

        def LEFT(self):
            return self.getToken(fugue_sqlParser.LEFT, 0)

        def RIGHT(self):
            return self.getToken(fugue_sqlParser.RIGHT, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_functionName

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionName" ):
                return visitor.visitFunctionName(self)
            else:
                return visitor.visitChildren(self)




    def functionName(self):

        localctx = fugue_sqlParser.FunctionNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 406, self.RULE_functionName)
        try:
            self.state = 3789
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,508,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 3785
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 3786
                self.match(fugue_sqlParser.FILTER)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 3787
                self.match(fugue_sqlParser.LEFT)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 3788
                self.match(fugue_sqlParser.RIGHT)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_qualifiedName

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiedName" ):
                return visitor.visitQualifiedName(self)
            else:
                return visitor.visitChildren(self)




    def qualifiedName(self):

        localctx = fugue_sqlParser.QualifiedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 408, self.RULE_qualifiedName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3791
            self.identifier()
            self.state = 3796
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,509,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 3792
                    self.match(fugue_sqlParser.T__6)
                    self.state = 3793
                    self.identifier() 
                self.state = 3798
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,509,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ErrorCapturingIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_errorCapturingIdentifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitErrorCapturingIdentifier" ):
                return visitor.visitErrorCapturingIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def errorCapturingIdentifier(self):

        localctx = fugue_sqlParser.ErrorCapturingIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 410, self.RULE_errorCapturingIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3799
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ErrorCapturingIdentifierExtraContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_errorCapturingIdentifierExtra

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ErrorIdentContext(ErrorCapturingIdentifierExtraContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.ErrorCapturingIdentifierExtraContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def MINUS(self, i:int=None):
            if i is None:
                return self.getTokens(fugue_sqlParser.MINUS)
            else:
                return self.getToken(fugue_sqlParser.MINUS, i)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(fugue_sqlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(fugue_sqlParser.IdentifierContext,i)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitErrorIdent" ):
                return visitor.visitErrorIdent(self)
            else:
                return visitor.visitChildren(self)



    def errorCapturingIdentifierExtra(self):

        localctx = fugue_sqlParser.ErrorCapturingIdentifierExtraContext(self, self._ctx, self.state)
        self.enterRule(localctx, 412, self.RULE_errorCapturingIdentifierExtra)
        self._la = 0 # Token type
        try:
            localctx = fugue_sqlParser.ErrorIdentContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 3803 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 3801
                self.match(fugue_sqlParser.MINUS)
                self.state = 3802
                self.identifier()
                self.state = 3805 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==320):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def strictIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.StrictIdentifierContext,0)


        def strictNonReserved(self):
            return self.getTypedRuleContext(fugue_sqlParser.StrictNonReservedContext,0)


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_identifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifier" ):
                return visitor.visitIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def identifier(self):

        localctx = fugue_sqlParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 414, self.RULE_identifier)
        try:
            self.state = 3809
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58, 59, 60, 61, 62, 63, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 163, 164, 165, 167, 168, 169, 170, 172, 173, 174, 175, 176, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 198, 199, 200, 201, 202, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 254, 255, 256, 257, 258, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 294, 295, 296, 297, 298, 299, 300, 302, 303, 304, 305, 306, 307, 308, 309, 324, 339, 340]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3807
                self.strictIdentifier()
                pass
            elif token in [64, 100, 127, 147, 162, 166, 171, 177, 197, 203, 242, 253, 259, 293, 301]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3808
                self.strictNonReserved()
                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 StrictIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_strictIdentifier

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class QuotedIdentifierAlternativeContext(StrictIdentifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StrictIdentifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def quotedIdentifier(self):
            return self.getTypedRuleContext(fugue_sqlParser.QuotedIdentifierContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuotedIdentifierAlternative" ):
                return visitor.visitQuotedIdentifierAlternative(self)
            else:
                return visitor.visitChildren(self)


    class UnquotedIdentifierContext(StrictIdentifierContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.StrictIdentifierContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IDENTIFIER(self):
            return self.getToken(fugue_sqlParser.IDENTIFIER, 0)
        def nonReserved(self):
            return self.getTypedRuleContext(fugue_sqlParser.NonReservedContext,0)


        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnquotedIdentifier" ):
                return visitor.visitUnquotedIdentifier(self)
            else:
                return visitor.visitChildren(self)



    def strictIdentifier(self):

        localctx = fugue_sqlParser.StrictIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 416, self.RULE_strictIdentifier)
        try:
            self.state = 3814
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [339]:
                localctx = fugue_sqlParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3811
                self.match(fugue_sqlParser.IDENTIFIER)
                pass
            elif token in [340]:
                localctx = fugue_sqlParser.QuotedIdentifierAlternativeContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3812
                self.quotedIdentifier()
                pass
            elif token in [58, 59, 60, 61, 62, 63, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 163, 164, 165, 167, 168, 169, 170, 172, 173, 174, 175, 176, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 198, 199, 200, 201, 202, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 254, 255, 256, 257, 258, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 294, 295, 296, 297, 298, 299, 300, 302, 303, 304, 305, 306, 307, 308, 309, 324]:
                localctx = fugue_sqlParser.UnquotedIdentifierContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3813
                self.nonReserved()
                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 QuotedIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BACKQUOTED_IDENTIFIER(self):
            return self.getToken(fugue_sqlParser.BACKQUOTED_IDENTIFIER, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_quotedIdentifier

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuotedIdentifier" ):
                return visitor.visitQuotedIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def quotedIdentifier(self):

        localctx = fugue_sqlParser.QuotedIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 418, self.RULE_quotedIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3816
            self.match(fugue_sqlParser.BACKQUOTED_IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return fugue_sqlParser.RULE_number

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class DecimalLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DECIMAL_VALUE(self):
            return self.getToken(fugue_sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDecimalLiteral" ):
                return visitor.visitDecimalLiteral(self)
            else:
                return visitor.visitChildren(self)


    class BigIntLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def BIGINT_LITERAL(self):
            return self.getToken(fugue_sqlParser.BIGINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBigIntLiteral" ):
                return visitor.visitBigIntLiteral(self)
            else:
                return visitor.visitChildren(self)


    class TinyIntLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TINYINT_LITERAL(self):
            return self.getToken(fugue_sqlParser.TINYINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTinyIntLiteral" ):
                return visitor.visitTinyIntLiteral(self)
            else:
                return visitor.visitChildren(self)


    class LegacyDecimalLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXPONENT_VALUE(self):
            return self.getToken(fugue_sqlParser.EXPONENT_VALUE, 0)
        def DECIMAL_VALUE(self):
            return self.getToken(fugue_sqlParser.DECIMAL_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLegacyDecimalLiteral" ):
                return visitor.visitLegacyDecimalLiteral(self)
            else:
                return visitor.visitChildren(self)


    class BigDecimalLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def BIGDECIMAL_LITERAL(self):
            return self.getToken(fugue_sqlParser.BIGDECIMAL_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBigDecimalLiteral" ):
                return visitor.visitBigDecimalLiteral(self)
            else:
                return visitor.visitChildren(self)


    class ExponentLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXPONENT_VALUE(self):
            return self.getToken(fugue_sqlParser.EXPONENT_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExponentLiteral" ):
                return visitor.visitExponentLiteral(self)
            else:
                return visitor.visitChildren(self)


    class DoubleLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DOUBLE_LITERAL(self):
            return self.getToken(fugue_sqlParser.DOUBLE_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDoubleLiteral" ):
                return visitor.visitDoubleLiteral(self)
            else:
                return visitor.visitChildren(self)


    class IntegerLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def INTEGER_VALUE(self):
            return self.getToken(fugue_sqlParser.INTEGER_VALUE, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntegerLiteral" ):
                return visitor.visitIntegerLiteral(self)
            else:
                return visitor.visitChildren(self)


    class SmallIntLiteralContext(NumberContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a fugue_sqlParser.NumberContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SMALLINT_LITERAL(self):
            return self.getToken(fugue_sqlParser.SMALLINT_LITERAL, 0)
        def MINUS(self):
            return self.getToken(fugue_sqlParser.MINUS, 0)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSmallIntLiteral" ):
                return visitor.visitSmallIntLiteral(self)
            else:
                return visitor.visitChildren(self)



    def number(self):

        localctx = fugue_sqlParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 420, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.state = 3854
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,522,self._ctx)
            if la_ == 1:
                localctx = fugue_sqlParser.ExponentLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 3819
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3818
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3821
                self.match(fugue_sqlParser.EXPONENT_VALUE)
                pass

            elif la_ == 2:
                localctx = fugue_sqlParser.DecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 3823
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3822
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3825
                self.match(fugue_sqlParser.DECIMAL_VALUE)
                pass

            elif la_ == 3:
                localctx = fugue_sqlParser.LegacyDecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 3827
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3826
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3829
                _la = self._input.LA(1)
                if not(_la==335 or _la==336):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 4:
                localctx = fugue_sqlParser.IntegerLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 3831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3830
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3833
                self.match(fugue_sqlParser.INTEGER_VALUE)
                pass

            elif la_ == 5:
                localctx = fugue_sqlParser.BigIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 3835
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3834
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3837
                self.match(fugue_sqlParser.BIGINT_LITERAL)
                pass

            elif la_ == 6:
                localctx = fugue_sqlParser.SmallIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 3839
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3838
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3841
                self.match(fugue_sqlParser.SMALLINT_LITERAL)
                pass

            elif la_ == 7:
                localctx = fugue_sqlParser.TinyIntLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 3843
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3842
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3845
                self.match(fugue_sqlParser.TINYINT_LITERAL)
                pass

            elif la_ == 8:
                localctx = fugue_sqlParser.DoubleLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 3847
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3846
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3849
                self.match(fugue_sqlParser.DOUBLE_LITERAL)
                pass

            elif la_ == 9:
                localctx = fugue_sqlParser.BigDecimalLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 3851
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==320:
                    self.state = 3850
                    self.match(fugue_sqlParser.MINUS)


                self.state = 3853
                self.match(fugue_sqlParser.BIGDECIMAL_LITERAL)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AlterColumnActionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.setOrDrop = None # Token

        def TYPE(self):
            return self.getToken(fugue_sqlParser.TYPE, 0)

        def dataType(self):
            return self.getTypedRuleContext(fugue_sqlParser.DataTypeContext,0)


        def commentSpec(self):
            return self.getTypedRuleContext(fugue_sqlParser.CommentSpecContext,0)


        def colPosition(self):
            return self.getTypedRuleContext(fugue_sqlParser.ColPositionContext,0)


        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)

        def DROP(self):
            return self.getToken(fugue_sqlParser.DROP, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_alterColumnAction

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAlterColumnAction" ):
                return visitor.visitAlterColumnAction(self)
            else:
                return visitor.visitChildren(self)




    def alterColumnAction(self):

        localctx = fugue_sqlParser.AlterColumnActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 422, self.RULE_alterColumnAction)
        self._la = 0 # Token type
        try:
            self.state = 3863
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [289]:
                self.enterOuterAlt(localctx, 1)
                self.state = 3856
                self.match(fugue_sqlParser.TYPE)
                self.state = 3857
                self.dataType()
                pass
            elif token in [91]:
                self.enterOuterAlt(localctx, 2)
                self.state = 3858
                self.commentSpec()
                pass
            elif token in [59, 140]:
                self.enterOuterAlt(localctx, 3)
                self.state = 3859
                self.colPosition()
                pass
            elif token in [122, 258]:
                self.enterOuterAlt(localctx, 4)
                self.state = 3860
                localctx.setOrDrop = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==122 or _la==258):
                    localctx.setOrDrop = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 3861
                self.match(fugue_sqlParser.NOT)
                self.state = 3862
                self.match(fugue_sqlParser.THENULL)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AnsiNonReservedContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ADD(self):
            return self.getToken(fugue_sqlParser.ADD, 0)

        def AFTER(self):
            return self.getToken(fugue_sqlParser.AFTER, 0)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)

        def ANALYZE(self):
            return self.getToken(fugue_sqlParser.ANALYZE, 0)

        def ARCHIVE(self):
            return self.getToken(fugue_sqlParser.ARCHIVE, 0)

        def ARRAY(self):
            return self.getToken(fugue_sqlParser.ARRAY, 0)

        def ASC(self):
            return self.getToken(fugue_sqlParser.ASC, 0)

        def AT(self):
            return self.getToken(fugue_sqlParser.AT, 0)

        def BETWEEN(self):
            return self.getToken(fugue_sqlParser.BETWEEN, 0)

        def BUCKET(self):
            return self.getToken(fugue_sqlParser.BUCKET, 0)

        def BUCKETS(self):
            return self.getToken(fugue_sqlParser.BUCKETS, 0)

        def BY(self):
            return self.getToken(fugue_sqlParser.BY, 0)

        def CACHE(self):
            return self.getToken(fugue_sqlParser.CACHE, 0)

        def CASCADE(self):
            return self.getToken(fugue_sqlParser.CASCADE, 0)

        def CHANGE(self):
            return self.getToken(fugue_sqlParser.CHANGE, 0)

        def CLEAR(self):
            return self.getToken(fugue_sqlParser.CLEAR, 0)

        def CLUSTER(self):
            return self.getToken(fugue_sqlParser.CLUSTER, 0)

        def CLUSTERED(self):
            return self.getToken(fugue_sqlParser.CLUSTERED, 0)

        def CODEGEN(self):
            return self.getToken(fugue_sqlParser.CODEGEN, 0)

        def COLLECTION(self):
            return self.getToken(fugue_sqlParser.COLLECTION, 0)

        def COLUMNS(self):
            return self.getToken(fugue_sqlParser.COLUMNS, 0)

        def COMMENT(self):
            return self.getToken(fugue_sqlParser.COMMENT, 0)

        def COMMIT(self):
            return self.getToken(fugue_sqlParser.COMMIT, 0)

        def COMPACT(self):
            return self.getToken(fugue_sqlParser.COMPACT, 0)

        def COMPACTIONS(self):
            return self.getToken(fugue_sqlParser.COMPACTIONS, 0)

        def COMPUTE(self):
            return self.getToken(fugue_sqlParser.COMPUTE, 0)

        def CONCATENATE(self):
            return self.getToken(fugue_sqlParser.CONCATENATE, 0)

        def COST(self):
            return self.getToken(fugue_sqlParser.COST, 0)

        def CUBE(self):
            return self.getToken(fugue_sqlParser.CUBE, 0)

        def CURRENT(self):
            return self.getToken(fugue_sqlParser.CURRENT, 0)

        def DATA(self):
            return self.getToken(fugue_sqlParser.DATA, 0)

        def DATABASE(self):
            return self.getToken(fugue_sqlParser.DATABASE, 0)

        def DATABASES(self):
            return self.getToken(fugue_sqlParser.DATABASES, 0)

        def DBPROPERTIES(self):
            return self.getToken(fugue_sqlParser.DBPROPERTIES, 0)

        def DEFINED(self):
            return self.getToken(fugue_sqlParser.DEFINED, 0)

        def DELETE(self):
            return self.getToken(fugue_sqlParser.DELETE, 0)

        def DELIMITED(self):
            return self.getToken(fugue_sqlParser.DELIMITED, 0)

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)

        def DESCRIBE(self):
            return self.getToken(fugue_sqlParser.DESCRIBE, 0)

        def DFS(self):
            return self.getToken(fugue_sqlParser.DFS, 0)

        def DIRECTORIES(self):
            return self.getToken(fugue_sqlParser.DIRECTORIES, 0)

        def DIRECTORY(self):
            return self.getToken(fugue_sqlParser.DIRECTORY, 0)

        def DISTRIBUTE(self):
            return self.getToken(fugue_sqlParser.DISTRIBUTE, 0)

        def DIV(self):
            return self.getToken(fugue_sqlParser.DIV, 0)

        def DROP(self):
            return self.getToken(fugue_sqlParser.DROP, 0)

        def ESCAPED(self):
            return self.getToken(fugue_sqlParser.ESCAPED, 0)

        def EXCHANGE(self):
            return self.getToken(fugue_sqlParser.EXCHANGE, 0)

        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)

        def EXPLAIN(self):
            return self.getToken(fugue_sqlParser.EXPLAIN, 0)

        def EXPORT(self):
            return self.getToken(fugue_sqlParser.EXPORT, 0)

        def EXTENDED(self):
            return self.getToken(fugue_sqlParser.EXTENDED, 0)

        def EXTERNAL(self):
            return self.getToken(fugue_sqlParser.EXTERNAL, 0)

        def EXTRACT(self):
            return self.getToken(fugue_sqlParser.EXTRACT, 0)

        def FIELDS(self):
            return self.getToken(fugue_sqlParser.FIELDS, 0)

        def FILEFORMAT(self):
            return self.getToken(fugue_sqlParser.FILEFORMAT, 0)

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)

        def FOLLOWING(self):
            return self.getToken(fugue_sqlParser.FOLLOWING, 0)

        def FORMAT(self):
            return self.getToken(fugue_sqlParser.FORMAT, 0)

        def FORMATTED(self):
            return self.getToken(fugue_sqlParser.FORMATTED, 0)

        def FUNCTION(self):
            return self.getToken(fugue_sqlParser.FUNCTION, 0)

        def FUNCTIONS(self):
            return self.getToken(fugue_sqlParser.FUNCTIONS, 0)

        def GLOBAL(self):
            return self.getToken(fugue_sqlParser.GLOBAL, 0)

        def GROUPING(self):
            return self.getToken(fugue_sqlParser.GROUPING, 0)

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)

        def IGNORE(self):
            return self.getToken(fugue_sqlParser.IGNORE, 0)

        def IMPORT(self):
            return self.getToken(fugue_sqlParser.IMPORT, 0)

        def INDEX(self):
            return self.getToken(fugue_sqlParser.INDEX, 0)

        def INDEXES(self):
            return self.getToken(fugue_sqlParser.INDEXES, 0)

        def INPATH(self):
            return self.getToken(fugue_sqlParser.INPATH, 0)

        def INPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.INPUTFORMAT, 0)

        def INSERT(self):
            return self.getToken(fugue_sqlParser.INSERT, 0)

        def INTERVAL(self):
            return self.getToken(fugue_sqlParser.INTERVAL, 0)

        def ITEMS(self):
            return self.getToken(fugue_sqlParser.ITEMS, 0)

        def KEYS(self):
            return self.getToken(fugue_sqlParser.KEYS, 0)

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)

        def LATERAL(self):
            return self.getToken(fugue_sqlParser.LATERAL, 0)

        def LAZY(self):
            return self.getToken(fugue_sqlParser.LAZY, 0)

        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)

        def LIMIT(self):
            return self.getToken(fugue_sqlParser.LIMIT, 0)

        def LINES(self):
            return self.getToken(fugue_sqlParser.LINES, 0)

        def LIST(self):
            return self.getToken(fugue_sqlParser.LIST, 0)

        def LOAD(self):
            return self.getToken(fugue_sqlParser.LOAD, 0)

        def LOCAL(self):
            return self.getToken(fugue_sqlParser.LOCAL, 0)

        def LOCATION(self):
            return self.getToken(fugue_sqlParser.LOCATION, 0)

        def LOCK(self):
            return self.getToken(fugue_sqlParser.LOCK, 0)

        def LOCKS(self):
            return self.getToken(fugue_sqlParser.LOCKS, 0)

        def LOGICAL(self):
            return self.getToken(fugue_sqlParser.LOGICAL, 0)

        def MACRO(self):
            return self.getToken(fugue_sqlParser.MACRO, 0)

        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)

        def MATCHED(self):
            return self.getToken(fugue_sqlParser.MATCHED, 0)

        def MERGE(self):
            return self.getToken(fugue_sqlParser.MERGE, 0)

        def MSCK(self):
            return self.getToken(fugue_sqlParser.MSCK, 0)

        def NAMESPACE(self):
            return self.getToken(fugue_sqlParser.NAMESPACE, 0)

        def NAMESPACES(self):
            return self.getToken(fugue_sqlParser.NAMESPACES, 0)

        def NO(self):
            return self.getToken(fugue_sqlParser.NO, 0)

        def THENULLS(self):
            return self.getToken(fugue_sqlParser.THENULLS, 0)

        def OF(self):
            return self.getToken(fugue_sqlParser.OF, 0)

        def OPTION(self):
            return self.getToken(fugue_sqlParser.OPTION, 0)

        def OPTIONS(self):
            return self.getToken(fugue_sqlParser.OPTIONS, 0)

        def OUT(self):
            return self.getToken(fugue_sqlParser.OUT, 0)

        def OUTPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.OUTPUTFORMAT, 0)

        def OVER(self):
            return self.getToken(fugue_sqlParser.OVER, 0)

        def OVERLAY(self):
            return self.getToken(fugue_sqlParser.OVERLAY, 0)

        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)

        def PARTITION(self):
            return self.getToken(fugue_sqlParser.PARTITION, 0)

        def PARTITIONED(self):
            return self.getToken(fugue_sqlParser.PARTITIONED, 0)

        def PARTITIONS(self):
            return self.getToken(fugue_sqlParser.PARTITIONS, 0)

        def PERCENTLIT(self):
            return self.getToken(fugue_sqlParser.PERCENTLIT, 0)

        def PIVOT(self):
            return self.getToken(fugue_sqlParser.PIVOT, 0)

        def PLACING(self):
            return self.getToken(fugue_sqlParser.PLACING, 0)

        def POSITION(self):
            return self.getToken(fugue_sqlParser.POSITION, 0)

        def PRECEDING(self):
            return self.getToken(fugue_sqlParser.PRECEDING, 0)

        def PRINCIPALS(self):
            return self.getToken(fugue_sqlParser.PRINCIPALS, 0)

        def PROPERTIES(self):
            return self.getToken(fugue_sqlParser.PROPERTIES, 0)

        def PURGE(self):
            return self.getToken(fugue_sqlParser.PURGE, 0)

        def QUERY(self):
            return self.getToken(fugue_sqlParser.QUERY, 0)

        def RANGE(self):
            return self.getToken(fugue_sqlParser.RANGE, 0)

        def RECORDREADER(self):
            return self.getToken(fugue_sqlParser.RECORDREADER, 0)

        def RECORDWRITER(self):
            return self.getToken(fugue_sqlParser.RECORDWRITER, 0)

        def RECOVER(self):
            return self.getToken(fugue_sqlParser.RECOVER, 0)

        def REDUCE(self):
            return self.getToken(fugue_sqlParser.REDUCE, 0)

        def REFRESH(self):
            return self.getToken(fugue_sqlParser.REFRESH, 0)

        def RENAME(self):
            return self.getToken(fugue_sqlParser.RENAME, 0)

        def REPAIR(self):
            return self.getToken(fugue_sqlParser.REPAIR, 0)

        def REPLACE(self):
            return self.getToken(fugue_sqlParser.REPLACE, 0)

        def RESET(self):
            return self.getToken(fugue_sqlParser.RESET, 0)

        def RESTRICT(self):
            return self.getToken(fugue_sqlParser.RESTRICT, 0)

        def REVOKE(self):
            return self.getToken(fugue_sqlParser.REVOKE, 0)

        def RLIKE(self):
            return self.getToken(fugue_sqlParser.RLIKE, 0)

        def ROLE(self):
            return self.getToken(fugue_sqlParser.ROLE, 0)

        def ROLES(self):
            return self.getToken(fugue_sqlParser.ROLES, 0)

        def ROLLBACK(self):
            return self.getToken(fugue_sqlParser.ROLLBACK, 0)

        def ROLLUP(self):
            return self.getToken(fugue_sqlParser.ROLLUP, 0)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

        def SCHEMA(self):
            return self.getToken(fugue_sqlParser.SCHEMA, 0)

        def SEPARATED(self):
            return self.getToken(fugue_sqlParser.SEPARATED, 0)

        def SERDE(self):
            return self.getToken(fugue_sqlParser.SERDE, 0)

        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)

        def SETS(self):
            return self.getToken(fugue_sqlParser.SETS, 0)

        def SHOW(self):
            return self.getToken(fugue_sqlParser.SHOW, 0)

        def SKEWED(self):
            return self.getToken(fugue_sqlParser.SKEWED, 0)

        def SORT(self):
            return self.getToken(fugue_sqlParser.SORT, 0)

        def SORTED(self):
            return self.getToken(fugue_sqlParser.SORTED, 0)

        def START(self):
            return self.getToken(fugue_sqlParser.START, 0)

        def STATISTICS(self):
            return self.getToken(fugue_sqlParser.STATISTICS, 0)

        def STORED(self):
            return self.getToken(fugue_sqlParser.STORED, 0)

        def STRATIFY(self):
            return self.getToken(fugue_sqlParser.STRATIFY, 0)

        def STRUCT(self):
            return self.getToken(fugue_sqlParser.STRUCT, 0)

        def SUBSTR(self):
            return self.getToken(fugue_sqlParser.SUBSTR, 0)

        def SUBSTRING(self):
            return self.getToken(fugue_sqlParser.SUBSTRING, 0)

        def TABLES(self):
            return self.getToken(fugue_sqlParser.TABLES, 0)

        def TABLESAMPLE(self):
            return self.getToken(fugue_sqlParser.TABLESAMPLE, 0)

        def TBLPROPERTIES(self):
            return self.getToken(fugue_sqlParser.TBLPROPERTIES, 0)

        def TEMPORARY(self):
            return self.getToken(fugue_sqlParser.TEMPORARY, 0)

        def TERMINATED(self):
            return self.getToken(fugue_sqlParser.TERMINATED, 0)

        def TOUCH(self):
            return self.getToken(fugue_sqlParser.TOUCH, 0)

        def TRANSACTION(self):
            return self.getToken(fugue_sqlParser.TRANSACTION, 0)

        def TRANSACTIONS(self):
            return self.getToken(fugue_sqlParser.TRANSACTIONS, 0)

        def TRANSFORM(self):
            return self.getToken(fugue_sqlParser.TRANSFORM, 0)

        def TRIM(self):
            return self.getToken(fugue_sqlParser.TRIM, 0)

        def TRUE(self):
            return self.getToken(fugue_sqlParser.TRUE, 0)

        def TRUNCATE(self):
            return self.getToken(fugue_sqlParser.TRUNCATE, 0)

        def UNARCHIVE(self):
            return self.getToken(fugue_sqlParser.UNARCHIVE, 0)

        def UNBOUNDED(self):
            return self.getToken(fugue_sqlParser.UNBOUNDED, 0)

        def UNCACHE(self):
            return self.getToken(fugue_sqlParser.UNCACHE, 0)

        def UNLOCK(self):
            return self.getToken(fugue_sqlParser.UNLOCK, 0)

        def UNSET(self):
            return self.getToken(fugue_sqlParser.UNSET, 0)

        def UPDATE(self):
            return self.getToken(fugue_sqlParser.UPDATE, 0)

        def USE(self):
            return self.getToken(fugue_sqlParser.USE, 0)

        def VALUES(self):
            return self.getToken(fugue_sqlParser.VALUES, 0)

        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)

        def VIEWS(self):
            return self.getToken(fugue_sqlParser.VIEWS, 0)

        def WINDOW(self):
            return self.getToken(fugue_sqlParser.WINDOW, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_ansiNonReserved

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAnsiNonReserved" ):
                return visitor.visitAnsiNonReserved(self)
            else:
                return visitor.visitChildren(self)




    def ansiNonReserved(self):

        localctx = fugue_sqlParser.AnsiNonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 424, self.RULE_ansiNonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3865
            _la = self._input.LA(1)
            if not((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & -4616724533169136869) != 0 or (((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & -54836095400108079) != 0 or (((_la - 186)) & ~0x3f) == 0 and ((1 << (_la - 186)) & -72339344050251969) != 0 or (((_la - 250)) & ~0x3f) == 0 and ((1 << (_la - 250)) & 176704157053345137) != 0 or _la==324):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StrictNonReservedContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ANTI(self):
            return self.getToken(fugue_sqlParser.ANTI, 0)

        def CROSS(self):
            return self.getToken(fugue_sqlParser.CROSS, 0)

        def EXCEPT(self):
            return self.getToken(fugue_sqlParser.EXCEPT, 0)

        def FULL(self):
            return self.getToken(fugue_sqlParser.FULL, 0)

        def INNER(self):
            return self.getToken(fugue_sqlParser.INNER, 0)

        def INTERSECT(self):
            return self.getToken(fugue_sqlParser.INTERSECT, 0)

        def JOIN(self):
            return self.getToken(fugue_sqlParser.JOIN, 0)

        def LEFT(self):
            return self.getToken(fugue_sqlParser.LEFT, 0)

        def NATURAL(self):
            return self.getToken(fugue_sqlParser.NATURAL, 0)

        def ON(self):
            return self.getToken(fugue_sqlParser.ON, 0)

        def RIGHT(self):
            return self.getToken(fugue_sqlParser.RIGHT, 0)

        def SEMI(self):
            return self.getToken(fugue_sqlParser.SEMI, 0)

        def SETMINUS(self):
            return self.getToken(fugue_sqlParser.SETMINUS, 0)

        def UNION(self):
            return self.getToken(fugue_sqlParser.UNION, 0)

        def USING(self):
            return self.getToken(fugue_sqlParser.USING, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_strictNonReserved

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStrictNonReserved" ):
                return visitor.visitStrictNonReserved(self)
            else:
                return visitor.visitChildren(self)




    def strictNonReserved(self):

        localctx = fugue_sqlParser.StrictNonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 426, self.RULE_strictNonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3867
            _la = self._input.LA(1)
            if not((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -9223371968135299071) != 0 or (((_la - 147)) & ~0x3f) == 0 and ((1 << (_la - 147)) & 73183495035846657) != 0 or (((_la - 242)) & ~0x3f) == 0 and ((1 << (_la - 242)) & 578712552117241857) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NonReservedContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ADD(self):
            return self.getToken(fugue_sqlParser.ADD, 0)

        def AFTER(self):
            return self.getToken(fugue_sqlParser.AFTER, 0)

        def ALL(self):
            return self.getToken(fugue_sqlParser.ALL, 0)

        def ALTER(self):
            return self.getToken(fugue_sqlParser.ALTER, 0)

        def ANALYZE(self):
            return self.getToken(fugue_sqlParser.ANALYZE, 0)

        def AND(self):
            return self.getToken(fugue_sqlParser.AND, 0)

        def ANY(self):
            return self.getToken(fugue_sqlParser.ANY, 0)

        def ARCHIVE(self):
            return self.getToken(fugue_sqlParser.ARCHIVE, 0)

        def ARRAY(self):
            return self.getToken(fugue_sqlParser.ARRAY, 0)

        def AS(self):
            return self.getToken(fugue_sqlParser.AS, 0)

        def ASC(self):
            return self.getToken(fugue_sqlParser.ASC, 0)

        def AT(self):
            return self.getToken(fugue_sqlParser.AT, 0)

        def AUTHORIZATION(self):
            return self.getToken(fugue_sqlParser.AUTHORIZATION, 0)

        def BETWEEN(self):
            return self.getToken(fugue_sqlParser.BETWEEN, 0)

        def BOTH(self):
            return self.getToken(fugue_sqlParser.BOTH, 0)

        def BUCKET(self):
            return self.getToken(fugue_sqlParser.BUCKET, 0)

        def BUCKETS(self):
            return self.getToken(fugue_sqlParser.BUCKETS, 0)

        def BY(self):
            return self.getToken(fugue_sqlParser.BY, 0)

        def CACHE(self):
            return self.getToken(fugue_sqlParser.CACHE, 0)

        def CASCADE(self):
            return self.getToken(fugue_sqlParser.CASCADE, 0)

        def CASE(self):
            return self.getToken(fugue_sqlParser.CASE, 0)

        def CAST(self):
            return self.getToken(fugue_sqlParser.CAST, 0)

        def CHANGE(self):
            return self.getToken(fugue_sqlParser.CHANGE, 0)

        def CHECK(self):
            return self.getToken(fugue_sqlParser.CHECK, 0)

        def CLEAR(self):
            return self.getToken(fugue_sqlParser.CLEAR, 0)

        def CLUSTER(self):
            return self.getToken(fugue_sqlParser.CLUSTER, 0)

        def CLUSTERED(self):
            return self.getToken(fugue_sqlParser.CLUSTERED, 0)

        def CODEGEN(self):
            return self.getToken(fugue_sqlParser.CODEGEN, 0)

        def COLLATE(self):
            return self.getToken(fugue_sqlParser.COLLATE, 0)

        def COLLECTION(self):
            return self.getToken(fugue_sqlParser.COLLECTION, 0)

        def COLUMN(self):
            return self.getToken(fugue_sqlParser.COLUMN, 0)

        def COLUMNS(self):
            return self.getToken(fugue_sqlParser.COLUMNS, 0)

        def COMMENT(self):
            return self.getToken(fugue_sqlParser.COMMENT, 0)

        def COMMIT(self):
            return self.getToken(fugue_sqlParser.COMMIT, 0)

        def COMPACT(self):
            return self.getToken(fugue_sqlParser.COMPACT, 0)

        def COMPACTIONS(self):
            return self.getToken(fugue_sqlParser.COMPACTIONS, 0)

        def COMPUTE(self):
            return self.getToken(fugue_sqlParser.COMPUTE, 0)

        def CONCATENATE(self):
            return self.getToken(fugue_sqlParser.CONCATENATE, 0)

        def CONSTRAINT(self):
            return self.getToken(fugue_sqlParser.CONSTRAINT, 0)

        def COST(self):
            return self.getToken(fugue_sqlParser.COST, 0)

        def CREATE(self):
            return self.getToken(fugue_sqlParser.CREATE, 0)

        def CUBE(self):
            return self.getToken(fugue_sqlParser.CUBE, 0)

        def CURRENT(self):
            return self.getToken(fugue_sqlParser.CURRENT, 0)

        def CURRENT_DATE(self):
            return self.getToken(fugue_sqlParser.CURRENT_DATE, 0)

        def CURRENT_TIME(self):
            return self.getToken(fugue_sqlParser.CURRENT_TIME, 0)

        def CURRENT_TIMESTAMP(self):
            return self.getToken(fugue_sqlParser.CURRENT_TIMESTAMP, 0)

        def CURRENT_USER(self):
            return self.getToken(fugue_sqlParser.CURRENT_USER, 0)

        def DATA(self):
            return self.getToken(fugue_sqlParser.DATA, 0)

        def DATABASE(self):
            return self.getToken(fugue_sqlParser.DATABASE, 0)

        def DATABASES(self):
            return self.getToken(fugue_sqlParser.DATABASES, 0)

        def DAY(self):
            return self.getToken(fugue_sqlParser.DAY, 0)

        def DBPROPERTIES(self):
            return self.getToken(fugue_sqlParser.DBPROPERTIES, 0)

        def DEFINED(self):
            return self.getToken(fugue_sqlParser.DEFINED, 0)

        def DELETE(self):
            return self.getToken(fugue_sqlParser.DELETE, 0)

        def DELIMITED(self):
            return self.getToken(fugue_sqlParser.DELIMITED, 0)

        def DESC(self):
            return self.getToken(fugue_sqlParser.DESC, 0)

        def DESCRIBE(self):
            return self.getToken(fugue_sqlParser.DESCRIBE, 0)

        def DFS(self):
            return self.getToken(fugue_sqlParser.DFS, 0)

        def DIRECTORIES(self):
            return self.getToken(fugue_sqlParser.DIRECTORIES, 0)

        def DIRECTORY(self):
            return self.getToken(fugue_sqlParser.DIRECTORY, 0)

        def DISTINCT(self):
            return self.getToken(fugue_sqlParser.DISTINCT, 0)

        def DISTRIBUTE(self):
            return self.getToken(fugue_sqlParser.DISTRIBUTE, 0)

        def DIV(self):
            return self.getToken(fugue_sqlParser.DIV, 0)

        def DROP(self):
            return self.getToken(fugue_sqlParser.DROP, 0)

        def ELSE(self):
            return self.getToken(fugue_sqlParser.ELSE, 0)

        def END(self):
            return self.getToken(fugue_sqlParser.END, 0)

        def ESCAPE(self):
            return self.getToken(fugue_sqlParser.ESCAPE, 0)

        def ESCAPED(self):
            return self.getToken(fugue_sqlParser.ESCAPED, 0)

        def EXCHANGE(self):
            return self.getToken(fugue_sqlParser.EXCHANGE, 0)

        def EXISTS(self):
            return self.getToken(fugue_sqlParser.EXISTS, 0)

        def EXPLAIN(self):
            return self.getToken(fugue_sqlParser.EXPLAIN, 0)

        def EXPORT(self):
            return self.getToken(fugue_sqlParser.EXPORT, 0)

        def EXTENDED(self):
            return self.getToken(fugue_sqlParser.EXTENDED, 0)

        def EXTERNAL(self):
            return self.getToken(fugue_sqlParser.EXTERNAL, 0)

        def EXTRACT(self):
            return self.getToken(fugue_sqlParser.EXTRACT, 0)

        def FALSE(self):
            return self.getToken(fugue_sqlParser.FALSE, 0)

        def FETCH(self):
            return self.getToken(fugue_sqlParser.FETCH, 0)

        def FILTER(self):
            return self.getToken(fugue_sqlParser.FILTER, 0)

        def FIELDS(self):
            return self.getToken(fugue_sqlParser.FIELDS, 0)

        def FILEFORMAT(self):
            return self.getToken(fugue_sqlParser.FILEFORMAT, 0)

        def FIRST(self):
            return self.getToken(fugue_sqlParser.FIRST, 0)

        def FOLLOWING(self):
            return self.getToken(fugue_sqlParser.FOLLOWING, 0)

        def FOR(self):
            return self.getToken(fugue_sqlParser.FOR, 0)

        def FOREIGN(self):
            return self.getToken(fugue_sqlParser.FOREIGN, 0)

        def FORMAT(self):
            return self.getToken(fugue_sqlParser.FORMAT, 0)

        def FORMATTED(self):
            return self.getToken(fugue_sqlParser.FORMATTED, 0)

        def FROM(self):
            return self.getToken(fugue_sqlParser.FROM, 0)

        def FUNCTION(self):
            return self.getToken(fugue_sqlParser.FUNCTION, 0)

        def FUNCTIONS(self):
            return self.getToken(fugue_sqlParser.FUNCTIONS, 0)

        def GLOBAL(self):
            return self.getToken(fugue_sqlParser.GLOBAL, 0)

        def GRANT(self):
            return self.getToken(fugue_sqlParser.GRANT, 0)

        def GROUP(self):
            return self.getToken(fugue_sqlParser.GROUP, 0)

        def GROUPING(self):
            return self.getToken(fugue_sqlParser.GROUPING, 0)

        def HAVING(self):
            return self.getToken(fugue_sqlParser.HAVING, 0)

        def HOUR(self):
            return self.getToken(fugue_sqlParser.HOUR, 0)

        def IF(self):
            return self.getToken(fugue_sqlParser.IF, 0)

        def IGNORE(self):
            return self.getToken(fugue_sqlParser.IGNORE, 0)

        def IMPORT(self):
            return self.getToken(fugue_sqlParser.IMPORT, 0)

        def IN(self):
            return self.getToken(fugue_sqlParser.IN, 0)

        def INDEX(self):
            return self.getToken(fugue_sqlParser.INDEX, 0)

        def INDEXES(self):
            return self.getToken(fugue_sqlParser.INDEXES, 0)

        def INPATH(self):
            return self.getToken(fugue_sqlParser.INPATH, 0)

        def INPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.INPUTFORMAT, 0)

        def INSERT(self):
            return self.getToken(fugue_sqlParser.INSERT, 0)

        def INTERVAL(self):
            return self.getToken(fugue_sqlParser.INTERVAL, 0)

        def INTO(self):
            return self.getToken(fugue_sqlParser.INTO, 0)

        def IS(self):
            return self.getToken(fugue_sqlParser.IS, 0)

        def ITEMS(self):
            return self.getToken(fugue_sqlParser.ITEMS, 0)

        def KEYS(self):
            return self.getToken(fugue_sqlParser.KEYS, 0)

        def LAST(self):
            return self.getToken(fugue_sqlParser.LAST, 0)

        def LATERAL(self):
            return self.getToken(fugue_sqlParser.LATERAL, 0)

        def LAZY(self):
            return self.getToken(fugue_sqlParser.LAZY, 0)

        def LEADING(self):
            return self.getToken(fugue_sqlParser.LEADING, 0)

        def LIKE(self):
            return self.getToken(fugue_sqlParser.LIKE, 0)

        def LIMIT(self):
            return self.getToken(fugue_sqlParser.LIMIT, 0)

        def LINES(self):
            return self.getToken(fugue_sqlParser.LINES, 0)

        def LIST(self):
            return self.getToken(fugue_sqlParser.LIST, 0)

        def LOAD(self):
            return self.getToken(fugue_sqlParser.LOAD, 0)

        def LOCAL(self):
            return self.getToken(fugue_sqlParser.LOCAL, 0)

        def LOCATION(self):
            return self.getToken(fugue_sqlParser.LOCATION, 0)

        def LOCK(self):
            return self.getToken(fugue_sqlParser.LOCK, 0)

        def LOCKS(self):
            return self.getToken(fugue_sqlParser.LOCKS, 0)

        def LOGICAL(self):
            return self.getToken(fugue_sqlParser.LOGICAL, 0)

        def MACRO(self):
            return self.getToken(fugue_sqlParser.MACRO, 0)

        def MAP(self):
            return self.getToken(fugue_sqlParser.MAP, 0)

        def MATCHED(self):
            return self.getToken(fugue_sqlParser.MATCHED, 0)

        def MERGE(self):
            return self.getToken(fugue_sqlParser.MERGE, 0)

        def MINUTE(self):
            return self.getToken(fugue_sqlParser.MINUTE, 0)

        def MONTH(self):
            return self.getToken(fugue_sqlParser.MONTH, 0)

        def MSCK(self):
            return self.getToken(fugue_sqlParser.MSCK, 0)

        def NAMESPACE(self):
            return self.getToken(fugue_sqlParser.NAMESPACE, 0)

        def NAMESPACES(self):
            return self.getToken(fugue_sqlParser.NAMESPACES, 0)

        def NO(self):
            return self.getToken(fugue_sqlParser.NO, 0)

        def NOT(self):
            return self.getToken(fugue_sqlParser.NOT, 0)

        def THENULL(self):
            return self.getToken(fugue_sqlParser.THENULL, 0)

        def THENULLS(self):
            return self.getToken(fugue_sqlParser.THENULLS, 0)

        def OF(self):
            return self.getToken(fugue_sqlParser.OF, 0)

        def ONLY(self):
            return self.getToken(fugue_sqlParser.ONLY, 0)

        def OPTION(self):
            return self.getToken(fugue_sqlParser.OPTION, 0)

        def OPTIONS(self):
            return self.getToken(fugue_sqlParser.OPTIONS, 0)

        def OR(self):
            return self.getToken(fugue_sqlParser.OR, 0)

        def ORDER(self):
            return self.getToken(fugue_sqlParser.ORDER, 0)

        def OUT(self):
            return self.getToken(fugue_sqlParser.OUT, 0)

        def OUTER(self):
            return self.getToken(fugue_sqlParser.OUTER, 0)

        def OUTPUTFORMAT(self):
            return self.getToken(fugue_sqlParser.OUTPUTFORMAT, 0)

        def OVER(self):
            return self.getToken(fugue_sqlParser.OVER, 0)

        def OVERLAPS(self):
            return self.getToken(fugue_sqlParser.OVERLAPS, 0)

        def OVERLAY(self):
            return self.getToken(fugue_sqlParser.OVERLAY, 0)

        def OVERWRITE(self):
            return self.getToken(fugue_sqlParser.OVERWRITE, 0)

        def PARTITION(self):
            return self.getToken(fugue_sqlParser.PARTITION, 0)

        def PARTITIONED(self):
            return self.getToken(fugue_sqlParser.PARTITIONED, 0)

        def PARTITIONS(self):
            return self.getToken(fugue_sqlParser.PARTITIONS, 0)

        def PERCENTLIT(self):
            return self.getToken(fugue_sqlParser.PERCENTLIT, 0)

        def PIVOT(self):
            return self.getToken(fugue_sqlParser.PIVOT, 0)

        def PLACING(self):
            return self.getToken(fugue_sqlParser.PLACING, 0)

        def POSITION(self):
            return self.getToken(fugue_sqlParser.POSITION, 0)

        def PRECEDING(self):
            return self.getToken(fugue_sqlParser.PRECEDING, 0)

        def PRIMARY(self):
            return self.getToken(fugue_sqlParser.PRIMARY, 0)

        def PRINCIPALS(self):
            return self.getToken(fugue_sqlParser.PRINCIPALS, 0)

        def PROPERTIES(self):
            return self.getToken(fugue_sqlParser.PROPERTIES, 0)

        def PURGE(self):
            return self.getToken(fugue_sqlParser.PURGE, 0)

        def QUERY(self):
            return self.getToken(fugue_sqlParser.QUERY, 0)

        def RANGE(self):
            return self.getToken(fugue_sqlParser.RANGE, 0)

        def RECORDREADER(self):
            return self.getToken(fugue_sqlParser.RECORDREADER, 0)

        def RECORDWRITER(self):
            return self.getToken(fugue_sqlParser.RECORDWRITER, 0)

        def RECOVER(self):
            return self.getToken(fugue_sqlParser.RECOVER, 0)

        def REDUCE(self):
            return self.getToken(fugue_sqlParser.REDUCE, 0)

        def REFERENCES(self):
            return self.getToken(fugue_sqlParser.REFERENCES, 0)

        def REFRESH(self):
            return self.getToken(fugue_sqlParser.REFRESH, 0)

        def RENAME(self):
            return self.getToken(fugue_sqlParser.RENAME, 0)

        def REPAIR(self):
            return self.getToken(fugue_sqlParser.REPAIR, 0)

        def REPLACE(self):
            return self.getToken(fugue_sqlParser.REPLACE, 0)

        def RESET(self):
            return self.getToken(fugue_sqlParser.RESET, 0)

        def RESTRICT(self):
            return self.getToken(fugue_sqlParser.RESTRICT, 0)

        def REVOKE(self):
            return self.getToken(fugue_sqlParser.REVOKE, 0)

        def RLIKE(self):
            return self.getToken(fugue_sqlParser.RLIKE, 0)

        def ROLE(self):
            return self.getToken(fugue_sqlParser.ROLE, 0)

        def ROLES(self):
            return self.getToken(fugue_sqlParser.ROLES, 0)

        def ROLLBACK(self):
            return self.getToken(fugue_sqlParser.ROLLBACK, 0)

        def ROLLUP(self):
            return self.getToken(fugue_sqlParser.ROLLUP, 0)

        def ROW(self):
            return self.getToken(fugue_sqlParser.ROW, 0)

        def ROWS(self):
            return self.getToken(fugue_sqlParser.ROWS, 0)

        def SCHEMA(self):
            return self.getToken(fugue_sqlParser.SCHEMA, 0)

        def SECOND(self):
            return self.getToken(fugue_sqlParser.SECOND, 0)

        def SELECT(self):
            return self.getToken(fugue_sqlParser.SELECT, 0)

        def SEPARATED(self):
            return self.getToken(fugue_sqlParser.SEPARATED, 0)

        def SERDE(self):
            return self.getToken(fugue_sqlParser.SERDE, 0)

        def SERDEPROPERTIES(self):
            return self.getToken(fugue_sqlParser.SERDEPROPERTIES, 0)

        def SESSION_USER(self):
            return self.getToken(fugue_sqlParser.SESSION_USER, 0)

        def SET(self):
            return self.getToken(fugue_sqlParser.SET, 0)

        def SETS(self):
            return self.getToken(fugue_sqlParser.SETS, 0)

        def SHOW(self):
            return self.getToken(fugue_sqlParser.SHOW, 0)

        def SKEWED(self):
            return self.getToken(fugue_sqlParser.SKEWED, 0)

        def SOME(self):
            return self.getToken(fugue_sqlParser.SOME, 0)

        def SORT(self):
            return self.getToken(fugue_sqlParser.SORT, 0)

        def SORTED(self):
            return self.getToken(fugue_sqlParser.SORTED, 0)

        def START(self):
            return self.getToken(fugue_sqlParser.START, 0)

        def STATISTICS(self):
            return self.getToken(fugue_sqlParser.STATISTICS, 0)

        def STORED(self):
            return self.getToken(fugue_sqlParser.STORED, 0)

        def STRATIFY(self):
            return self.getToken(fugue_sqlParser.STRATIFY, 0)

        def STRUCT(self):
            return self.getToken(fugue_sqlParser.STRUCT, 0)

        def SUBSTR(self):
            return self.getToken(fugue_sqlParser.SUBSTR, 0)

        def SUBSTRING(self):
            return self.getToken(fugue_sqlParser.SUBSTRING, 0)

        def TABLE(self):
            return self.getToken(fugue_sqlParser.TABLE, 0)

        def TABLES(self):
            return self.getToken(fugue_sqlParser.TABLES, 0)

        def TABLESAMPLE(self):
            return self.getToken(fugue_sqlParser.TABLESAMPLE, 0)

        def TBLPROPERTIES(self):
            return self.getToken(fugue_sqlParser.TBLPROPERTIES, 0)

        def TEMPORARY(self):
            return self.getToken(fugue_sqlParser.TEMPORARY, 0)

        def TERMINATED(self):
            return self.getToken(fugue_sqlParser.TERMINATED, 0)

        def THEN(self):
            return self.getToken(fugue_sqlParser.THEN, 0)

        def TO(self):
            return self.getToken(fugue_sqlParser.TO, 0)

        def TOUCH(self):
            return self.getToken(fugue_sqlParser.TOUCH, 0)

        def TRAILING(self):
            return self.getToken(fugue_sqlParser.TRAILING, 0)

        def TRANSACTION(self):
            return self.getToken(fugue_sqlParser.TRANSACTION, 0)

        def TRANSACTIONS(self):
            return self.getToken(fugue_sqlParser.TRANSACTIONS, 0)

        def TRANSFORM(self):
            return self.getToken(fugue_sqlParser.TRANSFORM, 0)

        def TRIM(self):
            return self.getToken(fugue_sqlParser.TRIM, 0)

        def TRUE(self):
            return self.getToken(fugue_sqlParser.TRUE, 0)

        def TRUNCATE(self):
            return self.getToken(fugue_sqlParser.TRUNCATE, 0)

        def TYPE(self):
            return self.getToken(fugue_sqlParser.TYPE, 0)

        def UNARCHIVE(self):
            return self.getToken(fugue_sqlParser.UNARCHIVE, 0)

        def UNBOUNDED(self):
            return self.getToken(fugue_sqlParser.UNBOUNDED, 0)

        def UNCACHE(self):
            return self.getToken(fugue_sqlParser.UNCACHE, 0)

        def UNIQUE(self):
            return self.getToken(fugue_sqlParser.UNIQUE, 0)

        def UNKNOWN(self):
            return self.getToken(fugue_sqlParser.UNKNOWN, 0)

        def UNLOCK(self):
            return self.getToken(fugue_sqlParser.UNLOCK, 0)

        def UNSET(self):
            return self.getToken(fugue_sqlParser.UNSET, 0)

        def UPDATE(self):
            return self.getToken(fugue_sqlParser.UPDATE, 0)

        def USE(self):
            return self.getToken(fugue_sqlParser.USE, 0)

        def USER(self):
            return self.getToken(fugue_sqlParser.USER, 0)

        def VALUES(self):
            return self.getToken(fugue_sqlParser.VALUES, 0)

        def VIEW(self):
            return self.getToken(fugue_sqlParser.VIEW, 0)

        def VIEWS(self):
            return self.getToken(fugue_sqlParser.VIEWS, 0)

        def WHEN(self):
            return self.getToken(fugue_sqlParser.WHEN, 0)

        def WHERE(self):
            return self.getToken(fugue_sqlParser.WHERE, 0)

        def WINDOW(self):
            return self.getToken(fugue_sqlParser.WINDOW, 0)

        def WITH(self):
            return self.getToken(fugue_sqlParser.WITH, 0)

        def YEAR(self):
            return self.getToken(fugue_sqlParser.YEAR, 0)

        def getRuleIndex(self):
            return fugue_sqlParser.RULE_nonReserved

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNonReserved" ):
                return visitor.visitNonReserved(self)
            else:
                return visitor.visitChildren(self)




    def nonReserved(self):

        localctx = fugue_sqlParser.NonReservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 428, self.RULE_nonReserved)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3869
            _la = self._input.LA(1)
            if not((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & -4398046511169) != 0 or (((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & -36610438703611937) != 0 or (((_la - 186)) & ~0x3f) == 0 and ((1 << (_la - 186)) & -72057594038061057) != 0 or (((_la - 250)) & ~0x3f) == 0 and ((1 << (_la - 250)) & 1150660908700138999) != 0 or _la==324):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[48] = self.fuguePartitionNum_sempred
        self._predicates[116] = self.queryTerm_sempred
        self._predicates[171] = self.booleanExpression_sempred
        self._predicates[173] = self.valueExpression_sempred
        self._predicates[174] = self.primaryExpression_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 fuguePartitionNum_sempred(self, localctx:FuguePartitionNumContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         

    def queryTerm_sempred(self, localctx:QueryTermContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 1)
         

    def booleanExpression_sempred(self, localctx:BooleanExpressionContext, predIndex:int):
            if predIndex == 4:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 1)
         

    def valueExpression_sempred(self, localctx:ValueExpressionContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 4)
         

            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, 1)
         

    def primaryExpression_sempred(self, localctx:PrimaryExpressionContext, predIndex:int):
            if predIndex == 12:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 6)
         




