# Generated from \SQLiteParser.g4 by ANTLR 4.10.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,193,2086,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,1,0,5,0,226,8,0,10,0,12,0,229,9,0,
        1,0,1,0,1,1,5,1,234,8,1,10,1,12,1,237,9,1,1,1,1,1,4,1,241,8,1,11,
        1,12,1,242,1,1,5,1,246,8,1,10,1,12,1,249,9,1,1,1,5,1,252,8,1,10,
        1,12,1,255,9,1,1,2,1,2,1,2,3,2,260,8,2,3,2,262,8,2,1,2,1,2,1,2,1,
        2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,
        2,1,2,1,2,1,2,1,2,3,2,288,8,2,1,3,1,3,1,3,1,3,1,3,3,3,295,8,3,1,
        3,1,3,1,3,1,3,1,3,3,3,302,8,3,1,3,1,3,1,3,1,3,3,3,308,8,3,1,3,1,
        3,3,3,312,8,3,1,3,1,3,1,3,3,3,317,8,3,1,3,3,3,320,8,3,1,4,1,4,1,
        4,1,4,1,4,3,4,327,8,4,1,4,3,4,330,8,4,1,5,1,5,3,5,334,8,5,1,5,1,
        5,1,5,1,5,1,6,1,6,3,6,342,8,6,1,6,1,6,3,6,346,8,6,3,6,348,8,6,1,
        7,1,7,3,7,352,8,7,1,8,1,8,3,8,356,8,8,1,8,1,8,3,8,360,8,8,1,8,3,
        8,363,8,8,1,9,1,9,1,9,1,10,1,10,3,10,370,8,10,1,10,1,10,1,11,1,11,
        3,11,376,8,11,1,11,1,11,1,11,1,11,3,11,382,8,11,1,11,1,11,1,11,3,
        11,387,8,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,5,11,396,8,11,10,
        11,12,11,399,9,11,1,11,1,11,1,11,3,11,404,8,11,1,12,1,12,3,12,408,
        8,12,1,12,1,12,3,12,412,8,12,1,12,3,12,415,8,12,1,13,1,13,3,13,419,
        8,13,1,13,1,13,1,13,1,13,3,13,425,8,13,1,13,1,13,1,13,3,13,430,8,
        13,1,13,1,13,1,13,1,13,1,13,5,13,437,8,13,10,13,12,13,440,9,13,1,
        13,1,13,5,13,444,8,13,10,13,12,13,447,9,13,1,13,1,13,1,13,3,13,452,
        8,13,1,13,1,13,3,13,456,8,13,1,14,1,14,3,14,460,8,14,1,14,5,14,463,
        8,14,10,14,12,14,466,9,14,1,15,4,15,469,8,15,11,15,12,15,470,1,15,
        1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,483,8,15,1,16,
        1,16,3,16,487,8,16,1,16,1,16,1,16,3,16,492,8,16,1,16,3,16,495,8,
        16,1,16,3,16,498,8,16,1,16,1,16,1,16,3,16,503,8,16,1,16,3,16,506,
        8,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
        3,16,520,8,16,1,16,1,16,1,16,1,16,1,16,3,16,527,8,16,1,16,1,16,1,
        16,1,16,1,16,3,16,534,8,16,3,16,536,8,16,1,17,3,17,539,8,17,1,17,
        1,17,1,18,1,18,3,18,545,8,18,1,18,1,18,1,18,3,18,550,8,18,1,18,1,
        18,1,18,1,18,5,18,556,8,18,10,18,12,18,559,9,18,1,18,1,18,3,18,563,
        8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,5,18,
        576,8,18,10,18,12,18,579,9,18,1,18,1,18,1,18,3,18,584,8,18,1,19,
        1,19,1,19,1,19,1,19,1,19,5,19,592,8,19,10,19,12,19,595,9,19,1,19,
        1,19,3,19,599,8,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,
        609,8,19,1,19,1,19,5,19,613,8,19,10,19,12,19,616,9,19,1,19,3,19,
        619,8,19,1,19,1,19,1,19,3,19,624,8,19,3,19,626,8,19,1,20,1,20,1,
        20,1,20,1,21,1,21,3,21,634,8,21,1,21,1,21,1,21,1,21,3,21,640,8,21,
        1,21,1,21,1,21,3,21,645,8,21,1,21,1,21,1,21,1,21,1,21,3,21,652,8,
        21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,5,21,661,8,21,10,21,12,21,
        664,9,21,3,21,666,8,21,3,21,668,8,21,1,21,1,21,1,21,1,21,1,21,3,
        21,675,8,21,1,21,1,21,3,21,679,8,21,1,21,1,21,1,21,1,21,1,21,3,21,
        686,8,21,1,21,1,21,4,21,690,8,21,11,21,12,21,691,1,21,1,21,1,22,
        1,22,3,22,698,8,22,1,22,1,22,1,22,1,22,3,22,704,8,22,1,22,1,22,1,
        22,3,22,709,8,22,1,22,1,22,1,22,1,22,1,22,5,22,716,8,22,10,22,12,
        22,719,9,22,1,22,1,22,3,22,723,8,22,1,22,1,22,1,22,1,23,1,23,1,23,
        1,23,1,23,1,23,3,23,734,8,23,1,23,1,23,1,23,3,23,739,8,23,1,23,1,
        23,1,23,1,23,1,23,1,23,1,23,5,23,748,8,23,10,23,12,23,751,9,23,1,
        23,1,23,3,23,755,8,23,1,24,1,24,3,24,759,8,24,1,24,1,24,1,24,1,24,
        1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,5,24,773,8,24,10,24,12,24,
        776,9,24,1,25,1,25,1,25,1,25,1,25,5,25,783,8,25,10,25,12,25,786,
        9,25,1,25,1,25,3,25,790,8,25,1,26,1,26,1,26,1,26,1,26,1,26,3,26,
        798,8,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,5,27,808,8,27,10,
        27,12,27,811,9,27,1,27,1,27,3,27,815,8,27,1,27,1,27,1,27,1,27,1,
        27,1,28,3,28,823,8,28,1,28,1,28,1,28,1,28,1,28,3,28,830,8,28,1,28,
        3,28,833,8,28,1,29,3,29,836,8,29,1,29,1,29,1,29,1,29,1,29,3,29,843,
        8,29,1,29,3,29,846,8,29,1,29,3,29,849,8,29,1,29,3,29,852,8,29,1,
        30,1,30,3,30,856,8,30,1,30,1,30,1,31,1,31,1,31,1,31,3,31,864,8,31,
        1,31,1,31,1,31,3,31,869,8,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,
        1,32,3,32,879,8,32,1,32,1,32,1,32,3,32,884,8,32,1,32,1,32,1,32,1,
        32,1,32,1,32,1,32,3,32,893,8,32,1,32,1,32,1,32,5,32,898,8,32,10,
        32,12,32,901,9,32,1,32,3,32,904,8,32,1,32,1,32,3,32,908,8,32,1,32,
        3,32,911,8,32,1,32,1,32,1,32,1,32,5,32,917,8,32,10,32,12,32,920,
        9,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,932,
        8,32,1,32,3,32,935,8,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,943,8,
        32,1,32,1,32,1,32,1,32,1,32,4,32,950,8,32,11,32,12,32,951,1,32,1,
        32,3,32,956,8,32,1,32,1,32,1,32,3,32,961,8,32,1,32,1,32,1,32,1,32,
        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,991,
        8,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,1003,
        8,32,1,32,1,32,1,32,3,32,1008,8,32,1,32,1,32,1,32,1,32,1,32,1,32,
        1,32,1,32,1,32,1,32,3,32,1020,8,32,1,32,1,32,1,32,1,32,3,32,1026,
        8,32,1,32,1,32,1,32,1,32,1,32,3,32,1033,8,32,1,32,1,32,3,32,1037,
        8,32,1,32,1,32,1,32,1,32,1,32,1,32,5,32,1045,8,32,10,32,12,32,1048,
        9,32,3,32,1050,8,32,1,32,1,32,1,32,1,32,3,32,1056,8,32,1,32,1,32,
        1,32,1,32,3,32,1062,8,32,1,32,1,32,1,32,1,32,1,32,5,32,1069,8,32,
        10,32,12,32,1072,9,32,3,32,1074,8,32,1,32,1,32,3,32,1078,8,32,5,
        32,1080,8,32,10,32,12,32,1083,9,32,1,33,1,33,1,33,1,33,1,33,1,33,
        3,33,1091,8,33,1,33,1,33,1,34,1,34,1,35,3,35,1098,8,35,1,35,1,35,
        1,35,1,35,1,35,3,35,1105,8,35,1,35,1,35,1,35,1,35,3,35,1111,8,35,
        1,35,1,35,1,35,3,35,1116,8,35,1,35,1,35,1,35,1,35,5,35,1122,8,35,
        10,35,12,35,1125,9,35,1,35,1,35,3,35,1129,8,35,1,35,1,35,1,35,1,
        35,1,35,5,35,1136,8,35,10,35,12,35,1139,9,35,1,35,1,35,1,35,1,35,
        1,35,1,35,5,35,1147,8,35,10,35,12,35,1150,9,35,1,35,1,35,5,35,1154,
        8,35,10,35,12,35,1157,9,35,1,35,3,35,1160,8,35,1,35,3,35,1163,8,
        35,1,35,1,35,3,35,1167,8,35,1,35,3,35,1170,8,35,1,36,1,36,1,36,1,
        36,5,36,1176,8,36,10,36,12,36,1179,9,36,1,37,1,37,1,37,1,37,1,37,
        1,37,5,37,1187,8,37,10,37,12,37,1190,9,37,1,37,1,37,1,37,3,37,1195,
        8,37,3,37,1197,8,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,1205,8,37,
        1,37,1,37,1,37,1,37,1,37,3,37,1212,8,37,1,37,1,37,1,37,5,37,1217,
        8,37,10,37,12,37,1220,9,37,1,37,1,37,3,37,1224,8,37,3,37,1226,8,
        37,1,38,1,38,1,38,1,38,3,38,1232,8,38,1,38,1,38,1,38,1,38,1,38,1,
        38,1,38,3,38,1241,8,38,1,39,1,39,1,39,3,39,1246,8,39,1,40,1,40,1,
        40,1,40,1,40,3,40,1253,8,40,1,40,1,40,3,40,1257,8,40,3,40,1259,8,
        40,1,41,3,41,1262,8,41,1,41,1,41,1,41,1,41,5,41,1268,8,41,10,41,
        12,41,1271,9,41,1,41,3,41,1274,8,41,1,41,3,41,1277,8,41,1,42,1,42,
        1,42,1,42,3,42,1283,8,42,5,42,1285,8,42,10,42,12,42,1288,9,42,1,
        43,1,43,3,43,1292,8,43,1,43,1,43,1,43,5,43,1297,8,43,10,43,12,43,
        1300,9,43,1,43,1,43,1,43,1,43,5,43,1306,8,43,10,43,12,43,1309,9,
        43,1,43,3,43,1312,8,43,3,43,1314,8,43,1,43,1,43,3,43,1318,8,43,1,
        43,1,43,1,43,1,43,1,43,5,43,1325,8,43,10,43,12,43,1328,9,43,1,43,
        1,43,3,43,1332,8,43,3,43,1334,8,43,1,43,1,43,1,43,1,43,1,43,1,43,
        1,43,1,43,1,43,5,43,1345,8,43,10,43,12,43,1348,9,43,3,43,1350,8,
        43,1,43,1,43,1,43,1,43,1,43,5,43,1357,8,43,10,43,12,43,1360,9,43,
        1,43,1,43,1,43,1,43,1,43,1,43,5,43,1368,8,43,10,43,12,43,1371,9,
        43,1,43,1,43,5,43,1375,8,43,10,43,12,43,1378,9,43,3,43,1380,8,43,
        1,44,1,44,1,45,3,45,1385,8,45,1,45,1,45,3,45,1389,8,45,1,45,3,45,
        1392,8,45,1,46,3,46,1395,8,46,1,46,1,46,1,46,3,46,1400,8,46,1,46,
        1,46,3,46,1404,8,46,1,46,4,46,1407,8,46,11,46,12,46,1408,1,46,3,
        46,1412,8,46,1,46,3,46,1415,8,46,1,47,1,47,1,47,3,47,1420,8,47,1,
        47,1,47,3,47,1424,8,47,1,47,3,47,1427,8,47,1,47,1,47,1,47,1,47,1,
        47,3,47,1434,8,47,1,47,1,47,1,47,3,47,1439,8,47,1,47,1,47,1,47,1,
        47,1,47,5,47,1446,8,47,10,47,12,47,1449,9,47,1,47,1,47,3,47,1453,
        8,47,1,47,3,47,1456,8,47,1,47,1,47,1,47,1,47,5,47,1462,8,47,10,47,
        12,47,1465,9,47,1,47,3,47,1468,8,47,1,47,1,47,1,47,1,47,1,47,1,47,
        3,47,1476,8,47,1,47,3,47,1479,8,47,3,47,1481,8,47,1,48,1,48,1,48,
        1,48,1,48,1,48,1,48,3,48,1490,8,48,1,48,3,48,1493,8,48,3,48,1495,
        8,48,1,49,1,49,3,49,1499,8,49,1,49,1,49,3,49,1503,8,49,1,49,1,49,
        3,49,1507,8,49,1,49,3,49,1510,8,49,1,50,1,50,1,50,1,50,1,50,1,50,
        1,50,5,50,1519,8,50,10,50,12,50,1522,9,50,1,50,1,50,3,50,1526,8,
        50,1,51,1,51,3,51,1530,8,51,1,51,1,51,3,51,1534,8,51,1,52,3,52,1537,
        8,52,1,52,1,52,1,52,3,52,1542,8,52,1,52,1,52,1,52,1,52,3,52,1548,
        8,52,1,52,1,52,1,52,1,52,1,52,3,52,1555,8,52,1,52,1,52,1,52,5,52,
        1560,8,52,10,52,12,52,1563,9,52,1,52,1,52,1,52,1,52,5,52,1569,8,
        52,10,52,12,52,1572,9,52,1,52,3,52,1575,8,52,3,52,1577,8,52,1,52,
        1,52,3,52,1581,8,52,1,52,3,52,1584,8,52,1,53,1,53,1,53,1,53,5,53,
        1590,8,53,10,53,12,53,1593,9,53,1,53,1,53,1,54,3,54,1598,8,54,1,
        54,1,54,1,54,3,54,1603,8,54,1,54,1,54,1,54,1,54,3,54,1609,8,54,1,
        54,1,54,1,54,1,54,1,54,3,54,1616,8,54,1,54,1,54,1,54,5,54,1621,8,
        54,10,54,12,54,1624,9,54,1,54,1,54,3,54,1628,8,54,1,54,3,54,1631,
        8,54,1,54,3,54,1634,8,54,1,54,3,54,1637,8,54,1,55,1,55,1,55,3,55,
        1642,8,55,1,55,1,55,1,55,3,55,1647,8,55,1,55,1,55,1,55,1,55,1,55,
        3,55,1654,8,55,1,56,1,56,3,56,1658,8,56,1,56,1,56,3,56,1662,8,56,
        1,57,1,57,1,57,1,57,1,57,1,57,1,58,1,58,3,58,1672,8,58,1,58,1,58,
        1,58,1,58,1,58,5,58,1679,8,58,10,58,12,58,1682,9,58,3,58,1684,8,
        58,1,58,1,58,1,58,1,58,1,58,5,58,1691,8,58,10,58,12,58,1694,9,58,
        1,58,3,58,1697,8,58,1,58,1,58,1,59,1,59,1,59,1,59,3,59,1705,8,59,
        1,59,1,59,1,59,1,59,1,59,5,59,1712,8,59,10,59,12,59,1715,9,59,3,
        59,1717,8,59,1,59,1,59,1,59,1,59,1,59,5,59,1724,8,59,10,59,12,59,
        1727,9,59,3,59,1729,8,59,1,59,3,59,1732,8,59,1,59,3,59,1735,8,59,
        1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,1745,8,60,1,61,1,61,
        1,61,1,61,1,61,1,61,1,61,3,61,1754,8,61,1,62,1,62,1,62,1,62,1,62,
        5,62,1761,8,62,10,62,12,62,1764,9,62,1,62,3,62,1767,8,62,1,62,1,
        62,1,63,1,63,1,63,3,63,1774,8,63,1,63,1,63,1,63,5,63,1779,8,63,10,
        63,12,63,1782,9,63,1,63,3,63,1785,8,63,1,63,1,63,3,63,1789,8,63,
        1,64,1,64,1,64,1,64,1,64,5,64,1796,8,64,10,64,12,64,1799,9,64,1,
        64,3,64,1802,8,64,1,64,1,64,3,64,1806,8,64,1,64,1,64,1,64,3,64,1811,
        8,64,1,65,1,65,3,65,1815,8,65,1,65,1,65,1,65,5,65,1820,8,65,10,65,
        12,65,1823,9,65,1,66,1,66,1,66,1,66,1,66,5,66,1830,8,66,10,66,12,
        66,1833,9,66,1,67,1,67,1,67,1,67,3,67,1839,8,67,1,68,1,68,1,68,3,
        68,1844,8,68,1,68,3,68,1847,8,68,1,68,1,68,3,68,1851,8,68,1,69,1,
        69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1865,8,
        70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1877,8,
        71,1,72,1,72,1,72,1,72,1,72,1,72,1,72,3,72,1886,8,72,1,73,1,73,1,
        73,1,73,1,73,1,73,1,73,3,73,1895,8,73,1,73,1,73,3,73,1899,8,73,1,
        73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1909,8,73,1,73,3,73,1912,
        8,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1921,8,73,1,73,1,73,
        1,73,1,73,1,73,1,73,1,73,3,73,1930,8,73,1,73,3,73,1933,8,73,1,73,
        1,73,1,73,1,73,3,73,1939,8,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,
        1,73,1,73,1,73,1,73,1,73,3,73,1953,8,73,1,73,1,73,3,73,1957,8,73,
        1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1968,8,73,1,73,
        1,73,1,73,3,73,1973,8,73,1,74,1,74,1,74,1,75,1,75,1,75,1,76,1,76,
        1,76,4,76,1984,8,76,11,76,12,76,1985,1,77,1,77,1,77,4,77,1991,8,
        77,11,77,12,77,1992,1,78,1,78,1,78,1,78,1,79,1,79,3,79,2001,8,79,
        1,79,1,79,1,79,3,79,2006,8,79,5,79,2008,8,79,10,79,12,79,2011,9,
        79,1,80,1,80,1,81,1,81,1,82,1,82,1,83,1,83,1,84,1,84,3,84,2023,8,
        84,1,85,1,85,1,86,1,86,1,87,1,87,1,88,1,88,1,89,1,89,1,90,1,90,1,
        91,1,91,1,92,1,92,1,93,1,93,1,94,1,94,1,95,1,95,1,96,1,96,1,97,1,
        97,1,98,1,98,1,99,1,99,1,100,1,100,1,101,1,101,1,102,1,102,1,103,
        1,103,1,104,1,104,1,105,1,105,1,106,1,106,1,107,1,107,1,108,1,108,
        1,109,1,109,1,110,1,110,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        3,111,2084,8,111,1,111,2,438,470,1,64,112,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,0,28,3,0,58,58,69,
        69,82,82,2,0,47,47,66,66,1,0,133,134,2,0,146,146,171,171,1,0,8,9,
        2,0,59,59,141,141,2,0,56,56,104,104,2,0,58,58,82,82,5,0,25,25,72,
        72,81,81,122,122,126,126,4,0,84,84,132,132,138,138,145,145,2,0,7,
        7,12,13,1,0,14,17,1,0,18,21,4,0,77,77,97,97,99,99,118,118,3,0,25,
        25,72,72,126,126,5,0,52,54,104,104,172,173,186,186,188,189,2,0,29,
        29,62,62,3,0,128,128,154,154,179,179,2,0,5,5,106,106,1,0,176,177,
        2,0,34,34,60,60,2,0,151,151,162,162,2,0,159,159,166,166,2,0,160,
        160,167,168,2,0,161,161,163,163,2,0,8,10,102,102,2,0,185,185,188,
        188,2,0,25,123,125,180,2372,0,227,1,0,0,0,2,235,1,0,0,0,4,261,1,
        0,0,0,6,289,1,0,0,0,8,321,1,0,0,0,10,331,1,0,0,0,12,339,1,0,0,0,
        14,349,1,0,0,0,16,353,1,0,0,0,18,364,1,0,0,0,20,367,1,0,0,0,22,373,
        1,0,0,0,24,407,1,0,0,0,26,416,1,0,0,0,28,457,1,0,0,0,30,468,1,0,
        0,0,32,486,1,0,0,0,34,538,1,0,0,0,36,544,1,0,0,0,38,585,1,0,0,0,
        40,627,1,0,0,0,42,631,1,0,0,0,44,695,1,0,0,0,46,727,1,0,0,0,48,756,
        1,0,0,0,50,777,1,0,0,0,52,791,1,0,0,0,54,802,1,0,0,0,56,822,1,0,
        0,0,58,835,1,0,0,0,60,853,1,0,0,0,62,859,1,0,0,0,64,960,1,0,0,0,
        66,1084,1,0,0,0,68,1094,1,0,0,0,70,1097,1,0,0,0,72,1171,1,0,0,0,
        74,1180,1,0,0,0,76,1227,1,0,0,0,78,1245,1,0,0,0,80,1247,1,0,0,0,
        82,1261,1,0,0,0,84,1278,1,0,0,0,86,1379,1,0,0,0,88,1381,1,0,0,0,
        90,1384,1,0,0,0,92,1394,1,0,0,0,94,1480,1,0,0,0,96,1494,1,0,0,0,
        98,1509,1,0,0,0,100,1525,1,0,0,0,102,1533,1,0,0,0,104,1536,1,0,0,
        0,106,1585,1,0,0,0,108,1597,1,0,0,0,110,1641,1,0,0,0,112,1655,1,
        0,0,0,114,1663,1,0,0,0,116,1669,1,0,0,0,118,1700,1,0,0,0,120,1736,
        1,0,0,0,122,1746,1,0,0,0,124,1755,1,0,0,0,126,1770,1,0,0,0,128,1790,
        1,0,0,0,130,1812,1,0,0,0,132,1824,1,0,0,0,134,1834,1,0,0,0,136,1840,
        1,0,0,0,138,1852,1,0,0,0,140,1864,1,0,0,0,142,1876,1,0,0,0,144,1885,
        1,0,0,0,146,1972,1,0,0,0,148,1974,1,0,0,0,150,1977,1,0,0,0,152,1980,
        1,0,0,0,154,1987,1,0,0,0,156,1994,1,0,0,0,158,1998,1,0,0,0,160,2012,
        1,0,0,0,162,2014,1,0,0,0,164,2016,1,0,0,0,166,2018,1,0,0,0,168,2022,
        1,0,0,0,170,2024,1,0,0,0,172,2026,1,0,0,0,174,2028,1,0,0,0,176,2030,
        1,0,0,0,178,2032,1,0,0,0,180,2034,1,0,0,0,182,2036,1,0,0,0,184,2038,
        1,0,0,0,186,2040,1,0,0,0,188,2042,1,0,0,0,190,2044,1,0,0,0,192,2046,
        1,0,0,0,194,2048,1,0,0,0,196,2050,1,0,0,0,198,2052,1,0,0,0,200,2054,
        1,0,0,0,202,2056,1,0,0,0,204,2058,1,0,0,0,206,2060,1,0,0,0,208,2062,
        1,0,0,0,210,2064,1,0,0,0,212,2066,1,0,0,0,214,2068,1,0,0,0,216,2070,
        1,0,0,0,218,2072,1,0,0,0,220,2074,1,0,0,0,222,2083,1,0,0,0,224,226,
        3,2,1,0,225,224,1,0,0,0,226,229,1,0,0,0,227,225,1,0,0,0,227,228,
        1,0,0,0,228,230,1,0,0,0,229,227,1,0,0,0,230,231,5,0,0,1,231,1,1,
        0,0,0,232,234,5,1,0,0,233,232,1,0,0,0,234,237,1,0,0,0,235,233,1,
        0,0,0,235,236,1,0,0,0,236,238,1,0,0,0,237,235,1,0,0,0,238,247,3,
        4,2,0,239,241,5,1,0,0,240,239,1,0,0,0,241,242,1,0,0,0,242,240,1,
        0,0,0,242,243,1,0,0,0,243,244,1,0,0,0,244,246,3,4,2,0,245,240,1,
        0,0,0,246,249,1,0,0,0,247,245,1,0,0,0,247,248,1,0,0,0,248,253,1,
        0,0,0,249,247,1,0,0,0,250,252,5,1,0,0,251,250,1,0,0,0,252,255,1,
        0,0,0,253,251,1,0,0,0,253,254,1,0,0,0,254,3,1,0,0,0,255,253,1,0,
        0,0,256,259,5,71,0,0,257,258,5,114,0,0,258,260,5,111,0,0,259,257,
        1,0,0,0,259,260,1,0,0,0,260,262,1,0,0,0,261,256,1,0,0,0,261,262,
        1,0,0,0,262,287,1,0,0,0,263,288,3,6,3,0,264,288,3,8,4,0,265,288,
        3,10,5,0,266,288,3,12,6,0,267,288,3,14,7,0,268,288,3,22,11,0,269,
        288,3,26,13,0,270,288,3,42,21,0,271,288,3,44,22,0,272,288,3,46,23,
        0,273,288,3,56,28,0,274,288,3,58,29,0,275,288,3,60,30,0,276,288,
        3,62,31,0,277,288,3,70,35,0,278,288,3,76,38,0,279,288,3,80,40,0,
        280,288,3,20,10,0,281,288,3,16,8,0,282,288,3,18,9,0,283,288,3,82,
        41,0,284,288,3,104,52,0,285,288,3,108,54,0,286,288,3,112,56,0,287,
        263,1,0,0,0,287,264,1,0,0,0,287,265,1,0,0,0,287,266,1,0,0,0,287,
        267,1,0,0,0,287,268,1,0,0,0,287,269,1,0,0,0,287,270,1,0,0,0,287,
        271,1,0,0,0,287,272,1,0,0,0,287,273,1,0,0,0,287,274,1,0,0,0,287,
        275,1,0,0,0,287,276,1,0,0,0,287,277,1,0,0,0,287,278,1,0,0,0,287,
        279,1,0,0,0,287,280,1,0,0,0,287,281,1,0,0,0,287,282,1,0,0,0,287,
        283,1,0,0,0,287,284,1,0,0,0,287,285,1,0,0,0,287,286,1,0,0,0,288,
        5,1,0,0,0,289,290,5,30,0,0,290,294,5,132,0,0,291,292,3,178,89,0,
        292,293,5,2,0,0,293,295,1,0,0,0,294,291,1,0,0,0,294,295,1,0,0,0,
        295,296,1,0,0,0,296,319,3,180,90,0,297,307,5,121,0,0,298,299,5,136,
        0,0,299,308,3,184,92,0,300,302,5,46,0,0,301,300,1,0,0,0,301,302,
        1,0,0,0,302,303,1,0,0,0,303,304,3,186,93,0,304,305,5,136,0,0,305,
        306,3,186,93,0,306,308,1,0,0,0,307,298,1,0,0,0,307,301,1,0,0,0,308,
        320,1,0,0,0,309,311,5,27,0,0,310,312,5,46,0,0,311,310,1,0,0,0,311,
        312,1,0,0,0,312,313,1,0,0,0,313,320,3,28,14,0,314,316,5,63,0,0,315,
        317,5,46,0,0,316,315,1,0,0,0,316,317,1,0,0,0,317,318,1,0,0,0,318,
        320,3,186,93,0,319,297,1,0,0,0,319,309,1,0,0,0,319,314,1,0,0,0,320,
        7,1,0,0,0,321,329,5,31,0,0,322,330,3,178,89,0,323,324,3,178,89,0,
        324,325,5,2,0,0,325,327,1,0,0,0,326,323,1,0,0,0,326,327,1,0,0,0,
        327,328,1,0,0,0,328,330,3,182,91,0,329,322,1,0,0,0,329,326,1,0,0,
        0,329,330,1,0,0,0,330,9,1,0,0,0,331,333,5,35,0,0,332,334,5,55,0,
        0,333,332,1,0,0,0,333,334,1,0,0,0,334,335,1,0,0,0,335,336,3,64,32,
        0,336,337,5,33,0,0,337,338,3,178,89,0,338,11,1,0,0,0,339,341,5,38,
        0,0,340,342,7,0,0,0,341,340,1,0,0,0,341,342,1,0,0,0,342,347,1,0,
        0,0,343,345,5,137,0,0,344,346,3,206,103,0,345,344,1,0,0,0,345,346,
        1,0,0,0,346,348,1,0,0,0,347,343,1,0,0,0,347,348,1,0,0,0,348,13,1,
        0,0,0,349,351,7,1,0,0,350,352,5,137,0,0,351,350,1,0,0,0,351,352,
        1,0,0,0,352,15,1,0,0,0,353,355,5,126,0,0,354,356,5,137,0,0,355,354,
        1,0,0,0,355,356,1,0,0,0,356,362,1,0,0,0,357,359,5,136,0,0,358,360,
        5,129,0,0,359,358,1,0,0,0,359,360,1,0,0,0,360,361,1,0,0,0,361,363,
        3,202,101,0,362,357,1,0,0,0,362,363,1,0,0,0,363,17,1,0,0,0,364,365,
        5,129,0,0,365,366,3,202,101,0,366,19,1,0,0,0,367,369,5,120,0,0,368,
        370,5,129,0,0,369,368,1,0,0,0,369,370,1,0,0,0,370,371,1,0,0,0,371,
        372,3,202,101,0,372,21,1,0,0,0,373,375,5,50,0,0,374,376,5,140,0,
        0,375,374,1,0,0,0,375,376,1,0,0,0,376,377,1,0,0,0,377,381,5,84,0,
        0,378,379,5,80,0,0,379,380,5,102,0,0,380,382,5,70,0,0,381,378,1,
        0,0,0,381,382,1,0,0,0,382,386,1,0,0,0,383,384,3,178,89,0,384,385,
        5,2,0,0,385,387,1,0,0,0,386,383,1,0,0,0,386,387,1,0,0,0,387,388,
        1,0,0,0,388,389,3,192,96,0,389,390,5,107,0,0,390,391,3,180,90,0,
        391,392,5,3,0,0,392,397,3,24,12,0,393,394,5,5,0,0,394,396,3,24,12,
        0,395,393,1,0,0,0,396,399,1,0,0,0,397,395,1,0,0,0,397,398,1,0,0,
        0,398,400,1,0,0,0,399,397,1,0,0,0,400,403,5,4,0,0,401,402,5,148,
        0,0,402,404,3,64,32,0,403,401,1,0,0,0,403,404,1,0,0,0,404,23,1,0,
        0,0,405,408,3,186,93,0,406,408,3,64,32,0,407,405,1,0,0,0,407,406,
        1,0,0,0,408,411,1,0,0,0,409,410,5,45,0,0,410,412,3,188,94,0,411,
        409,1,0,0,0,411,412,1,0,0,0,412,414,1,0,0,0,413,415,3,138,69,0,414,
        413,1,0,0,0,414,415,1,0,0,0,415,25,1,0,0,0,416,418,5,50,0,0,417,
        419,7,2,0,0,418,417,1,0,0,0,418,419,1,0,0,0,419,420,1,0,0,0,420,
        424,5,132,0,0,421,422,5,80,0,0,422,423,5,102,0,0,423,425,5,70,0,
        0,424,421,1,0,0,0,424,425,1,0,0,0,425,429,1,0,0,0,426,427,3,178,
        89,0,427,428,5,2,0,0,428,430,1,0,0,0,429,426,1,0,0,0,429,430,1,0,
        0,0,430,431,1,0,0,0,431,455,3,180,90,0,432,433,5,3,0,0,433,438,3,
        28,14,0,434,435,5,5,0,0,435,437,3,28,14,0,436,434,1,0,0,0,437,440,
        1,0,0,0,438,439,1,0,0,0,438,436,1,0,0,0,439,445,1,0,0,0,440,438,
        1,0,0,0,441,442,5,5,0,0,442,444,3,36,18,0,443,441,1,0,0,0,444,447,
        1,0,0,0,445,443,1,0,0,0,445,446,1,0,0,0,446,448,1,0,0,0,447,445,
        1,0,0,0,448,451,5,4,0,0,449,450,5,150,0,0,450,452,5,185,0,0,451,
        449,1,0,0,0,451,452,1,0,0,0,452,456,1,0,0,0,453,454,5,33,0,0,454,
        456,3,82,41,0,455,432,1,0,0,0,455,453,1,0,0,0,456,27,1,0,0,0,457,
        459,3,186,93,0,458,460,3,30,15,0,459,458,1,0,0,0,459,460,1,0,0,0,
        460,464,1,0,0,0,461,463,3,32,16,0,462,461,1,0,0,0,463,466,1,0,0,
        0,464,462,1,0,0,0,464,465,1,0,0,0,465,29,1,0,0,0,466,464,1,0,0,0,
        467,469,3,174,87,0,468,467,1,0,0,0,469,470,1,0,0,0,470,471,1,0,0,
        0,470,468,1,0,0,0,471,482,1,0,0,0,472,473,5,3,0,0,473,474,3,34,17,
        0,474,475,5,4,0,0,475,483,1,0,0,0,476,477,5,3,0,0,477,478,3,34,17,
        0,478,479,5,5,0,0,479,480,3,34,17,0,480,481,5,4,0,0,481,483,1,0,
        0,0,482,472,1,0,0,0,482,476,1,0,0,0,482,483,1,0,0,0,483,31,1,0,0,
        0,484,485,5,49,0,0,485,487,3,174,87,0,486,484,1,0,0,0,486,487,1,
        0,0,0,487,535,1,0,0,0,488,489,5,113,0,0,489,491,5,95,0,0,490,492,
        3,138,69,0,491,490,1,0,0,0,491,492,1,0,0,0,492,494,1,0,0,0,493,495,
        3,40,20,0,494,493,1,0,0,0,494,495,1,0,0,0,495,497,1,0,0,0,496,498,
        5,36,0,0,497,496,1,0,0,0,497,498,1,0,0,0,498,536,1,0,0,0,499,500,
        5,102,0,0,500,503,5,104,0,0,501,503,5,140,0,0,502,499,1,0,0,0,502,
        501,1,0,0,0,503,505,1,0,0,0,504,506,3,40,20,0,505,504,1,0,0,0,505,
        506,1,0,0,0,506,536,1,0,0,0,507,508,5,44,0,0,508,509,5,3,0,0,509,
        510,3,64,32,0,510,511,5,4,0,0,511,536,1,0,0,0,512,519,5,56,0,0,513,
        520,3,34,17,0,514,520,3,68,34,0,515,516,5,3,0,0,516,517,3,64,32,
        0,517,518,5,4,0,0,518,520,1,0,0,0,519,513,1,0,0,0,519,514,1,0,0,
        0,519,515,1,0,0,0,520,536,1,0,0,0,521,522,5,45,0,0,522,536,3,188,
        94,0,523,536,3,38,19,0,524,525,5,169,0,0,525,527,5,170,0,0,526,524,
        1,0,0,0,526,527,1,0,0,0,527,528,1,0,0,0,528,529,5,33,0,0,529,530,
        5,3,0,0,530,531,3,64,32,0,531,533,5,4,0,0,532,534,7,3,0,0,533,532,
        1,0,0,0,533,534,1,0,0,0,534,536,1,0,0,0,535,488,1,0,0,0,535,502,
        1,0,0,0,535,507,1,0,0,0,535,512,1,0,0,0,535,521,1,0,0,0,535,523,
        1,0,0,0,535,526,1,0,0,0,536,33,1,0,0,0,537,539,7,4,0,0,538,537,1,
        0,0,0,538,539,1,0,0,0,539,540,1,0,0,0,540,541,5,186,0,0,541,35,1,
        0,0,0,542,543,5,49,0,0,543,545,3,174,87,0,544,542,1,0,0,0,544,545,
        1,0,0,0,545,583,1,0,0,0,546,547,5,113,0,0,547,550,5,95,0,0,548,550,
        5,140,0,0,549,546,1,0,0,0,549,548,1,0,0,0,550,551,1,0,0,0,551,552,
        5,3,0,0,552,557,3,24,12,0,553,554,5,5,0,0,554,556,3,24,12,0,555,
        553,1,0,0,0,556,559,1,0,0,0,557,555,1,0,0,0,557,558,1,0,0,0,558,
        560,1,0,0,0,559,557,1,0,0,0,560,562,5,4,0,0,561,563,3,40,20,0,562,
        561,1,0,0,0,562,563,1,0,0,0,563,584,1,0,0,0,564,565,5,44,0,0,565,
        566,5,3,0,0,566,567,3,64,32,0,567,568,5,4,0,0,568,584,1,0,0,0,569,
        570,5,74,0,0,570,571,5,95,0,0,571,572,5,3,0,0,572,577,3,186,93,0,
        573,574,5,5,0,0,574,576,3,186,93,0,575,573,1,0,0,0,576,579,1,0,0,
        0,577,575,1,0,0,0,577,578,1,0,0,0,578,580,1,0,0,0,579,577,1,0,0,
        0,580,581,5,4,0,0,581,582,3,38,19,0,582,584,1,0,0,0,583,549,1,0,
        0,0,583,564,1,0,0,0,583,569,1,0,0,0,584,37,1,0,0,0,585,586,5,117,
        0,0,586,598,3,190,95,0,587,588,5,3,0,0,588,593,3,186,93,0,589,590,
        5,5,0,0,590,592,3,186,93,0,591,589,1,0,0,0,592,595,1,0,0,0,593,591,
        1,0,0,0,593,594,1,0,0,0,594,596,1,0,0,0,595,593,1,0,0,0,596,597,
        5,4,0,0,597,599,1,0,0,0,598,587,1,0,0,0,598,599,1,0,0,0,599,614,
        1,0,0,0,600,601,5,107,0,0,601,608,7,5,0,0,602,603,5,131,0,0,603,
        609,7,6,0,0,604,609,5,41,0,0,605,609,5,123,0,0,606,607,5,101,0,0,
        607,609,5,26,0,0,608,602,1,0,0,0,608,604,1,0,0,0,608,605,1,0,0,0,
        608,606,1,0,0,0,609,613,1,0,0,0,610,611,5,99,0,0,611,613,3,174,87,
        0,612,600,1,0,0,0,612,610,1,0,0,0,613,616,1,0,0,0,614,612,1,0,0,
        0,614,615,1,0,0,0,615,625,1,0,0,0,616,614,1,0,0,0,617,619,5,102,
        0,0,618,617,1,0,0,0,618,619,1,0,0,0,619,620,1,0,0,0,620,623,5,57,
        0,0,621,622,5,86,0,0,622,624,7,7,0,0,623,621,1,0,0,0,623,624,1,0,
        0,0,624,626,1,0,0,0,625,618,1,0,0,0,625,626,1,0,0,0,626,39,1,0,0,
        0,627,628,5,107,0,0,628,629,5,48,0,0,629,630,7,8,0,0,630,41,1,0,
        0,0,631,633,5,50,0,0,632,634,7,2,0,0,633,632,1,0,0,0,633,634,1,0,
        0,0,634,635,1,0,0,0,635,639,5,138,0,0,636,637,5,80,0,0,637,638,5,
        102,0,0,638,640,5,70,0,0,639,636,1,0,0,0,639,640,1,0,0,0,640,644,
        1,0,0,0,641,642,3,178,89,0,642,643,5,2,0,0,643,645,1,0,0,0,644,641,
        1,0,0,0,644,645,1,0,0,0,645,646,1,0,0,0,646,651,3,194,97,0,647,652,
        5,37,0,0,648,652,5,28,0,0,649,650,5,89,0,0,650,652,5,105,0,0,651,
        647,1,0,0,0,651,648,1,0,0,0,651,649,1,0,0,0,651,652,1,0,0,0,652,
        667,1,0,0,0,653,668,5,59,0,0,654,668,5,88,0,0,655,665,5,141,0,0,
        656,657,5,105,0,0,657,662,3,186,93,0,658,659,5,5,0,0,659,661,3,186,
        93,0,660,658,1,0,0,0,661,664,1,0,0,0,662,660,1,0,0,0,662,663,1,0,
        0,0,663,666,1,0,0,0,664,662,1,0,0,0,665,656,1,0,0,0,665,666,1,0,
        0,0,666,668,1,0,0,0,667,653,1,0,0,0,667,654,1,0,0,0,667,655,1,0,
        0,0,668,669,1,0,0,0,669,670,5,107,0,0,670,674,3,180,90,0,671,672,
        5,73,0,0,672,673,5,64,0,0,673,675,5,127,0,0,674,671,1,0,0,0,674,
        675,1,0,0,0,675,678,1,0,0,0,676,677,5,147,0,0,677,679,3,64,32,0,
        678,676,1,0,0,0,678,679,1,0,0,0,679,680,1,0,0,0,680,689,5,38,0,0,
        681,686,3,104,52,0,682,686,3,70,35,0,683,686,3,56,28,0,684,686,3,
        82,41,0,685,681,1,0,0,0,685,682,1,0,0,0,685,683,1,0,0,0,685,684,
        1,0,0,0,686,687,1,0,0,0,687,688,5,1,0,0,688,690,1,0,0,0,689,685,
        1,0,0,0,690,691,1,0,0,0,691,689,1,0,0,0,691,692,1,0,0,0,692,693,
        1,0,0,0,693,694,5,66,0,0,694,43,1,0,0,0,695,697,5,50,0,0,696,698,
        7,2,0,0,697,696,1,0,0,0,697,698,1,0,0,0,698,699,1,0,0,0,699,703,
        5,145,0,0,700,701,5,80,0,0,701,702,5,102,0,0,702,704,5,70,0,0,703,
        700,1,0,0,0,703,704,1,0,0,0,704,708,1,0,0,0,705,706,3,178,89,0,706,
        707,5,2,0,0,707,709,1,0,0,0,708,705,1,0,0,0,708,709,1,0,0,0,709,
        710,1,0,0,0,710,722,3,196,98,0,711,712,5,3,0,0,712,717,3,186,93,
        0,713,714,5,5,0,0,714,716,3,186,93,0,715,713,1,0,0,0,716,719,1,0,
        0,0,717,715,1,0,0,0,717,718,1,0,0,0,718,720,1,0,0,0,719,717,1,0,
        0,0,720,721,5,4,0,0,721,723,1,0,0,0,722,711,1,0,0,0,722,723,1,0,
        0,0,723,724,1,0,0,0,724,725,5,33,0,0,725,726,3,82,41,0,726,45,1,
        0,0,0,727,728,5,50,0,0,728,729,5,146,0,0,729,733,5,132,0,0,730,731,
        5,80,0,0,731,732,5,102,0,0,732,734,5,70,0,0,733,730,1,0,0,0,733,
        734,1,0,0,0,734,738,1,0,0,0,735,736,3,178,89,0,736,737,5,2,0,0,737,
        739,1,0,0,0,738,735,1,0,0,0,738,739,1,0,0,0,739,740,1,0,0,0,740,
        741,3,180,90,0,741,742,5,142,0,0,742,754,3,198,99,0,743,744,5,3,
        0,0,744,749,3,168,84,0,745,746,5,5,0,0,746,748,3,168,84,0,747,745,
        1,0,0,0,748,751,1,0,0,0,749,747,1,0,0,0,749,750,1,0,0,0,750,752,
        1,0,0,0,751,749,1,0,0,0,752,753,5,4,0,0,753,755,1,0,0,0,754,743,
        1,0,0,0,754,755,1,0,0,0,755,47,1,0,0,0,756,758,5,149,0,0,757,759,
        5,116,0,0,758,757,1,0,0,0,758,759,1,0,0,0,759,760,1,0,0,0,760,761,
        3,50,25,0,761,762,5,33,0,0,762,763,5,3,0,0,763,764,3,82,41,0,764,
        774,5,4,0,0,765,766,5,5,0,0,766,767,3,50,25,0,767,768,5,33,0,0,768,
        769,5,3,0,0,769,770,3,82,41,0,770,771,5,4,0,0,771,773,1,0,0,0,772,
        765,1,0,0,0,773,776,1,0,0,0,774,772,1,0,0,0,774,775,1,0,0,0,775,
        49,1,0,0,0,776,774,1,0,0,0,777,789,3,180,90,0,778,779,5,3,0,0,779,
        784,3,186,93,0,780,781,5,5,0,0,781,783,3,186,93,0,782,780,1,0,0,
        0,783,786,1,0,0,0,784,782,1,0,0,0,784,785,1,0,0,0,785,787,1,0,0,
        0,786,784,1,0,0,0,787,788,5,4,0,0,788,790,1,0,0,0,789,778,1,0,0,
        0,789,790,1,0,0,0,790,51,1,0,0,0,791,792,3,50,25,0,792,793,5,33,
        0,0,793,794,5,3,0,0,794,795,3,160,80,0,795,797,5,139,0,0,796,798,
        5,29,0,0,797,796,1,0,0,0,797,798,1,0,0,0,798,799,1,0,0,0,799,800,
        3,162,81,0,800,801,5,4,0,0,801,53,1,0,0,0,802,814,3,180,90,0,803,
        804,5,3,0,0,804,809,3,186,93,0,805,806,5,5,0,0,806,808,3,186,93,
        0,807,805,1,0,0,0,808,811,1,0,0,0,809,807,1,0,0,0,809,810,1,0,0,
        0,810,812,1,0,0,0,811,809,1,0,0,0,812,813,5,4,0,0,813,815,1,0,0,
        0,814,803,1,0,0,0,814,815,1,0,0,0,815,816,1,0,0,0,816,817,5,33,0,
        0,817,818,5,3,0,0,818,819,3,82,41,0,819,820,5,4,0,0,820,55,1,0,0,
        0,821,823,3,48,24,0,822,821,1,0,0,0,822,823,1,0,0,0,823,824,1,0,
        0,0,824,825,5,59,0,0,825,826,5,75,0,0,826,829,3,110,55,0,827,828,
        5,148,0,0,828,830,3,64,32,0,829,827,1,0,0,0,829,830,1,0,0,0,830,
        832,1,0,0,0,831,833,3,72,36,0,832,831,1,0,0,0,832,833,1,0,0,0,833,
        57,1,0,0,0,834,836,3,48,24,0,835,834,1,0,0,0,835,836,1,0,0,0,836,
        837,1,0,0,0,837,838,5,59,0,0,838,839,5,75,0,0,839,842,3,110,55,0,
        840,841,5,148,0,0,841,843,3,64,32,0,842,840,1,0,0,0,842,843,1,0,
        0,0,843,845,1,0,0,0,844,846,3,72,36,0,845,844,1,0,0,0,845,846,1,
        0,0,0,846,851,1,0,0,0,847,849,3,132,66,0,848,847,1,0,0,0,848,849,
        1,0,0,0,849,850,1,0,0,0,850,852,3,134,67,0,851,848,1,0,0,0,851,852,
        1,0,0,0,852,59,1,0,0,0,853,855,5,61,0,0,854,856,5,55,0,0,855,854,
        1,0,0,0,855,856,1,0,0,0,856,857,1,0,0,0,857,858,3,178,89,0,858,61,
        1,0,0,0,859,860,5,63,0,0,860,863,7,9,0,0,861,862,5,80,0,0,862,864,
        5,70,0,0,863,861,1,0,0,0,863,864,1,0,0,0,864,868,1,0,0,0,865,866,
        3,178,89,0,866,867,5,2,0,0,867,869,1,0,0,0,868,865,1,0,0,0,868,869,
        1,0,0,0,869,870,1,0,0,0,870,871,3,222,111,0,871,63,1,0,0,0,872,873,
        6,32,-1,0,873,961,3,68,34,0,874,961,5,187,0,0,875,876,3,178,89,0,
        876,877,5,2,0,0,877,879,1,0,0,0,878,875,1,0,0,0,878,879,1,0,0,0,
        879,880,1,0,0,0,880,881,3,180,90,0,881,882,5,2,0,0,882,884,1,0,0,
        0,883,878,1,0,0,0,883,884,1,0,0,0,884,885,1,0,0,0,885,961,3,186,
        93,0,886,887,3,164,82,0,887,888,3,64,32,21,888,961,1,0,0,0,889,890,
        3,176,88,0,890,903,5,3,0,0,891,893,5,62,0,0,892,891,1,0,0,0,892,
        893,1,0,0,0,893,894,1,0,0,0,894,899,3,64,32,0,895,896,5,5,0,0,896,
        898,3,64,32,0,897,895,1,0,0,0,898,901,1,0,0,0,899,897,1,0,0,0,899,
        900,1,0,0,0,900,904,1,0,0,0,901,899,1,0,0,0,902,904,5,7,0,0,903,
        892,1,0,0,0,903,902,1,0,0,0,903,904,1,0,0,0,904,905,1,0,0,0,905,
        907,5,4,0,0,906,908,3,114,57,0,907,906,1,0,0,0,907,908,1,0,0,0,908,
        910,1,0,0,0,909,911,3,118,59,0,910,909,1,0,0,0,910,911,1,0,0,0,911,
        961,1,0,0,0,912,913,5,3,0,0,913,918,3,64,32,0,914,915,5,5,0,0,915,
        917,3,64,32,0,916,914,1,0,0,0,917,920,1,0,0,0,918,916,1,0,0,0,918,
        919,1,0,0,0,919,921,1,0,0,0,920,918,1,0,0,0,921,922,5,4,0,0,922,
        961,1,0,0,0,923,924,5,43,0,0,924,925,5,3,0,0,925,926,3,64,32,0,926,
        927,5,33,0,0,927,928,3,30,15,0,928,929,5,4,0,0,929,961,1,0,0,0,930,
        932,5,102,0,0,931,930,1,0,0,0,931,932,1,0,0,0,932,933,1,0,0,0,933,
        935,5,70,0,0,934,931,1,0,0,0,934,935,1,0,0,0,935,936,1,0,0,0,936,
        937,5,3,0,0,937,938,3,82,41,0,938,939,5,4,0,0,939,961,1,0,0,0,940,
        942,5,42,0,0,941,943,3,64,32,0,942,941,1,0,0,0,942,943,1,0,0,0,943,
        949,1,0,0,0,944,945,5,147,0,0,945,946,3,64,32,0,946,947,5,135,0,
        0,947,948,3,64,32,0,948,950,1,0,0,0,949,944,1,0,0,0,950,951,1,0,
        0,0,951,949,1,0,0,0,951,952,1,0,0,0,952,955,1,0,0,0,953,954,5,65,
        0,0,954,956,3,64,32,0,955,953,1,0,0,0,955,956,1,0,0,0,956,957,1,
        0,0,0,957,958,5,66,0,0,958,961,1,0,0,0,959,961,3,66,33,0,960,872,
        1,0,0,0,960,874,1,0,0,0,960,883,1,0,0,0,960,886,1,0,0,0,960,889,
        1,0,0,0,960,912,1,0,0,0,960,923,1,0,0,0,960,934,1,0,0,0,960,940,
        1,0,0,0,960,959,1,0,0,0,961,1081,1,0,0,0,962,963,10,20,0,0,963,964,
        5,11,0,0,964,1080,3,64,32,21,965,966,10,19,0,0,966,967,7,10,0,0,
        967,1080,3,64,32,20,968,969,10,18,0,0,969,970,7,4,0,0,970,1080,3,
        64,32,19,971,972,10,17,0,0,972,973,7,11,0,0,973,1080,3,64,32,18,
        974,975,10,16,0,0,975,976,7,12,0,0,976,1080,3,64,32,17,977,990,10,
        15,0,0,978,991,5,6,0,0,979,991,5,22,0,0,980,991,5,23,0,0,981,991,
        5,24,0,0,982,991,5,92,0,0,983,984,5,92,0,0,984,991,5,102,0,0,985,
        991,5,83,0,0,986,991,5,97,0,0,987,991,5,77,0,0,988,991,5,99,0,0,
        989,991,5,118,0,0,990,978,1,0,0,0,990,979,1,0,0,0,990,980,1,0,0,
        0,990,981,1,0,0,0,990,982,1,0,0,0,990,983,1,0,0,0,990,985,1,0,0,
        0,990,986,1,0,0,0,990,987,1,0,0,0,990,988,1,0,0,0,990,989,1,0,0,
        0,991,992,1,0,0,0,992,1080,3,64,32,16,993,994,10,14,0,0,994,995,
        5,32,0,0,995,1080,3,64,32,15,996,997,10,13,0,0,997,998,5,108,0,0,
        998,1080,3,64,32,14,999,1000,10,6,0,0,1000,1002,5,92,0,0,1001,1003,
        5,102,0,0,1002,1001,1,0,0,0,1002,1003,1,0,0,0,1003,1004,1,0,0,0,
        1004,1080,3,64,32,7,1005,1007,10,5,0,0,1006,1008,5,102,0,0,1007,
        1006,1,0,0,0,1007,1008,1,0,0,0,1008,1009,1,0,0,0,1009,1010,5,39,
        0,0,1010,1011,3,64,32,0,1011,1012,5,32,0,0,1012,1013,3,64,32,6,1013,
        1080,1,0,0,0,1014,1015,10,9,0,0,1015,1016,5,45,0,0,1016,1080,3,188,
        94,0,1017,1019,10,8,0,0,1018,1020,5,102,0,0,1019,1018,1,0,0,0,1019,
        1020,1,0,0,0,1020,1021,1,0,0,0,1021,1022,7,13,0,0,1022,1025,3,64,
        32,0,1023,1024,5,67,0,0,1024,1026,3,64,32,0,1025,1023,1,0,0,0,1025,
        1026,1,0,0,0,1026,1080,1,0,0,0,1027,1032,10,7,0,0,1028,1033,5,93,
        0,0,1029,1033,5,103,0,0,1030,1031,5,102,0,0,1031,1033,5,104,0,0,
        1032,1028,1,0,0,0,1032,1029,1,0,0,0,1032,1030,1,0,0,0,1033,1080,
        1,0,0,0,1034,1036,10,4,0,0,1035,1037,5,102,0,0,1036,1035,1,0,0,0,
        1036,1037,1,0,0,0,1037,1038,1,0,0,0,1038,1077,5,83,0,0,1039,1049,
        5,3,0,0,1040,1050,3,82,41,0,1041,1046,3,64,32,0,1042,1043,5,5,0,
        0,1043,1045,3,64,32,0,1044,1042,1,0,0,0,1045,1048,1,0,0,0,1046,1044,
        1,0,0,0,1046,1047,1,0,0,0,1047,1050,1,0,0,0,1048,1046,1,0,0,0,1049,
        1040,1,0,0,0,1049,1041,1,0,0,0,1049,1050,1,0,0,0,1050,1051,1,0,0,
        0,1051,1078,5,4,0,0,1052,1053,3,178,89,0,1053,1054,5,2,0,0,1054,
        1056,1,0,0,0,1055,1052,1,0,0,0,1055,1056,1,0,0,0,1056,1057,1,0,0,
        0,1057,1078,3,180,90,0,1058,1059,3,178,89,0,1059,1060,5,2,0,0,1060,
        1062,1,0,0,0,1061,1058,1,0,0,0,1061,1062,1,0,0,0,1062,1063,1,0,0,
        0,1063,1064,3,220,110,0,1064,1073,5,3,0,0,1065,1070,3,64,32,0,1066,
        1067,5,5,0,0,1067,1069,3,64,32,0,1068,1066,1,0,0,0,1069,1072,1,0,
        0,0,1070,1068,1,0,0,0,1070,1071,1,0,0,0,1071,1074,1,0,0,0,1072,1070,
        1,0,0,0,1073,1065,1,0,0,0,1073,1074,1,0,0,0,1074,1075,1,0,0,0,1075,
        1076,5,4,0,0,1076,1078,1,0,0,0,1077,1039,1,0,0,0,1077,1055,1,0,0,
        0,1077,1061,1,0,0,0,1078,1080,1,0,0,0,1079,962,1,0,0,0,1079,965,
        1,0,0,0,1079,968,1,0,0,0,1079,971,1,0,0,0,1079,974,1,0,0,0,1079,
        977,1,0,0,0,1079,993,1,0,0,0,1079,996,1,0,0,0,1079,999,1,0,0,0,1079,
        1005,1,0,0,0,1079,1014,1,0,0,0,1079,1017,1,0,0,0,1079,1027,1,0,0,
        0,1079,1034,1,0,0,0,1080,1083,1,0,0,0,1081,1079,1,0,0,0,1081,1082,
        1,0,0,0,1082,65,1,0,0,0,1083,1081,1,0,0,0,1084,1085,5,115,0,0,1085,
        1090,5,3,0,0,1086,1091,5,81,0,0,1087,1088,7,14,0,0,1088,1089,5,5,
        0,0,1089,1091,3,166,83,0,1090,1086,1,0,0,0,1090,1087,1,0,0,0,1091,
        1092,1,0,0,0,1092,1093,5,4,0,0,1093,67,1,0,0,0,1094,1095,7,15,0,
        0,1095,69,1,0,0,0,1096,1098,3,48,24,0,1097,1096,1,0,0,0,1097,1098,
        1,0,0,0,1098,1104,1,0,0,0,1099,1105,5,88,0,0,1100,1105,5,122,0,0,
        1101,1102,5,88,0,0,1102,1103,5,108,0,0,1103,1105,7,8,0,0,1104,1099,
        1,0,0,0,1104,1100,1,0,0,0,1104,1101,1,0,0,0,1105,1106,1,0,0,0,1106,
        1110,5,91,0,0,1107,1108,3,178,89,0,1108,1109,5,2,0,0,1109,1111,1,
        0,0,0,1110,1107,1,0,0,0,1110,1111,1,0,0,0,1111,1112,1,0,0,0,1112,
        1115,3,180,90,0,1113,1114,5,33,0,0,1114,1116,3,204,102,0,1115,1113,
        1,0,0,0,1115,1116,1,0,0,0,1116,1128,1,0,0,0,1117,1118,5,3,0,0,1118,
        1123,3,186,93,0,1119,1120,5,5,0,0,1120,1122,3,186,93,0,1121,1119,
        1,0,0,0,1122,1125,1,0,0,0,1123,1121,1,0,0,0,1123,1124,1,0,0,0,1124,
        1126,1,0,0,0,1125,1123,1,0,0,0,1126,1127,5,4,0,0,1127,1129,1,0,0,
        0,1128,1117,1,0,0,0,1128,1129,1,0,0,0,1129,1166,1,0,0,0,1130,1131,
        5,144,0,0,1131,1132,5,3,0,0,1132,1137,3,64,32,0,1133,1134,5,5,0,
        0,1134,1136,3,64,32,0,1135,1133,1,0,0,0,1136,1139,1,0,0,0,1137,1135,
        1,0,0,0,1137,1138,1,0,0,0,1138,1140,1,0,0,0,1139,1137,1,0,0,0,1140,
        1155,5,4,0,0,1141,1142,5,5,0,0,1142,1143,5,3,0,0,1143,1148,3,64,
        32,0,1144,1145,5,5,0,0,1145,1147,3,64,32,0,1146,1144,1,0,0,0,1147,
        1150,1,0,0,0,1148,1146,1,0,0,0,1148,1149,1,0,0,0,1149,1151,1,0,0,
        0,1150,1148,1,0,0,0,1151,1152,5,4,0,0,1152,1154,1,0,0,0,1153,1141,
        1,0,0,0,1154,1157,1,0,0,0,1155,1153,1,0,0,0,1155,1156,1,0,0,0,1156,
        1160,1,0,0,0,1157,1155,1,0,0,0,1158,1160,3,82,41,0,1159,1130,1,0,
        0,0,1159,1158,1,0,0,0,1160,1162,1,0,0,0,1161,1163,3,74,37,0,1162,
        1161,1,0,0,0,1162,1163,1,0,0,0,1163,1167,1,0,0,0,1164,1165,5,56,
        0,0,1165,1167,5,144,0,0,1166,1159,1,0,0,0,1166,1164,1,0,0,0,1167,
        1169,1,0,0,0,1168,1170,3,72,36,0,1169,1168,1,0,0,0,1169,1170,1,0,
        0,0,1170,71,1,0,0,0,1171,1172,5,124,0,0,1172,1177,3,96,48,0,1173,
        1174,5,5,0,0,1174,1176,3,96,48,0,1175,1173,1,0,0,0,1176,1179,1,0,
        0,0,1177,1175,1,0,0,0,1177,1178,1,0,0,0,1178,73,1,0,0,0,1179,1177,
        1,0,0,0,1180,1181,5,107,0,0,1181,1196,5,48,0,0,1182,1183,5,3,0,0,
        1183,1188,3,24,12,0,1184,1185,5,5,0,0,1185,1187,3,24,12,0,1186,1184,
        1,0,0,0,1187,1190,1,0,0,0,1188,1186,1,0,0,0,1188,1189,1,0,0,0,1189,
        1191,1,0,0,0,1190,1188,1,0,0,0,1191,1194,5,4,0,0,1192,1193,5,148,
        0,0,1193,1195,3,64,32,0,1194,1192,1,0,0,0,1194,1195,1,0,0,0,1195,
        1197,1,0,0,0,1196,1182,1,0,0,0,1196,1197,1,0,0,0,1197,1198,1,0,0,
        0,1198,1225,5,183,0,0,1199,1226,5,184,0,0,1200,1201,5,141,0,0,1201,
        1204,5,131,0,0,1202,1205,3,186,93,0,1203,1205,3,106,53,0,1204,1202,
        1,0,0,0,1204,1203,1,0,0,0,1205,1206,1,0,0,0,1206,1207,5,6,0,0,1207,
        1218,3,64,32,0,1208,1211,5,5,0,0,1209,1212,3,186,93,0,1210,1212,
        3,106,53,0,1211,1209,1,0,0,0,1211,1210,1,0,0,0,1212,1213,1,0,0,0,
        1213,1214,5,6,0,0,1214,1215,3,64,32,0,1215,1217,1,0,0,0,1216,1208,
        1,0,0,0,1217,1220,1,0,0,0,1218,1216,1,0,0,0,1218,1219,1,0,0,0,1219,
        1223,1,0,0,0,1220,1218,1,0,0,0,1221,1222,5,148,0,0,1222,1224,3,64,
        32,0,1223,1221,1,0,0,0,1223,1224,1,0,0,0,1224,1226,1,0,0,0,1225,
        1199,1,0,0,0,1225,1200,1,0,0,0,1226,75,1,0,0,0,1227,1231,5,112,0,
        0,1228,1229,3,178,89,0,1229,1230,5,2,0,0,1230,1232,1,0,0,0,1231,
        1228,1,0,0,0,1231,1232,1,0,0,0,1232,1233,1,0,0,0,1233,1240,3,200,
        100,0,1234,1235,5,6,0,0,1235,1241,3,78,39,0,1236,1237,5,3,0,0,1237,
        1238,3,78,39,0,1238,1239,5,4,0,0,1239,1241,1,0,0,0,1240,1234,1,0,
        0,0,1240,1236,1,0,0,0,1240,1241,1,0,0,0,1241,77,1,0,0,0,1242,1246,
        3,34,17,0,1243,1246,3,174,87,0,1244,1246,5,188,0,0,1245,1242,1,0,
        0,0,1245,1243,1,0,0,0,1245,1244,1,0,0,0,1246,79,1,0,0,0,1247,1258,
        5,119,0,0,1248,1259,3,188,94,0,1249,1250,3,178,89,0,1250,1251,5,
        2,0,0,1251,1253,1,0,0,0,1252,1249,1,0,0,0,1252,1253,1,0,0,0,1253,
        1256,1,0,0,0,1254,1257,3,180,90,0,1255,1257,3,192,96,0,1256,1254,
        1,0,0,0,1256,1255,1,0,0,0,1257,1259,1,0,0,0,1258,1248,1,0,0,0,1258,
        1252,1,0,0,0,1258,1259,1,0,0,0,1259,81,1,0,0,0,1260,1262,3,130,65,
        0,1261,1260,1,0,0,0,1261,1262,1,0,0,0,1262,1263,1,0,0,0,1263,1269,
        3,86,43,0,1264,1265,3,102,51,0,1265,1266,3,86,43,0,1266,1268,1,0,
        0,0,1267,1264,1,0,0,0,1268,1271,1,0,0,0,1269,1267,1,0,0,0,1269,1270,
        1,0,0,0,1270,1273,1,0,0,0,1271,1269,1,0,0,0,1272,1274,3,132,66,0,
        1273,1272,1,0,0,0,1273,1274,1,0,0,0,1274,1276,1,0,0,0,1275,1277,
        3,134,67,0,1276,1275,1,0,0,0,1276,1277,1,0,0,0,1277,83,1,0,0,0,1278,
        1286,3,94,47,0,1279,1280,3,98,49,0,1280,1282,3,94,47,0,1281,1283,
        3,100,50,0,1282,1281,1,0,0,0,1282,1283,1,0,0,0,1283,1285,1,0,0,0,
        1284,1279,1,0,0,0,1285,1288,1,0,0,0,1286,1284,1,0,0,0,1286,1287,
        1,0,0,0,1287,85,1,0,0,0,1288,1286,1,0,0,0,1289,1291,5,130,0,0,1290,
        1292,7,16,0,0,1291,1290,1,0,0,0,1291,1292,1,0,0,0,1292,1293,1,0,
        0,0,1293,1298,3,96,48,0,1294,1295,5,5,0,0,1295,1297,3,96,48,0,1296,
        1294,1,0,0,0,1297,1300,1,0,0,0,1298,1296,1,0,0,0,1298,1299,1,0,0,
        0,1299,1313,1,0,0,0,1300,1298,1,0,0,0,1301,1311,5,75,0,0,1302,1307,
        3,94,47,0,1303,1304,5,5,0,0,1304,1306,3,94,47,0,1305,1303,1,0,0,
        0,1306,1309,1,0,0,0,1307,1305,1,0,0,0,1307,1308,1,0,0,0,1308,1312,
        1,0,0,0,1309,1307,1,0,0,0,1310,1312,3,84,42,0,1311,1302,1,0,0,0,
        1311,1310,1,0,0,0,1312,1314,1,0,0,0,1313,1301,1,0,0,0,1313,1314,
        1,0,0,0,1314,1317,1,0,0,0,1315,1316,5,148,0,0,1316,1318,3,64,32,
        0,1317,1315,1,0,0,0,1317,1318,1,0,0,0,1318,1333,1,0,0,0,1319,1320,
        5,78,0,0,1320,1321,5,40,0,0,1321,1326,3,64,32,0,1322,1323,5,5,0,
        0,1323,1325,3,64,32,0,1324,1322,1,0,0,0,1325,1328,1,0,0,0,1326,1324,
        1,0,0,0,1326,1327,1,0,0,0,1327,1331,1,0,0,0,1328,1326,1,0,0,0,1329,
        1330,5,79,0,0,1330,1332,3,64,32,0,1331,1329,1,0,0,0,1331,1332,1,
        0,0,0,1332,1334,1,0,0,0,1333,1319,1,0,0,0,1333,1334,1,0,0,0,1334,
        1349,1,0,0,0,1335,1336,5,174,0,0,1336,1337,3,208,104,0,1337,1338,
        5,33,0,0,1338,1346,3,116,58,0,1339,1340,5,5,0,0,1340,1341,3,208,
        104,0,1341,1342,5,33,0,0,1342,1343,3,116,58,0,1343,1345,1,0,0,0,
        1344,1339,1,0,0,0,1345,1348,1,0,0,0,1346,1344,1,0,0,0,1346,1347,
        1,0,0,0,1347,1350,1,0,0,0,1348,1346,1,0,0,0,1349,1335,1,0,0,0,1349,
        1350,1,0,0,0,1350,1380,1,0,0,0,1351,1352,5,144,0,0,1352,1353,5,3,
        0,0,1353,1358,3,64,32,0,1354,1355,5,5,0,0,1355,1357,3,64,32,0,1356,
        1354,1,0,0,0,1357,1360,1,0,0,0,1358,1356,1,0,0,0,1358,1359,1,0,0,
        0,1359,1361,1,0,0,0,1360,1358,1,0,0,0,1361,1376,5,4,0,0,1362,1363,
        5,5,0,0,1363,1364,5,3,0,0,1364,1369,3,64,32,0,1365,1366,5,5,0,0,
        1366,1368,3,64,32,0,1367,1365,1,0,0,0,1368,1371,1,0,0,0,1369,1367,
        1,0,0,0,1369,1370,1,0,0,0,1370,1372,1,0,0,0,1371,1369,1,0,0,0,1372,
        1373,5,4,0,0,1373,1375,1,0,0,0,1374,1362,1,0,0,0,1375,1378,1,0,0,
        0,1376,1374,1,0,0,0,1376,1377,1,0,0,0,1377,1380,1,0,0,0,1378,1376,
        1,0,0,0,1379,1289,1,0,0,0,1379,1351,1,0,0,0,1380,87,1,0,0,0,1381,
        1382,3,82,41,0,1382,89,1,0,0,0,1383,1385,3,130,65,0,1384,1383,1,
        0,0,0,1384,1385,1,0,0,0,1385,1386,1,0,0,0,1386,1388,3,86,43,0,1387,
        1389,3,132,66,0,1388,1387,1,0,0,0,1388,1389,1,0,0,0,1389,1391,1,
        0,0,0,1390,1392,3,134,67,0,1391,1390,1,0,0,0,1391,1392,1,0,0,0,1392,
        91,1,0,0,0,1393,1395,3,130,65,0,1394,1393,1,0,0,0,1394,1395,1,0,
        0,0,1395,1396,1,0,0,0,1396,1406,3,86,43,0,1397,1399,5,139,0,0,1398,
        1400,5,29,0,0,1399,1398,1,0,0,0,1399,1400,1,0,0,0,1400,1404,1,0,
        0,0,1401,1404,5,90,0,0,1402,1404,5,68,0,0,1403,1397,1,0,0,0,1403,
        1401,1,0,0,0,1403,1402,1,0,0,0,1404,1405,1,0,0,0,1405,1407,3,86,
        43,0,1406,1403,1,0,0,0,1407,1408,1,0,0,0,1408,1406,1,0,0,0,1408,
        1409,1,0,0,0,1409,1411,1,0,0,0,1410,1412,3,132,66,0,1411,1410,1,
        0,0,0,1411,1412,1,0,0,0,1412,1414,1,0,0,0,1413,1415,3,134,67,0,1414,
        1413,1,0,0,0,1414,1415,1,0,0,0,1415,93,1,0,0,0,1416,1417,3,178,89,
        0,1417,1418,5,2,0,0,1418,1420,1,0,0,0,1419,1416,1,0,0,0,1419,1420,
        1,0,0,0,1420,1421,1,0,0,0,1421,1426,3,180,90,0,1422,1424,5,33,0,
        0,1423,1422,1,0,0,0,1423,1424,1,0,0,0,1424,1425,1,0,0,0,1425,1427,
        3,204,102,0,1426,1423,1,0,0,0,1426,1427,1,0,0,0,1427,1433,1,0,0,
        0,1428,1429,5,85,0,0,1429,1430,5,40,0,0,1430,1434,3,192,96,0,1431,
        1432,5,102,0,0,1432,1434,5,85,0,0,1433,1428,1,0,0,0,1433,1431,1,
        0,0,0,1433,1434,1,0,0,0,1434,1481,1,0,0,0,1435,1436,3,178,89,0,1436,
        1437,5,2,0,0,1437,1439,1,0,0,0,1438,1435,1,0,0,0,1438,1439,1,0,0,
        0,1439,1440,1,0,0,0,1440,1441,3,220,110,0,1441,1442,5,3,0,0,1442,
        1447,3,64,32,0,1443,1444,5,5,0,0,1444,1446,3,64,32,0,1445,1443,1,
        0,0,0,1446,1449,1,0,0,0,1447,1445,1,0,0,0,1447,1448,1,0,0,0,1448,
        1450,1,0,0,0,1449,1447,1,0,0,0,1450,1455,5,4,0,0,1451,1453,5,33,
        0,0,1452,1451,1,0,0,0,1452,1453,1,0,0,0,1453,1454,1,0,0,0,1454,1456,
        3,204,102,0,1455,1452,1,0,0,0,1455,1456,1,0,0,0,1456,1481,1,0,0,
        0,1457,1467,5,3,0,0,1458,1463,3,94,47,0,1459,1460,5,5,0,0,1460,1462,
        3,94,47,0,1461,1459,1,0,0,0,1462,1465,1,0,0,0,1463,1461,1,0,0,0,
        1463,1464,1,0,0,0,1464,1468,1,0,0,0,1465,1463,1,0,0,0,1466,1468,
        3,84,42,0,1467,1458,1,0,0,0,1467,1466,1,0,0,0,1468,1469,1,0,0,0,
        1469,1470,5,4,0,0,1470,1481,1,0,0,0,1471,1472,5,3,0,0,1472,1473,
        3,82,41,0,1473,1478,5,4,0,0,1474,1476,5,33,0,0,1475,1474,1,0,0,0,
        1475,1476,1,0,0,0,1476,1477,1,0,0,0,1477,1479,3,204,102,0,1478,1475,
        1,0,0,0,1478,1479,1,0,0,0,1479,1481,1,0,0,0,1480,1419,1,0,0,0,1480,
        1438,1,0,0,0,1480,1457,1,0,0,0,1480,1471,1,0,0,0,1481,95,1,0,0,0,
        1482,1495,5,7,0,0,1483,1484,3,180,90,0,1484,1485,5,2,0,0,1485,1486,
        5,7,0,0,1486,1495,1,0,0,0,1487,1492,3,64,32,0,1488,1490,5,33,0,0,
        1489,1488,1,0,0,0,1489,1490,1,0,0,0,1490,1491,1,0,0,0,1491,1493,
        3,170,85,0,1492,1489,1,0,0,0,1492,1493,1,0,0,0,1493,1495,1,0,0,0,
        1494,1482,1,0,0,0,1494,1483,1,0,0,0,1494,1487,1,0,0,0,1495,97,1,
        0,0,0,1496,1510,5,5,0,0,1497,1499,5,100,0,0,1498,1497,1,0,0,0,1498,
        1499,1,0,0,0,1499,1506,1,0,0,0,1500,1502,5,96,0,0,1501,1503,5,110,
        0,0,1502,1501,1,0,0,0,1502,1503,1,0,0,0,1503,1507,1,0,0,0,1504,1507,
        5,87,0,0,1505,1507,5,51,0,0,1506,1500,1,0,0,0,1506,1504,1,0,0,0,
        1506,1505,1,0,0,0,1506,1507,1,0,0,0,1507,1508,1,0,0,0,1508,1510,
        5,94,0,0,1509,1496,1,0,0,0,1509,1498,1,0,0,0,1510,99,1,0,0,0,1511,
        1512,5,107,0,0,1512,1526,3,64,32,0,1513,1514,5,142,0,0,1514,1515,
        5,3,0,0,1515,1520,3,186,93,0,1516,1517,5,5,0,0,1517,1519,3,186,93,
        0,1518,1516,1,0,0,0,1519,1522,1,0,0,0,1520,1518,1,0,0,0,1520,1521,
        1,0,0,0,1521,1523,1,0,0,0,1522,1520,1,0,0,0,1523,1524,5,4,0,0,1524,
        1526,1,0,0,0,1525,1511,1,0,0,0,1525,1513,1,0,0,0,1526,101,1,0,0,
        0,1527,1529,5,139,0,0,1528,1530,5,29,0,0,1529,1528,1,0,0,0,1529,
        1530,1,0,0,0,1530,1534,1,0,0,0,1531,1534,5,90,0,0,1532,1534,5,68,
        0,0,1533,1527,1,0,0,0,1533,1531,1,0,0,0,1533,1532,1,0,0,0,1534,103,
        1,0,0,0,1535,1537,3,48,24,0,1536,1535,1,0,0,0,1536,1537,1,0,0,0,
        1537,1538,1,0,0,0,1538,1541,5,141,0,0,1539,1540,5,108,0,0,1540,1542,
        7,8,0,0,1541,1539,1,0,0,0,1541,1542,1,0,0,0,1542,1543,1,0,0,0,1543,
        1544,3,110,55,0,1544,1547,5,131,0,0,1545,1548,3,186,93,0,1546,1548,
        3,106,53,0,1547,1545,1,0,0,0,1547,1546,1,0,0,0,1548,1549,1,0,0,0,
        1549,1550,5,6,0,0,1550,1561,3,64,32,0,1551,1554,5,5,0,0,1552,1555,
        3,186,93,0,1553,1555,3,106,53,0,1554,1552,1,0,0,0,1554,1553,1,0,
        0,0,1555,1556,1,0,0,0,1556,1557,5,6,0,0,1557,1558,3,64,32,0,1558,
        1560,1,0,0,0,1559,1551,1,0,0,0,1560,1563,1,0,0,0,1561,1559,1,0,0,
        0,1561,1562,1,0,0,0,1562,1576,1,0,0,0,1563,1561,1,0,0,0,1564,1574,
        5,75,0,0,1565,1570,3,94,47,0,1566,1567,5,5,0,0,1567,1569,3,94,47,
        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,1575,1,0,0,0,1572,1570,1,0,0,0,1573,1575,3,84,42,0,
        1574,1565,1,0,0,0,1574,1573,1,0,0,0,1575,1577,1,0,0,0,1576,1564,
        1,0,0,0,1576,1577,1,0,0,0,1577,1580,1,0,0,0,1578,1579,5,148,0,0,
        1579,1581,3,64,32,0,1580,1578,1,0,0,0,1580,1581,1,0,0,0,1581,1583,
        1,0,0,0,1582,1584,3,72,36,0,1583,1582,1,0,0,0,1583,1584,1,0,0,0,
        1584,105,1,0,0,0,1585,1586,5,3,0,0,1586,1591,3,186,93,0,1587,1588,
        5,5,0,0,1588,1590,3,186,93,0,1589,1587,1,0,0,0,1590,1593,1,0,0,0,
        1591,1589,1,0,0,0,1591,1592,1,0,0,0,1592,1594,1,0,0,0,1593,1591,
        1,0,0,0,1594,1595,5,4,0,0,1595,107,1,0,0,0,1596,1598,3,48,24,0,1597,
        1596,1,0,0,0,1597,1598,1,0,0,0,1598,1599,1,0,0,0,1599,1602,5,141,
        0,0,1600,1601,5,108,0,0,1601,1603,7,8,0,0,1602,1600,1,0,0,0,1602,
        1603,1,0,0,0,1603,1604,1,0,0,0,1604,1605,3,110,55,0,1605,1608,5,
        131,0,0,1606,1609,3,186,93,0,1607,1609,3,106,53,0,1608,1606,1,0,
        0,0,1608,1607,1,0,0,0,1609,1610,1,0,0,0,1610,1611,5,6,0,0,1611,1622,
        3,64,32,0,1612,1615,5,5,0,0,1613,1616,3,186,93,0,1614,1616,3,106,
        53,0,1615,1613,1,0,0,0,1615,1614,1,0,0,0,1616,1617,1,0,0,0,1617,
        1618,5,6,0,0,1618,1619,3,64,32,0,1619,1621,1,0,0,0,1620,1612,1,0,
        0,0,1621,1624,1,0,0,0,1622,1620,1,0,0,0,1622,1623,1,0,0,0,1623,1627,
        1,0,0,0,1624,1622,1,0,0,0,1625,1626,5,148,0,0,1626,1628,3,64,32,
        0,1627,1625,1,0,0,0,1627,1628,1,0,0,0,1628,1630,1,0,0,0,1629,1631,
        3,72,36,0,1630,1629,1,0,0,0,1630,1631,1,0,0,0,1631,1636,1,0,0,0,
        1632,1634,3,132,66,0,1633,1632,1,0,0,0,1633,1634,1,0,0,0,1634,1635,
        1,0,0,0,1635,1637,3,134,67,0,1636,1633,1,0,0,0,1636,1637,1,0,0,0,
        1637,109,1,0,0,0,1638,1639,3,178,89,0,1639,1640,5,2,0,0,1640,1642,
        1,0,0,0,1641,1638,1,0,0,0,1641,1642,1,0,0,0,1642,1643,1,0,0,0,1643,
        1646,3,180,90,0,1644,1645,5,33,0,0,1645,1647,3,210,105,0,1646,1644,
        1,0,0,0,1646,1647,1,0,0,0,1647,1653,1,0,0,0,1648,1649,5,85,0,0,1649,
        1650,5,40,0,0,1650,1654,3,192,96,0,1651,1652,5,102,0,0,1652,1654,
        5,85,0,0,1653,1648,1,0,0,0,1653,1651,1,0,0,0,1653,1654,1,0,0,0,1654,
        111,1,0,0,0,1655,1657,5,143,0,0,1656,1658,3,178,89,0,1657,1656,1,
        0,0,0,1657,1658,1,0,0,0,1658,1661,1,0,0,0,1659,1660,5,91,0,0,1660,
        1662,3,212,106,0,1661,1659,1,0,0,0,1661,1662,1,0,0,0,1662,113,1,
        0,0,0,1663,1664,5,178,0,0,1664,1665,5,3,0,0,1665,1666,5,148,0,0,
        1666,1667,3,64,32,0,1667,1668,5,4,0,0,1668,115,1,0,0,0,1669,1671,
        5,3,0,0,1670,1672,3,214,107,0,1671,1670,1,0,0,0,1671,1672,1,0,0,
        0,1672,1683,1,0,0,0,1673,1674,5,153,0,0,1674,1675,5,40,0,0,1675,
        1680,3,64,32,0,1676,1677,5,5,0,0,1677,1679,3,64,32,0,1678,1676,1,
        0,0,0,1679,1682,1,0,0,0,1680,1678,1,0,0,0,1680,1681,1,0,0,0,1681,
        1684,1,0,0,0,1682,1680,1,0,0,0,1683,1673,1,0,0,0,1683,1684,1,0,0,
        0,1684,1685,1,0,0,0,1685,1686,5,109,0,0,1686,1687,5,40,0,0,1687,
        1692,3,136,68,0,1688,1689,5,5,0,0,1689,1691,3,136,68,0,1690,1688,
        1,0,0,0,1691,1694,1,0,0,0,1692,1690,1,0,0,0,1692,1693,1,0,0,0,1693,
        1696,1,0,0,0,1694,1692,1,0,0,0,1695,1697,3,120,60,0,1696,1695,1,
        0,0,0,1696,1697,1,0,0,0,1697,1698,1,0,0,0,1698,1699,5,4,0,0,1699,
        117,1,0,0,0,1700,1734,5,152,0,0,1701,1735,3,208,104,0,1702,1704,
        5,3,0,0,1703,1705,3,214,107,0,1704,1703,1,0,0,0,1704,1705,1,0,0,
        0,1705,1716,1,0,0,0,1706,1707,5,153,0,0,1707,1708,5,40,0,0,1708,
        1713,3,64,32,0,1709,1710,5,5,0,0,1710,1712,3,64,32,0,1711,1709,1,
        0,0,0,1712,1715,1,0,0,0,1713,1711,1,0,0,0,1713,1714,1,0,0,0,1714,
        1717,1,0,0,0,1715,1713,1,0,0,0,1716,1706,1,0,0,0,1716,1717,1,0,0,
        0,1717,1728,1,0,0,0,1718,1719,5,109,0,0,1719,1720,5,40,0,0,1720,
        1725,3,136,68,0,1721,1722,5,5,0,0,1722,1724,3,136,68,0,1723,1721,
        1,0,0,0,1724,1727,1,0,0,0,1725,1723,1,0,0,0,1725,1726,1,0,0,0,1726,
        1729,1,0,0,0,1727,1725,1,0,0,0,1728,1718,1,0,0,0,1728,1729,1,0,0,
        0,1729,1731,1,0,0,0,1730,1732,3,120,60,0,1731,1730,1,0,0,0,1731,
        1732,1,0,0,0,1732,1733,1,0,0,0,1733,1735,5,4,0,0,1734,1701,1,0,0,
        0,1734,1702,1,0,0,0,1735,119,1,0,0,0,1736,1744,3,122,61,0,1737,1738,
        5,180,0,0,1738,1739,5,101,0,0,1739,1745,5,182,0,0,1740,1741,5,157,
        0,0,1741,1745,5,127,0,0,1742,1745,5,78,0,0,1743,1745,5,181,0,0,1744,
        1737,1,0,0,0,1744,1740,1,0,0,0,1744,1742,1,0,0,0,1744,1743,1,0,0,
        0,1744,1745,1,0,0,0,1745,121,1,0,0,0,1746,1753,7,17,0,0,1747,1754,
        3,144,72,0,1748,1749,5,39,0,0,1749,1750,3,140,70,0,1750,1751,5,32,
        0,0,1751,1752,3,142,71,0,1752,1754,1,0,0,0,1753,1747,1,0,0,0,1753,
        1748,1,0,0,0,1754,123,1,0,0,0,1755,1756,3,216,108,0,1756,1766,5,
        3,0,0,1757,1762,3,64,32,0,1758,1759,5,5,0,0,1759,1761,3,64,32,0,
        1760,1758,1,0,0,0,1761,1764,1,0,0,0,1762,1760,1,0,0,0,1762,1763,
        1,0,0,0,1763,1767,1,0,0,0,1764,1762,1,0,0,0,1765,1767,5,7,0,0,1766,
        1757,1,0,0,0,1766,1765,1,0,0,0,1767,1768,1,0,0,0,1768,1769,5,4,0,
        0,1769,125,1,0,0,0,1770,1771,3,218,109,0,1771,1784,5,3,0,0,1772,
        1774,5,62,0,0,1773,1772,1,0,0,0,1773,1774,1,0,0,0,1774,1775,1,0,
        0,0,1775,1780,3,64,32,0,1776,1777,5,5,0,0,1777,1779,3,64,32,0,1778,
        1776,1,0,0,0,1779,1782,1,0,0,0,1780,1778,1,0,0,0,1780,1781,1,0,0,
        0,1781,1785,1,0,0,0,1782,1780,1,0,0,0,1783,1785,5,7,0,0,1784,1773,
        1,0,0,0,1784,1783,1,0,0,0,1784,1785,1,0,0,0,1785,1786,1,0,0,0,1786,
        1788,5,4,0,0,1787,1789,3,114,57,0,1788,1787,1,0,0,0,1788,1789,1,
        0,0,0,1789,127,1,0,0,0,1790,1791,3,146,73,0,1791,1801,5,3,0,0,1792,
        1797,3,64,32,0,1793,1794,5,5,0,0,1794,1796,3,64,32,0,1795,1793,1,
        0,0,0,1796,1799,1,0,0,0,1797,1795,1,0,0,0,1797,1798,1,0,0,0,1798,
        1802,1,0,0,0,1799,1797,1,0,0,0,1800,1802,5,7,0,0,1801,1792,1,0,0,
        0,1801,1800,1,0,0,0,1801,1802,1,0,0,0,1802,1803,1,0,0,0,1803,1805,
        5,4,0,0,1804,1806,3,114,57,0,1805,1804,1,0,0,0,1805,1806,1,0,0,0,
        1806,1807,1,0,0,0,1807,1810,5,152,0,0,1808,1811,3,116,58,0,1809,
        1811,3,208,104,0,1810,1808,1,0,0,0,1810,1809,1,0,0,0,1811,129,1,
        0,0,0,1812,1814,5,149,0,0,1813,1815,5,116,0,0,1814,1813,1,0,0,0,
        1814,1815,1,0,0,0,1815,1816,1,0,0,0,1816,1821,3,54,27,0,1817,1818,
        5,5,0,0,1818,1820,3,54,27,0,1819,1817,1,0,0,0,1820,1823,1,0,0,0,
        1821,1819,1,0,0,0,1821,1822,1,0,0,0,1822,131,1,0,0,0,1823,1821,1,
        0,0,0,1824,1825,5,109,0,0,1825,1826,5,40,0,0,1826,1831,3,136,68,
        0,1827,1828,5,5,0,0,1828,1830,3,136,68,0,1829,1827,1,0,0,0,1830,
        1833,1,0,0,0,1831,1829,1,0,0,0,1831,1832,1,0,0,0,1832,133,1,0,0,
        0,1833,1831,1,0,0,0,1834,1835,5,98,0,0,1835,1838,3,64,32,0,1836,
        1837,7,18,0,0,1837,1839,3,64,32,0,1838,1836,1,0,0,0,1838,1839,1,
        0,0,0,1839,135,1,0,0,0,1840,1843,3,64,32,0,1841,1842,5,45,0,0,1842,
        1844,3,188,94,0,1843,1841,1,0,0,0,1843,1844,1,0,0,0,1844,1846,1,
        0,0,0,1845,1847,3,138,69,0,1846,1845,1,0,0,0,1846,1847,1,0,0,0,1847,
        1850,1,0,0,0,1848,1849,5,175,0,0,1849,1851,7,19,0,0,1850,1848,1,
        0,0,0,1850,1851,1,0,0,0,1851,137,1,0,0,0,1852,1853,7,20,0,0,1853,
        139,1,0,0,0,1854,1855,3,64,32,0,1855,1856,5,155,0,0,1856,1865,1,
        0,0,0,1857,1858,3,64,32,0,1858,1859,5,158,0,0,1859,1865,1,0,0,0,
        1860,1861,5,157,0,0,1861,1865,5,127,0,0,1862,1863,5,156,0,0,1863,
        1865,5,155,0,0,1864,1854,1,0,0,0,1864,1857,1,0,0,0,1864,1860,1,0,
        0,0,1864,1862,1,0,0,0,1865,141,1,0,0,0,1866,1867,3,64,32,0,1867,
        1868,5,155,0,0,1868,1877,1,0,0,0,1869,1870,3,64,32,0,1870,1871,5,
        158,0,0,1871,1877,1,0,0,0,1872,1873,5,157,0,0,1873,1877,5,127,0,
        0,1874,1875,5,156,0,0,1875,1877,5,158,0,0,1876,1866,1,0,0,0,1876,
        1869,1,0,0,0,1876,1872,1,0,0,0,1876,1874,1,0,0,0,1877,143,1,0,0,
        0,1878,1879,3,64,32,0,1879,1880,5,155,0,0,1880,1886,1,0,0,0,1881,
        1882,5,156,0,0,1882,1886,5,155,0,0,1883,1884,5,157,0,0,1884,1886,
        5,127,0,0,1885,1878,1,0,0,0,1885,1881,1,0,0,0,1885,1883,1,0,0,0,
        1886,145,1,0,0,0,1887,1888,7,21,0,0,1888,1889,5,3,0,0,1889,1890,
        3,64,32,0,1890,1891,5,4,0,0,1891,1892,5,152,0,0,1892,1894,5,3,0,
        0,1893,1895,3,152,76,0,1894,1893,1,0,0,0,1894,1895,1,0,0,0,1895,
        1896,1,0,0,0,1896,1898,3,156,78,0,1897,1899,3,122,61,0,1898,1897,
        1,0,0,0,1898,1899,1,0,0,0,1899,1900,1,0,0,0,1900,1901,5,4,0,0,1901,
        1973,1,0,0,0,1902,1903,7,22,0,0,1903,1904,5,3,0,0,1904,1905,5,4,
        0,0,1905,1906,5,152,0,0,1906,1908,5,3,0,0,1907,1909,3,152,76,0,1908,
        1907,1,0,0,0,1908,1909,1,0,0,0,1909,1911,1,0,0,0,1910,1912,3,154,
        77,0,1911,1910,1,0,0,0,1911,1912,1,0,0,0,1912,1913,1,0,0,0,1913,
        1973,5,4,0,0,1914,1915,7,23,0,0,1915,1916,5,3,0,0,1916,1917,5,4,
        0,0,1917,1918,5,152,0,0,1918,1920,5,3,0,0,1919,1921,3,152,76,0,1920,
        1919,1,0,0,0,1920,1921,1,0,0,0,1921,1922,1,0,0,0,1922,1923,3,156,
        78,0,1923,1924,5,4,0,0,1924,1973,1,0,0,0,1925,1926,7,24,0,0,1926,
        1927,5,3,0,0,1927,1929,3,64,32,0,1928,1930,3,148,74,0,1929,1928,
        1,0,0,0,1929,1930,1,0,0,0,1930,1932,1,0,0,0,1931,1933,3,150,75,0,
        1932,1931,1,0,0,0,1932,1933,1,0,0,0,1933,1934,1,0,0,0,1934,1935,
        5,4,0,0,1935,1936,5,152,0,0,1936,1938,5,3,0,0,1937,1939,3,152,76,
        0,1938,1937,1,0,0,0,1938,1939,1,0,0,0,1939,1940,1,0,0,0,1940,1941,
        3,156,78,0,1941,1942,5,4,0,0,1942,1973,1,0,0,0,1943,1944,5,164,0,
        0,1944,1945,5,3,0,0,1945,1946,3,64,32,0,1946,1947,5,5,0,0,1947,1948,
        3,34,17,0,1948,1949,5,4,0,0,1949,1950,5,152,0,0,1950,1952,5,3,0,
        0,1951,1953,3,152,76,0,1952,1951,1,0,0,0,1952,1953,1,0,0,0,1953,
        1954,1,0,0,0,1954,1956,3,156,78,0,1955,1957,3,122,61,0,1956,1955,
        1,0,0,0,1956,1957,1,0,0,0,1957,1958,1,0,0,0,1958,1959,5,4,0,0,1959,
        1973,1,0,0,0,1960,1961,5,165,0,0,1961,1962,5,3,0,0,1962,1963,3,64,
        32,0,1963,1964,5,4,0,0,1964,1965,5,152,0,0,1965,1967,5,3,0,0,1966,
        1968,3,152,76,0,1967,1966,1,0,0,0,1967,1968,1,0,0,0,1968,1969,1,
        0,0,0,1969,1970,3,156,78,0,1970,1971,5,4,0,0,1971,1973,1,0,0,0,1972,
        1887,1,0,0,0,1972,1902,1,0,0,0,1972,1914,1,0,0,0,1972,1925,1,0,0,
        0,1972,1943,1,0,0,0,1972,1960,1,0,0,0,1973,147,1,0,0,0,1974,1975,
        5,5,0,0,1975,1976,3,34,17,0,1976,149,1,0,0,0,1977,1978,5,5,0,0,1978,
        1979,3,34,17,0,1979,151,1,0,0,0,1980,1981,5,153,0,0,1981,1983,5,
        40,0,0,1982,1984,3,64,32,0,1983,1982,1,0,0,0,1984,1985,1,0,0,0,1985,
        1983,1,0,0,0,1985,1986,1,0,0,0,1986,153,1,0,0,0,1987,1988,5,109,
        0,0,1988,1990,5,40,0,0,1989,1991,3,64,32,0,1990,1989,1,0,0,0,1991,
        1992,1,0,0,0,1992,1990,1,0,0,0,1992,1993,1,0,0,0,1993,155,1,0,0,
        0,1994,1995,5,109,0,0,1995,1996,5,40,0,0,1996,1997,3,158,79,0,1997,
        157,1,0,0,0,1998,2000,3,64,32,0,1999,2001,3,138,69,0,2000,1999,1,
        0,0,0,2000,2001,1,0,0,0,2001,2009,1,0,0,0,2002,2003,5,5,0,0,2003,
        2005,3,64,32,0,2004,2006,3,138,69,0,2005,2004,1,0,0,0,2005,2006,
        1,0,0,0,2006,2008,1,0,0,0,2007,2002,1,0,0,0,2008,2011,1,0,0,0,2009,
        2007,1,0,0,0,2009,2010,1,0,0,0,2010,159,1,0,0,0,2011,2009,1,0,0,
        0,2012,2013,3,82,41,0,2013,161,1,0,0,0,2014,2015,3,82,41,0,2015,
        163,1,0,0,0,2016,2017,7,25,0,0,2017,165,1,0,0,0,2018,2019,5,188,
        0,0,2019,167,1,0,0,0,2020,2023,3,64,32,0,2021,2023,3,28,14,0,2022,
        2020,1,0,0,0,2022,2021,1,0,0,0,2023,169,1,0,0,0,2024,2025,7,26,0,
        0,2025,171,1,0,0,0,2026,2027,7,27,0,0,2027,173,1,0,0,0,2028,2029,
        3,222,111,0,2029,175,1,0,0,0,2030,2031,3,222,111,0,2031,177,1,0,
        0,0,2032,2033,3,222,111,0,2033,179,1,0,0,0,2034,2035,3,222,111,0,
        2035,181,1,0,0,0,2036,2037,3,222,111,0,2037,183,1,0,0,0,2038,2039,
        3,222,111,0,2039,185,1,0,0,0,2040,2041,3,222,111,0,2041,187,1,0,
        0,0,2042,2043,3,222,111,0,2043,189,1,0,0,0,2044,2045,3,222,111,0,
        2045,191,1,0,0,0,2046,2047,3,222,111,0,2047,193,1,0,0,0,2048,2049,
        3,222,111,0,2049,195,1,0,0,0,2050,2051,3,222,111,0,2051,197,1,0,
        0,0,2052,2053,3,222,111,0,2053,199,1,0,0,0,2054,2055,3,222,111,0,
        2055,201,1,0,0,0,2056,2057,3,222,111,0,2057,203,1,0,0,0,2058,2059,
        3,222,111,0,2059,205,1,0,0,0,2060,2061,3,222,111,0,2061,207,1,0,
        0,0,2062,2063,3,222,111,0,2063,209,1,0,0,0,2064,2065,3,222,111,0,
        2065,211,1,0,0,0,2066,2067,3,222,111,0,2067,213,1,0,0,0,2068,2069,
        3,222,111,0,2069,215,1,0,0,0,2070,2071,3,222,111,0,2071,217,1,0,
        0,0,2072,2073,3,222,111,0,2073,219,1,0,0,0,2074,2075,3,222,111,0,
        2075,221,1,0,0,0,2076,2084,5,185,0,0,2077,2084,3,172,86,0,2078,2084,
        5,188,0,0,2079,2080,5,3,0,0,2080,2081,3,222,111,0,2081,2082,5,4,
        0,0,2082,2084,1,0,0,0,2083,2076,1,0,0,0,2083,2077,1,0,0,0,2083,2078,
        1,0,0,0,2083,2079,1,0,0,0,2084,223,1,0,0,0,298,227,235,242,247,253,
        259,261,287,294,301,307,311,316,319,326,329,333,341,345,347,351,
        355,359,362,369,375,381,386,397,403,407,411,414,418,424,429,438,
        445,451,455,459,464,470,482,486,491,494,497,502,505,519,526,533,
        535,538,544,549,557,562,577,583,593,598,608,612,614,618,623,625,
        633,639,644,651,662,665,667,674,678,685,691,697,703,708,717,722,
        733,738,749,754,758,774,784,789,797,809,814,822,829,832,835,842,
        845,848,851,855,863,868,878,883,892,899,903,907,910,918,931,934,
        942,951,955,960,990,1002,1007,1019,1025,1032,1036,1046,1049,1055,
        1061,1070,1073,1077,1079,1081,1090,1097,1104,1110,1115,1123,1128,
        1137,1148,1155,1159,1162,1166,1169,1177,1188,1194,1196,1204,1211,
        1218,1223,1225,1231,1240,1245,1252,1256,1258,1261,1269,1273,1276,
        1282,1286,1291,1298,1307,1311,1313,1317,1326,1331,1333,1346,1349,
        1358,1369,1376,1379,1384,1388,1391,1394,1399,1403,1408,1411,1414,
        1419,1423,1426,1433,1438,1447,1452,1455,1463,1467,1475,1478,1480,
        1489,1492,1494,1498,1502,1506,1509,1520,1525,1529,1533,1536,1541,
        1547,1554,1561,1570,1574,1576,1580,1583,1591,1597,1602,1608,1615,
        1622,1627,1630,1633,1636,1641,1646,1653,1657,1661,1671,1680,1683,
        1692,1696,1704,1713,1716,1725,1728,1731,1734,1744,1753,1762,1766,
        1773,1780,1784,1788,1797,1801,1805,1810,1814,1821,1831,1838,1843,
        1846,1850,1864,1876,1885,1894,1898,1908,1911,1920,1929,1932,1938,
        1952,1956,1967,1972,1985,1992,2000,2005,2009,2022,2083
    ]

class SQLiteParser ( Parser ):

    grammarFileName = "SQLiteParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "';'", "'.'", "'('", "')'", "','", "'='", 
                     "'*'", "'+'", "'-'", "'~'", "'||'", "'/'", "'%'", "'<<'", 
                     "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'", "'>='", 
                     "'=='", "'!='", "'<>'", "'ABORT'", "'ACTION'", "'ADD'", 
                     "'AFTER'", "'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", 
                     "'AS'", "'ASC'", "'ATTACH'", "'AUTOINCREMENT'", "'BEFORE'", 
                     "'BEGIN'", "'BETWEEN'", "'BY'", "'CASCADE'", "'CASE'", 
                     "'CAST'", "'CHECK'", "'COLLATE'", "'COLUMN'", "'COMMIT'", 
                     "'CONFLICT'", "'CONSTRAINT'", "'CREATE'", "'CROSS'", 
                     "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", 
                     "'DATABASE'", "'DEFAULT'", "'DEFERRABLE'", "'DEFERRED'", 
                     "'DELETE'", "'DESC'", "'DETACH'", "'DISTINCT'", "'DROP'", 
                     "'EACH'", "'ELSE'", "'END'", "'ESCAPE'", "'EXCEPT'", 
                     "'EXCLUSIVE'", "'EXISTS'", "'EXPLAIN'", "'FAIL'", "'FOR'", 
                     "'FOREIGN'", "'FROM'", "'FULL'", "'GLOB'", "'GROUP'", 
                     "'HAVING'", "'IF'", "'IGNORE'", "'IMMEDIATE'", "'IN'", 
                     "'INDEX'", "'INDEXED'", "'INITIALLY'", "'INNER'", "'INSERT'", 
                     "'INSTEAD'", "'INTERSECT'", "'INTO'", "'IS'", "'ISNULL'", 
                     "'JOIN'", "'KEY'", "'LEFT'", "'LIKE'", "'LIMIT'", "'MATCH'", 
                     "'NATURAL'", "'NO'", "'NOT'", "'NOTNULL'", "'NULL'", 
                     "'OF'", "'OFFSET'", "'ON'", "'OR'", "'ORDER'", "'OUTER'", 
                     "'PLAN'", "'PRAGMA'", "'PRIMARY'", "'QUERY'", "'RAISE'", 
                     "'RECURSIVE'", "'REFERENCES'", "'REGEXP'", "'REINDEX'", 
                     "'RELEASE'", "'RENAME'", "'REPLACE'", "'RESTRICT'", 
                     "'RETURNING'", "'RIGHT'", "'ROLLBACK'", "'ROW'", "'ROWS'", 
                     "'SAVEPOINT'", "'SELECT'", "'SET'", "'TABLE'", "'TEMP'", 
                     "'TEMPORARY'", "'THEN'", "'TO'", "'TRANSACTION'", "'TRIGGER'", 
                     "'UNION'", "'UNIQUE'", "'UPDATE'", "'USING'", "'VACUUM'", 
                     "'VALUES'", "'VIEW'", "'VIRTUAL'", "'WHEN'", "'WHERE'", 
                     "'WITH'", "'WITHOUT'", "'FIRST_VALUE'", "'OVER'", "'PARTITION'", 
                     "'RANGE'", "'PRECEDING'", "'UNBOUNDED'", "'CURRENT'", 
                     "'FOLLOWING'", "'CUME_DIST'", "'DENSE_RANK'", "'LAG'", 
                     "'LAST_VALUE'", "'LEAD'", "'NTH_VALUE'", "'NTILE'", 
                     "'PERCENT_RANK'", "'RANK'", "'ROW_NUMBER'", "'GENERATED'", 
                     "'ALWAYS'", "'STORED'", "'TRUE'", "'FALSE'", "'WINDOW'", 
                     "'NULLS'", "'FIRST'", "'LAST'", "'FILTER'", "'GROUPS'", 
                     "'EXCLUDE'", "'TIES'", "'OTHERS'", "'DO'", "'NOTHING'" ]

    symbolicNames = [ "<INVALID>", "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", 
                      "COMMA", "ASSIGN", "STAR", "PLUS", "MINUS", "TILDE", 
                      "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP", "PIPE", 
                      "LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2", 
                      "ABORT_", "ACTION_", "ADD_", "AFTER_", "ALL_", "ALTER_", 
                      "ANALYZE_", "AND_", "AS_", "ASC_", "ATTACH_", "AUTOINCREMENT_", 
                      "BEFORE_", "BEGIN_", "BETWEEN_", "BY_", "CASCADE_", 
                      "CASE_", "CAST_", "CHECK_", "COLLATE_", "COLUMN_", 
                      "COMMIT_", "CONFLICT_", "CONSTRAINT_", "CREATE_", 
                      "CROSS_", "CURRENT_DATE_", "CURRENT_TIME_", "CURRENT_TIMESTAMP_", 
                      "DATABASE_", "DEFAULT_", "DEFERRABLE_", "DEFERRED_", 
                      "DELETE_", "DESC_", "DETACH_", "DISTINCT_", "DROP_", 
                      "EACH_", "ELSE_", "END_", "ESCAPE_", "EXCEPT_", "EXCLUSIVE_", 
                      "EXISTS_", "EXPLAIN_", "FAIL_", "FOR_", "FOREIGN_", 
                      "FROM_", "FULL_", "GLOB_", "GROUP_", "HAVING_", "IF_", 
                      "IGNORE_", "IMMEDIATE_", "IN_", "INDEX_", "INDEXED_", 
                      "INITIALLY_", "INNER_", "INSERT_", "INSTEAD_", "INTERSECT_", 
                      "INTO_", "IS_", "ISNULL_", "JOIN_", "KEY_", "LEFT_", 
                      "LIKE_", "LIMIT_", "MATCH_", "NATURAL_", "NO_", "NOT_", 
                      "NOTNULL_", "NULL_", "OF_", "OFFSET_", "ON_", "OR_", 
                      "ORDER_", "OUTER_", "PLAN_", "PRAGMA_", "PRIMARY_", 
                      "QUERY_", "RAISE_", "RECURSIVE_", "REFERENCES_", "REGEXP_", 
                      "REINDEX_", "RELEASE_", "RENAME_", "REPLACE_", "RESTRICT_", 
                      "RETURNING_", "RIGHT_", "ROLLBACK_", "ROW_", "ROWS_", 
                      "SAVEPOINT_", "SELECT_", "SET_", "TABLE_", "TEMP_", 
                      "TEMPORARY_", "THEN_", "TO_", "TRANSACTION_", "TRIGGER_", 
                      "UNION_", "UNIQUE_", "UPDATE_", "USING_", "VACUUM_", 
                      "VALUES_", "VIEW_", "VIRTUAL_", "WHEN_", "WHERE_", 
                      "WITH_", "WITHOUT_", "FIRST_VALUE_", "OVER_", "PARTITION_", 
                      "RANGE_", "PRECEDING_", "UNBOUNDED_", "CURRENT_", 
                      "FOLLOWING_", "CUME_DIST_", "DENSE_RANK_", "LAG_", 
                      "LAST_VALUE_", "LEAD_", "NTH_VALUE_", "NTILE_", "PERCENT_RANK_", 
                      "RANK_", "ROW_NUMBER_", "GENERATED_", "ALWAYS_", "STORED_", 
                      "TRUE_", "FALSE_", "WINDOW_", "NULLS_", "FIRST_", 
                      "LAST_", "FILTER_", "GROUPS_", "EXCLUDE_", "TIES_", 
                      "OTHERS_", "DO_", "NOTHING_", "IDENTIFIER", "NUMERIC_LITERAL", 
                      "BIND_PARAMETER", "STRING_LITERAL", "BLOB_LITERAL", 
                      "SINGLE_LINE_COMMENT", "MULTILINE_COMMENT", "SPACES", 
                      "UNEXPECTED_CHAR" ]

    RULE_parse = 0
    RULE_sql_stmt_list = 1
    RULE_sql_stmt = 2
    RULE_alter_table_stmt = 3
    RULE_analyze_stmt = 4
    RULE_attach_stmt = 5
    RULE_begin_stmt = 6
    RULE_commit_stmt = 7
    RULE_rollback_stmt = 8
    RULE_savepoint_stmt = 9
    RULE_release_stmt = 10
    RULE_create_index_stmt = 11
    RULE_indexed_column = 12
    RULE_create_table_stmt = 13
    RULE_column_def = 14
    RULE_type_name = 15
    RULE_column_constraint = 16
    RULE_signed_number = 17
    RULE_table_constraint = 18
    RULE_foreign_key_clause = 19
    RULE_conflict_clause = 20
    RULE_create_trigger_stmt = 21
    RULE_create_view_stmt = 22
    RULE_create_virtual_table_stmt = 23
    RULE_with_clause = 24
    RULE_cte_table_name = 25
    RULE_recursive_cte = 26
    RULE_common_table_expression = 27
    RULE_delete_stmt = 28
    RULE_delete_stmt_limited = 29
    RULE_detach_stmt = 30
    RULE_drop_stmt = 31
    RULE_expr = 32
    RULE_raise_function = 33
    RULE_literal_value = 34
    RULE_insert_stmt = 35
    RULE_returning_clause = 36
    RULE_upsert_clause = 37
    RULE_pragma_stmt = 38
    RULE_pragma_value = 39
    RULE_reindex_stmt = 40
    RULE_select_stmt = 41
    RULE_join_clause = 42
    RULE_select_core = 43
    RULE_factored_select_stmt = 44
    RULE_simple_select_stmt = 45
    RULE_compound_select_stmt = 46
    RULE_table_or_subquery = 47
    RULE_result_column = 48
    RULE_join_operator = 49
    RULE_join_constraint = 50
    RULE_compound_operator = 51
    RULE_update_stmt = 52
    RULE_column_name_list = 53
    RULE_update_stmt_limited = 54
    RULE_qualified_table_name = 55
    RULE_vacuum_stmt = 56
    RULE_filter_clause = 57
    RULE_window_defn = 58
    RULE_over_clause = 59
    RULE_frame_spec = 60
    RULE_frame_clause = 61
    RULE_simple_function_invocation = 62
    RULE_aggregate_function_invocation = 63
    RULE_window_function_invocation = 64
    RULE_common_table_stmt = 65
    RULE_order_by_stmt = 66
    RULE_limit_stmt = 67
    RULE_ordering_term = 68
    RULE_asc_desc = 69
    RULE_frame_left = 70
    RULE_frame_right = 71
    RULE_frame_single = 72
    RULE_window_function = 73
    RULE_offset = 74
    RULE_default_value = 75
    RULE_partition_by = 76
    RULE_order_by_expr = 77
    RULE_order_by_expr_asc_desc = 78
    RULE_expr_asc_desc = 79
    RULE_initial_select = 80
    RULE_recursive_select = 81
    RULE_unary_operator = 82
    RULE_error_message = 83
    RULE_module_argument = 84
    RULE_column_alias = 85
    RULE_keyword = 86
    RULE_name = 87
    RULE_function_name = 88
    RULE_schema_name = 89
    RULE_table_name = 90
    RULE_table_or_index_name = 91
    RULE_new_table_name = 92
    RULE_column_name = 93
    RULE_collation_name = 94
    RULE_foreign_table = 95
    RULE_index_name = 96
    RULE_trigger_name = 97
    RULE_view_name = 98
    RULE_module_name = 99
    RULE_pragma_name = 100
    RULE_savepoint_name = 101
    RULE_table_alias = 102
    RULE_transaction_name = 103
    RULE_window_name = 104
    RULE_alias = 105
    RULE_filename = 106
    RULE_base_window_name = 107
    RULE_simple_func = 108
    RULE_aggregate_func = 109
    RULE_table_function_name = 110
    RULE_any_name = 111

    ruleNames =  [ "parse", "sql_stmt_list", "sql_stmt", "alter_table_stmt", 
                   "analyze_stmt", "attach_stmt", "begin_stmt", "commit_stmt", 
                   "rollback_stmt", "savepoint_stmt", "release_stmt", "create_index_stmt", 
                   "indexed_column", "create_table_stmt", "column_def", 
                   "type_name", "column_constraint", "signed_number", "table_constraint", 
                   "foreign_key_clause", "conflict_clause", "create_trigger_stmt", 
                   "create_view_stmt", "create_virtual_table_stmt", "with_clause", 
                   "cte_table_name", "recursive_cte", "common_table_expression", 
                   "delete_stmt", "delete_stmt_limited", "detach_stmt", 
                   "drop_stmt", "expr", "raise_function", "literal_value", 
                   "insert_stmt", "returning_clause", "upsert_clause", "pragma_stmt", 
                   "pragma_value", "reindex_stmt", "select_stmt", "join_clause", 
                   "select_core", "factored_select_stmt", "simple_select_stmt", 
                   "compound_select_stmt", "table_or_subquery", "result_column", 
                   "join_operator", "join_constraint", "compound_operator", 
                   "update_stmt", "column_name_list", "update_stmt_limited", 
                   "qualified_table_name", "vacuum_stmt", "filter_clause", 
                   "window_defn", "over_clause", "frame_spec", "frame_clause", 
                   "simple_function_invocation", "aggregate_function_invocation", 
                   "window_function_invocation", "common_table_stmt", "order_by_stmt", 
                   "limit_stmt", "ordering_term", "asc_desc", "frame_left", 
                   "frame_right", "frame_single", "window_function", "offset", 
                   "default_value", "partition_by", "order_by_expr", "order_by_expr_asc_desc", 
                   "expr_asc_desc", "initial_select", "recursive_select", 
                   "unary_operator", "error_message", "module_argument", 
                   "column_alias", "keyword", "name", "function_name", "schema_name", 
                   "table_name", "table_or_index_name", "new_table_name", 
                   "column_name", "collation_name", "foreign_table", "index_name", 
                   "trigger_name", "view_name", "module_name", "pragma_name", 
                   "savepoint_name", "table_alias", "transaction_name", 
                   "window_name", "alias", "filename", "base_window_name", 
                   "simple_func", "aggregate_func", "table_function_name", 
                   "any_name" ]

    EOF = Token.EOF
    SCOL=1
    DOT=2
    OPEN_PAR=3
    CLOSE_PAR=4
    COMMA=5
    ASSIGN=6
    STAR=7
    PLUS=8
    MINUS=9
    TILDE=10
    PIPE2=11
    DIV=12
    MOD=13
    LT2=14
    GT2=15
    AMP=16
    PIPE=17
    LT=18
    LT_EQ=19
    GT=20
    GT_EQ=21
    EQ=22
    NOT_EQ1=23
    NOT_EQ2=24
    ABORT_=25
    ACTION_=26
    ADD_=27
    AFTER_=28
    ALL_=29
    ALTER_=30
    ANALYZE_=31
    AND_=32
    AS_=33
    ASC_=34
    ATTACH_=35
    AUTOINCREMENT_=36
    BEFORE_=37
    BEGIN_=38
    BETWEEN_=39
    BY_=40
    CASCADE_=41
    CASE_=42
    CAST_=43
    CHECK_=44
    COLLATE_=45
    COLUMN_=46
    COMMIT_=47
    CONFLICT_=48
    CONSTRAINT_=49
    CREATE_=50
    CROSS_=51
    CURRENT_DATE_=52
    CURRENT_TIME_=53
    CURRENT_TIMESTAMP_=54
    DATABASE_=55
    DEFAULT_=56
    DEFERRABLE_=57
    DEFERRED_=58
    DELETE_=59
    DESC_=60
    DETACH_=61
    DISTINCT_=62
    DROP_=63
    EACH_=64
    ELSE_=65
    END_=66
    ESCAPE_=67
    EXCEPT_=68
    EXCLUSIVE_=69
    EXISTS_=70
    EXPLAIN_=71
    FAIL_=72
    FOR_=73
    FOREIGN_=74
    FROM_=75
    FULL_=76
    GLOB_=77
    GROUP_=78
    HAVING_=79
    IF_=80
    IGNORE_=81
    IMMEDIATE_=82
    IN_=83
    INDEX_=84
    INDEXED_=85
    INITIALLY_=86
    INNER_=87
    INSERT_=88
    INSTEAD_=89
    INTERSECT_=90
    INTO_=91
    IS_=92
    ISNULL_=93
    JOIN_=94
    KEY_=95
    LEFT_=96
    LIKE_=97
    LIMIT_=98
    MATCH_=99
    NATURAL_=100
    NO_=101
    NOT_=102
    NOTNULL_=103
    NULL_=104
    OF_=105
    OFFSET_=106
    ON_=107
    OR_=108
    ORDER_=109
    OUTER_=110
    PLAN_=111
    PRAGMA_=112
    PRIMARY_=113
    QUERY_=114
    RAISE_=115
    RECURSIVE_=116
    REFERENCES_=117
    REGEXP_=118
    REINDEX_=119
    RELEASE_=120
    RENAME_=121
    REPLACE_=122
    RESTRICT_=123
    RETURNING_=124
    RIGHT_=125
    ROLLBACK_=126
    ROW_=127
    ROWS_=128
    SAVEPOINT_=129
    SELECT_=130
    SET_=131
    TABLE_=132
    TEMP_=133
    TEMPORARY_=134
    THEN_=135
    TO_=136
    TRANSACTION_=137
    TRIGGER_=138
    UNION_=139
    UNIQUE_=140
    UPDATE_=141
    USING_=142
    VACUUM_=143
    VALUES_=144
    VIEW_=145
    VIRTUAL_=146
    WHEN_=147
    WHERE_=148
    WITH_=149
    WITHOUT_=150
    FIRST_VALUE_=151
    OVER_=152
    PARTITION_=153
    RANGE_=154
    PRECEDING_=155
    UNBOUNDED_=156
    CURRENT_=157
    FOLLOWING_=158
    CUME_DIST_=159
    DENSE_RANK_=160
    LAG_=161
    LAST_VALUE_=162
    LEAD_=163
    NTH_VALUE_=164
    NTILE_=165
    PERCENT_RANK_=166
    RANK_=167
    ROW_NUMBER_=168
    GENERATED_=169
    ALWAYS_=170
    STORED_=171
    TRUE_=172
    FALSE_=173
    WINDOW_=174
    NULLS_=175
    FIRST_=176
    LAST_=177
    FILTER_=178
    GROUPS_=179
    EXCLUDE_=180
    TIES_=181
    OTHERS_=182
    DO_=183
    NOTHING_=184
    IDENTIFIER=185
    NUMERIC_LITERAL=186
    BIND_PARAMETER=187
    STRING_LITERAL=188
    BLOB_LITERAL=189
    SINGLE_LINE_COMMENT=190
    MULTILINE_COMMENT=191
    SPACES=192
    UNEXPECTED_CHAR=193

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




    class ParseContext(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(SQLiteParser.EOF, 0)

        def sql_stmt_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Sql_stmt_listContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Sql_stmt_listContext,i)


        def getRuleIndex(self):
            return SQLiteParser.RULE_parse

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

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




    def parse(self):

        localctx = SQLiteParser.ParseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_parse)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 227
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.SCOL) | (1 << SQLiteParser.ALTER_) | (1 << SQLiteParser.ANALYZE_) | (1 << SQLiteParser.ATTACH_) | (1 << SQLiteParser.BEGIN_) | (1 << SQLiteParser.COMMIT_) | (1 << SQLiteParser.CREATE_) | (1 << SQLiteParser.DELETE_) | (1 << SQLiteParser.DETACH_) | (1 << SQLiteParser.DROP_))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (SQLiteParser.END_ - 66)) | (1 << (SQLiteParser.EXPLAIN_ - 66)) | (1 << (SQLiteParser.INSERT_ - 66)) | (1 << (SQLiteParser.PRAGMA_ - 66)) | (1 << (SQLiteParser.REINDEX_ - 66)) | (1 << (SQLiteParser.RELEASE_ - 66)) | (1 << (SQLiteParser.REPLACE_ - 66)) | (1 << (SQLiteParser.ROLLBACK_ - 66)) | (1 << (SQLiteParser.SAVEPOINT_ - 66)))) != 0) or ((((_la - 130)) & ~0x3f) == 0 and ((1 << (_la - 130)) & ((1 << (SQLiteParser.SELECT_ - 130)) | (1 << (SQLiteParser.UPDATE_ - 130)) | (1 << (SQLiteParser.VACUUM_ - 130)) | (1 << (SQLiteParser.VALUES_ - 130)) | (1 << (SQLiteParser.WITH_ - 130)))) != 0):
                self.state = 224
                self.sql_stmt_list()
                self.state = 229
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Sql_stmt_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sql_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Sql_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Sql_stmtContext,i)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_sql_stmt_list

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

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




    def sql_stmt_list(self):

        localctx = SQLiteParser.Sql_stmt_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_sql_stmt_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 235
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.SCOL:
                self.state = 232
                self.match(SQLiteParser.SCOL)
                self.state = 237
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 238
            self.sql_stmt()
            self.state = 247
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 240 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 239
                        self.match(SQLiteParser.SCOL)
                        self.state = 242 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==SQLiteParser.SCOL):
                            break

                    self.state = 244
                    self.sql_stmt() 
                self.state = 249
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

            self.state = 253
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,4,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 250
                    self.match(SQLiteParser.SCOL) 
                self.state = 255
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,4,self._ctx)

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


    class Sql_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def alter_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Alter_table_stmtContext,0)


        def analyze_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Analyze_stmtContext,0)


        def attach_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Attach_stmtContext,0)


        def begin_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Begin_stmtContext,0)


        def commit_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Commit_stmtContext,0)


        def create_index_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_index_stmtContext,0)


        def create_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_table_stmtContext,0)


        def create_trigger_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_trigger_stmtContext,0)


        def create_view_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_view_stmtContext,0)


        def create_virtual_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_virtual_table_stmtContext,0)


        def delete_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Delete_stmtContext,0)


        def delete_stmt_limited(self):
            return self.getTypedRuleContext(SQLiteParser.Delete_stmt_limitedContext,0)


        def detach_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Detach_stmtContext,0)


        def drop_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Drop_stmtContext,0)


        def insert_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Insert_stmtContext,0)


        def pragma_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Pragma_stmtContext,0)


        def reindex_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Reindex_stmtContext,0)


        def release_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Release_stmtContext,0)


        def rollback_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Rollback_stmtContext,0)


        def savepoint_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Savepoint_stmtContext,0)


        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def update_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Update_stmtContext,0)


        def update_stmt_limited(self):
            return self.getTypedRuleContext(SQLiteParser.Update_stmt_limitedContext,0)


        def vacuum_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Vacuum_stmtContext,0)


        def EXPLAIN_(self):
            return self.getToken(SQLiteParser.EXPLAIN_, 0)

        def QUERY_(self):
            return self.getToken(SQLiteParser.QUERY_, 0)

        def PLAN_(self):
            return self.getToken(SQLiteParser.PLAN_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_sql_stmt

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

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




    def sql_stmt(self):

        localctx = SQLiteParser.Sql_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_sql_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 261
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.EXPLAIN_:
                self.state = 256
                self.match(SQLiteParser.EXPLAIN_)
                self.state = 259
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.QUERY_:
                    self.state = 257
                    self.match(SQLiteParser.QUERY_)
                    self.state = 258
                    self.match(SQLiteParser.PLAN_)




            self.state = 287
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 263
                self.alter_table_stmt()
                pass

            elif la_ == 2:
                self.state = 264
                self.analyze_stmt()
                pass

            elif la_ == 3:
                self.state = 265
                self.attach_stmt()
                pass

            elif la_ == 4:
                self.state = 266
                self.begin_stmt()
                pass

            elif la_ == 5:
                self.state = 267
                self.commit_stmt()
                pass

            elif la_ == 6:
                self.state = 268
                self.create_index_stmt()
                pass

            elif la_ == 7:
                self.state = 269
                self.create_table_stmt()
                pass

            elif la_ == 8:
                self.state = 270
                self.create_trigger_stmt()
                pass

            elif la_ == 9:
                self.state = 271
                self.create_view_stmt()
                pass

            elif la_ == 10:
                self.state = 272
                self.create_virtual_table_stmt()
                pass

            elif la_ == 11:
                self.state = 273
                self.delete_stmt()
                pass

            elif la_ == 12:
                self.state = 274
                self.delete_stmt_limited()
                pass

            elif la_ == 13:
                self.state = 275
                self.detach_stmt()
                pass

            elif la_ == 14:
                self.state = 276
                self.drop_stmt()
                pass

            elif la_ == 15:
                self.state = 277
                self.insert_stmt()
                pass

            elif la_ == 16:
                self.state = 278
                self.pragma_stmt()
                pass

            elif la_ == 17:
                self.state = 279
                self.reindex_stmt()
                pass

            elif la_ == 18:
                self.state = 280
                self.release_stmt()
                pass

            elif la_ == 19:
                self.state = 281
                self.rollback_stmt()
                pass

            elif la_ == 20:
                self.state = 282
                self.savepoint_stmt()
                pass

            elif la_ == 21:
                self.state = 283
                self.select_stmt()
                pass

            elif la_ == 22:
                self.state = 284
                self.update_stmt()
                pass

            elif la_ == 23:
                self.state = 285
                self.update_stmt_limited()
                pass

            elif la_ == 24:
                self.state = 286
                self.vacuum_stmt()
                pass


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


    class Alter_table_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_(self):
            return self.getToken(SQLiteParser.ALTER_, 0)

        def TABLE_(self):
            return self.getToken(SQLiteParser.TABLE_, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def RENAME_(self):
            return self.getToken(SQLiteParser.RENAME_, 0)

        def ADD_(self):
            return self.getToken(SQLiteParser.ADD_, 0)

        def column_def(self):
            return self.getTypedRuleContext(SQLiteParser.Column_defContext,0)


        def DROP_(self):
            return self.getToken(SQLiteParser.DROP_, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def TO_(self):
            return self.getToken(SQLiteParser.TO_, 0)

        def new_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.New_table_nameContext,0)


        def COLUMN_(self):
            return self.getToken(SQLiteParser.COLUMN_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_alter_table_stmt

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

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




    def alter_table_stmt(self):

        localctx = SQLiteParser.Alter_table_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_alter_table_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 289
            self.match(SQLiteParser.ALTER_)
            self.state = 290
            self.match(SQLiteParser.TABLE_)
            self.state = 294
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 291
                self.schema_name()
                self.state = 292
                self.match(SQLiteParser.DOT)


            self.state = 296
            self.table_name()
            self.state = 319
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.RENAME_]:
                self.state = 297
                self.match(SQLiteParser.RENAME_)
                self.state = 307
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
                if la_ == 1:
                    self.state = 298
                    self.match(SQLiteParser.TO_)
                    self.state = 299
                    self.new_table_name()
                    pass

                elif la_ == 2:
                    self.state = 301
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
                    if la_ == 1:
                        self.state = 300
                        self.match(SQLiteParser.COLUMN_)


                    self.state = 303
                    localctx.old_column_name = self.column_name()
                    self.state = 304
                    self.match(SQLiteParser.TO_)
                    self.state = 305
                    localctx.new_column_name = self.column_name()
                    pass


                pass
            elif token in [SQLiteParser.ADD_]:
                self.state = 309
                self.match(SQLiteParser.ADD_)
                self.state = 311
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
                if la_ == 1:
                    self.state = 310
                    self.match(SQLiteParser.COLUMN_)


                self.state = 313
                self.column_def()
                pass
            elif token in [SQLiteParser.DROP_]:
                self.state = 314
                self.match(SQLiteParser.DROP_)
                self.state = 316
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
                if la_ == 1:
                    self.state = 315
                    self.match(SQLiteParser.COLUMN_)


                self.state = 318
                self.column_name()
                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 Analyze_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ANALYZE_(self):
            return self.getToken(SQLiteParser.ANALYZE_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


        def table_or_index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_or_index_nameContext,0)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_analyze_stmt

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

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




    def analyze_stmt(self):

        localctx = SQLiteParser.Analyze_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_analyze_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 321
            self.match(SQLiteParser.ANALYZE_)
            self.state = 329
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.state = 322
                self.schema_name()

            elif la_ == 2:
                self.state = 326
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
                if la_ == 1:
                    self.state = 323
                    self.schema_name()
                    self.state = 324
                    self.match(SQLiteParser.DOT)


                self.state = 328
                self.table_or_index_name()


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


    class Attach_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ATTACH_(self):
            return self.getToken(SQLiteParser.ATTACH_, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


        def DATABASE_(self):
            return self.getToken(SQLiteParser.DATABASE_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_attach_stmt

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

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




    def attach_stmt(self):

        localctx = SQLiteParser.Attach_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_attach_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 331
            self.match(SQLiteParser.ATTACH_)
            self.state = 333
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.state = 332
                self.match(SQLiteParser.DATABASE_)


            self.state = 335
            self.expr(0)
            self.state = 336
            self.match(SQLiteParser.AS_)
            self.state = 337
            self.schema_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Begin_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BEGIN_(self):
            return self.getToken(SQLiteParser.BEGIN_, 0)

        def TRANSACTION_(self):
            return self.getToken(SQLiteParser.TRANSACTION_, 0)

        def DEFERRED_(self):
            return self.getToken(SQLiteParser.DEFERRED_, 0)

        def IMMEDIATE_(self):
            return self.getToken(SQLiteParser.IMMEDIATE_, 0)

        def EXCLUSIVE_(self):
            return self.getToken(SQLiteParser.EXCLUSIVE_, 0)

        def transaction_name(self):
            return self.getTypedRuleContext(SQLiteParser.Transaction_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_begin_stmt

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

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




    def begin_stmt(self):

        localctx = SQLiteParser.Begin_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_begin_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            self.match(SQLiteParser.BEGIN_)
            self.state = 341
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & ((1 << (SQLiteParser.DEFERRED_ - 58)) | (1 << (SQLiteParser.EXCLUSIVE_ - 58)) | (1 << (SQLiteParser.IMMEDIATE_ - 58)))) != 0):
                self.state = 340
                _la = self._input.LA(1)
                if not(((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & ((1 << (SQLiteParser.DEFERRED_ - 58)) | (1 << (SQLiteParser.EXCLUSIVE_ - 58)) | (1 << (SQLiteParser.IMMEDIATE_ - 58)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 347
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.TRANSACTION_:
                self.state = 343
                self.match(SQLiteParser.TRANSACTION_)
                self.state = 345
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                if la_ == 1:
                    self.state = 344
                    self.transaction_name()




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


    class Commit_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def COMMIT_(self):
            return self.getToken(SQLiteParser.COMMIT_, 0)

        def END_(self):
            return self.getToken(SQLiteParser.END_, 0)

        def TRANSACTION_(self):
            return self.getToken(SQLiteParser.TRANSACTION_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_commit_stmt

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

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




    def commit_stmt(self):

        localctx = SQLiteParser.Commit_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_commit_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 349
            _la = self._input.LA(1)
            if not(_la==SQLiteParser.COMMIT_ or _la==SQLiteParser.END_):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 351
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.TRANSACTION_:
                self.state = 350
                self.match(SQLiteParser.TRANSACTION_)


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


    class Rollback_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ROLLBACK_(self):
            return self.getToken(SQLiteParser.ROLLBACK_, 0)

        def TRANSACTION_(self):
            return self.getToken(SQLiteParser.TRANSACTION_, 0)

        def TO_(self):
            return self.getToken(SQLiteParser.TO_, 0)

        def savepoint_name(self):
            return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0)


        def SAVEPOINT_(self):
            return self.getToken(SQLiteParser.SAVEPOINT_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_rollback_stmt

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

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




    def rollback_stmt(self):

        localctx = SQLiteParser.Rollback_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_rollback_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 353
            self.match(SQLiteParser.ROLLBACK_)
            self.state = 355
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.TRANSACTION_:
                self.state = 354
                self.match(SQLiteParser.TRANSACTION_)


            self.state = 362
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.TO_:
                self.state = 357
                self.match(SQLiteParser.TO_)
                self.state = 359
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
                if la_ == 1:
                    self.state = 358
                    self.match(SQLiteParser.SAVEPOINT_)


                self.state = 361
                self.savepoint_name()


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


    class Savepoint_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SAVEPOINT_(self):
            return self.getToken(SQLiteParser.SAVEPOINT_, 0)

        def savepoint_name(self):
            return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_savepoint_stmt

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

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




    def savepoint_stmt(self):

        localctx = SQLiteParser.Savepoint_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_savepoint_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 364
            self.match(SQLiteParser.SAVEPOINT_)
            self.state = 365
            self.savepoint_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Release_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RELEASE_(self):
            return self.getToken(SQLiteParser.RELEASE_, 0)

        def savepoint_name(self):
            return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0)


        def SAVEPOINT_(self):
            return self.getToken(SQLiteParser.SAVEPOINT_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_release_stmt

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

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




    def release_stmt(self):

        localctx = SQLiteParser.Release_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_release_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 367
            self.match(SQLiteParser.RELEASE_)
            self.state = 369
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.state = 368
                self.match(SQLiteParser.SAVEPOINT_)


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


    class Create_index_stmtContext(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(SQLiteParser.CREATE_, 0)

        def INDEX_(self):
            return self.getToken(SQLiteParser.INDEX_, 0)

        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def ON_(self):
            return self.getToken(SQLiteParser.ON_, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def indexed_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Indexed_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Indexed_columnContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def UNIQUE_(self):
            return self.getToken(SQLiteParser.UNIQUE_, 0)

        def IF_(self):
            return self.getToken(SQLiteParser.IF_, 0)

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def EXISTS_(self):
            return self.getToken(SQLiteParser.EXISTS_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

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

        def WHERE_(self):
            return self.getToken(SQLiteParser.WHERE_, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_create_index_stmt

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

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




    def create_index_stmt(self):

        localctx = SQLiteParser.Create_index_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_create_index_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 373
            self.match(SQLiteParser.CREATE_)
            self.state = 375
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.UNIQUE_:
                self.state = 374
                self.match(SQLiteParser.UNIQUE_)


            self.state = 377
            self.match(SQLiteParser.INDEX_)
            self.state = 381
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.state = 378
                self.match(SQLiteParser.IF_)
                self.state = 379
                self.match(SQLiteParser.NOT_)
                self.state = 380
                self.match(SQLiteParser.EXISTS_)


            self.state = 386
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.state = 383
                self.schema_name()
                self.state = 384
                self.match(SQLiteParser.DOT)


            self.state = 388
            self.index_name()
            self.state = 389
            self.match(SQLiteParser.ON_)
            self.state = 390
            self.table_name()
            self.state = 391
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 392
            self.indexed_column()
            self.state = 397
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 393
                self.match(SQLiteParser.COMMA)
                self.state = 394
                self.indexed_column()
                self.state = 399
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 400
            self.match(SQLiteParser.CLOSE_PAR)
            self.state = 403
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WHERE_:
                self.state = 401
                self.match(SQLiteParser.WHERE_)
                self.state = 402
                self.expr(0)


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


    class Indexed_columnContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def column_name(self):
            return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0)


        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def COLLATE_(self):
            return self.getToken(SQLiteParser.COLLATE_, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def asc_desc(self):
            return self.getTypedRuleContext(SQLiteParser.Asc_descContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_indexed_column

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

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




    def indexed_column(self):

        localctx = SQLiteParser.Indexed_columnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_indexed_column)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 407
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.state = 405
                self.column_name()
                pass

            elif la_ == 2:
                self.state = 406
                self.expr(0)
                pass


            self.state = 411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.COLLATE_:
                self.state = 409
                self.match(SQLiteParser.COLLATE_)
                self.state = 410
                self.collation_name()


            self.state = 414
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_:
                self.state = 413
                self.asc_desc()


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


    class Create_table_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CREATE_(self):
            return self.getToken(SQLiteParser.CREATE_, 0)

        def TABLE_(self):
            return self.getToken(SQLiteParser.TABLE_, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_def(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_defContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_defContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def IF_(self):
            return self.getToken(SQLiteParser.IF_, 0)

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def EXISTS_(self):
            return self.getToken(SQLiteParser.EXISTS_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def TEMP_(self):
            return self.getToken(SQLiteParser.TEMP_, 0)

        def TEMPORARY_(self):
            return self.getToken(SQLiteParser.TEMPORARY_, 0)

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

        def table_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_constraintContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_constraintContext,i)


        def WITHOUT_(self):
            return self.getToken(SQLiteParser.WITHOUT_, 0)

        def IDENTIFIER(self):
            return self.getToken(SQLiteParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_create_table_stmt

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

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




    def create_table_stmt(self):

        localctx = SQLiteParser.Create_table_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_create_table_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 416
            self.match(SQLiteParser.CREATE_)
            self.state = 418
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_:
                self.state = 417
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 420
            self.match(SQLiteParser.TABLE_)
            self.state = 424
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
            if la_ == 1:
                self.state = 421
                self.match(SQLiteParser.IF_)
                self.state = 422
                self.match(SQLiteParser.NOT_)
                self.state = 423
                self.match(SQLiteParser.EXISTS_)


            self.state = 429
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.state = 426
                self.schema_name()
                self.state = 427
                self.match(SQLiteParser.DOT)


            self.state = 431
            self.table_name()
            self.state = 455
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.OPEN_PAR]:
                self.state = 432
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 433
                self.column_def()
                self.state = 438
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 434
                        self.match(SQLiteParser.COMMA)
                        self.state = 435
                        self.column_def() 
                    self.state = 440
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

                self.state = 445
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 441
                    self.match(SQLiteParser.COMMA)
                    self.state = 442
                    self.table_constraint()
                    self.state = 447
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 448
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 451
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.WITHOUT_:
                    self.state = 449
                    self.match(SQLiteParser.WITHOUT_)
                    self.state = 450
                    localctx.row_ROW_ID = self.match(SQLiteParser.IDENTIFIER)


                pass
            elif token in [SQLiteParser.AS_]:
                self.state = 453
                self.match(SQLiteParser.AS_)
                self.state = 454
                self.select_stmt()
                pass
            else:
                raise NoViableAltException(self)

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


    class Column_defContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def column_name(self):
            return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0)


        def type_name(self):
            return self.getTypedRuleContext(SQLiteParser.Type_nameContext,0)


        def column_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_constraintContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_constraintContext,i)


        def getRuleIndex(self):
            return SQLiteParser.RULE_column_def

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

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




    def column_def(self):

        localctx = SQLiteParser.Column_defContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_column_def)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 457
            self.column_name()
            self.state = 459
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
            if la_ == 1:
                self.state = 458
                self.type_name()


            self.state = 464
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.AS_) | (1 << SQLiteParser.CHECK_) | (1 << SQLiteParser.COLLATE_) | (1 << SQLiteParser.CONSTRAINT_) | (1 << SQLiteParser.DEFAULT_))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SQLiteParser.NOT_ - 102)) | (1 << (SQLiteParser.PRIMARY_ - 102)) | (1 << (SQLiteParser.REFERENCES_ - 102)) | (1 << (SQLiteParser.UNIQUE_ - 102)))) != 0) or _la==SQLiteParser.GENERATED_:
                self.state = 461
                self.column_constraint()
                self.state = 466
                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 Type_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.NameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.NameContext,i)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def signed_number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Signed_numberContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_type_name

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

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




    def type_name(self):

        localctx = SQLiteParser.Type_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_type_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 468 
            self._errHandler.sync(self)
            _alt = 1+1
            while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1+1:
                    self.state = 467
                    self.name()

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

            self.state = 482
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.state = 472
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 473
                self.signed_number()
                self.state = 474
                self.match(SQLiteParser.CLOSE_PAR)

            elif la_ == 2:
                self.state = 476
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 477
                self.signed_number()
                self.state = 478
                self.match(SQLiteParser.COMMA)
                self.state = 479
                self.signed_number()
                self.state = 480
                self.match(SQLiteParser.CLOSE_PAR)


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


    class Column_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHECK_(self):
            return self.getToken(SQLiteParser.CHECK_, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def DEFAULT_(self):
            return self.getToken(SQLiteParser.DEFAULT_, 0)

        def COLLATE_(self):
            return self.getToken(SQLiteParser.COLLATE_, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def foreign_key_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Foreign_key_clauseContext,0)


        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def CONSTRAINT_(self):
            return self.getToken(SQLiteParser.CONSTRAINT_, 0)

        def name(self):
            return self.getTypedRuleContext(SQLiteParser.NameContext,0)


        def PRIMARY_(self):
            return self.getToken(SQLiteParser.PRIMARY_, 0)

        def KEY_(self):
            return self.getToken(SQLiteParser.KEY_, 0)

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def NULL_(self):
            return self.getToken(SQLiteParser.NULL_, 0)

        def UNIQUE_(self):
            return self.getToken(SQLiteParser.UNIQUE_, 0)

        def signed_number(self):
            return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0)


        def literal_value(self):
            return self.getTypedRuleContext(SQLiteParser.Literal_valueContext,0)


        def conflict_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Conflict_clauseContext,0)


        def GENERATED_(self):
            return self.getToken(SQLiteParser.GENERATED_, 0)

        def ALWAYS_(self):
            return self.getToken(SQLiteParser.ALWAYS_, 0)

        def STORED_(self):
            return self.getToken(SQLiteParser.STORED_, 0)

        def VIRTUAL_(self):
            return self.getToken(SQLiteParser.VIRTUAL_, 0)

        def asc_desc(self):
            return self.getTypedRuleContext(SQLiteParser.Asc_descContext,0)


        def AUTOINCREMENT_(self):
            return self.getToken(SQLiteParser.AUTOINCREMENT_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_column_constraint

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

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




    def column_constraint(self):

        localctx = SQLiteParser.Column_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_column_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 486
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.CONSTRAINT_:
                self.state = 484
                self.match(SQLiteParser.CONSTRAINT_)
                self.state = 485
                self.name()


            self.state = 535
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.PRIMARY_]:
                self.state = 488
                self.match(SQLiteParser.PRIMARY_)
                self.state = 489
                self.match(SQLiteParser.KEY_)
                self.state = 491
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_:
                    self.state = 490
                    self.asc_desc()


                self.state = 494
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ON_:
                    self.state = 493
                    self.conflict_clause()


                self.state = 497
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.AUTOINCREMENT_:
                    self.state = 496
                    self.match(SQLiteParser.AUTOINCREMENT_)


                pass
            elif token in [SQLiteParser.NOT_, SQLiteParser.UNIQUE_]:
                self.state = 502
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.NOT_]:
                    self.state = 499
                    self.match(SQLiteParser.NOT_)
                    self.state = 500
                    self.match(SQLiteParser.NULL_)
                    pass
                elif token in [SQLiteParser.UNIQUE_]:
                    self.state = 501
                    self.match(SQLiteParser.UNIQUE_)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 505
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ON_:
                    self.state = 504
                    self.conflict_clause()


                pass
            elif token in [SQLiteParser.CHECK_]:
                self.state = 507
                self.match(SQLiteParser.CHECK_)
                self.state = 508
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 509
                self.expr(0)
                self.state = 510
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.DEFAULT_]:
                self.state = 512
                self.match(SQLiteParser.DEFAULT_)
                self.state = 519
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
                if la_ == 1:
                    self.state = 513
                    self.signed_number()
                    pass

                elif la_ == 2:
                    self.state = 514
                    self.literal_value()
                    pass

                elif la_ == 3:
                    self.state = 515
                    self.match(SQLiteParser.OPEN_PAR)
                    self.state = 516
                    self.expr(0)
                    self.state = 517
                    self.match(SQLiteParser.CLOSE_PAR)
                    pass


                pass
            elif token in [SQLiteParser.COLLATE_]:
                self.state = 521
                self.match(SQLiteParser.COLLATE_)
                self.state = 522
                self.collation_name()
                pass
            elif token in [SQLiteParser.REFERENCES_]:
                self.state = 523
                self.foreign_key_clause()
                pass
            elif token in [SQLiteParser.AS_, SQLiteParser.GENERATED_]:
                self.state = 526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.GENERATED_:
                    self.state = 524
                    self.match(SQLiteParser.GENERATED_)
                    self.state = 525
                    self.match(SQLiteParser.ALWAYS_)


                self.state = 528
                self.match(SQLiteParser.AS_)
                self.state = 529
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 530
                self.expr(0)
                self.state = 531
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 533
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.VIRTUAL_ or _la==SQLiteParser.STORED_:
                    self.state = 532
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.VIRTUAL_ or _la==SQLiteParser.STORED_):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                pass
            else:
                raise NoViableAltException(self)

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


    class Signed_numberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NUMERIC_LITERAL(self):
            return self.getToken(SQLiteParser.NUMERIC_LITERAL, 0)

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

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_signed_number

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

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




    def signed_number(self):

        localctx = SQLiteParser.Signed_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_signed_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 538
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS:
                self.state = 537
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 540
            self.match(SQLiteParser.NUMERIC_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def indexed_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Indexed_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Indexed_columnContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def CHECK_(self):
            return self.getToken(SQLiteParser.CHECK_, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def FOREIGN_(self):
            return self.getToken(SQLiteParser.FOREIGN_, 0)

        def KEY_(self):
            return self.getToken(SQLiteParser.KEY_, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def foreign_key_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Foreign_key_clauseContext,0)


        def CONSTRAINT_(self):
            return self.getToken(SQLiteParser.CONSTRAINT_, 0)

        def name(self):
            return self.getTypedRuleContext(SQLiteParser.NameContext,0)


        def PRIMARY_(self):
            return self.getToken(SQLiteParser.PRIMARY_, 0)

        def UNIQUE_(self):
            return self.getToken(SQLiteParser.UNIQUE_, 0)

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

        def conflict_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Conflict_clauseContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_constraint

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

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




    def table_constraint(self):

        localctx = SQLiteParser.Table_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_table_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 544
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.CONSTRAINT_:
                self.state = 542
                self.match(SQLiteParser.CONSTRAINT_)
                self.state = 543
                self.name()


            self.state = 583
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.PRIMARY_, SQLiteParser.UNIQUE_]:
                self.state = 549
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.PRIMARY_]:
                    self.state = 546
                    self.match(SQLiteParser.PRIMARY_)
                    self.state = 547
                    self.match(SQLiteParser.KEY_)
                    pass
                elif token in [SQLiteParser.UNIQUE_]:
                    self.state = 548
                    self.match(SQLiteParser.UNIQUE_)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 551
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 552
                self.indexed_column()
                self.state = 557
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 553
                    self.match(SQLiteParser.COMMA)
                    self.state = 554
                    self.indexed_column()
                    self.state = 559
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 560
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 562
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ON_:
                    self.state = 561
                    self.conflict_clause()


                pass
            elif token in [SQLiteParser.CHECK_]:
                self.state = 564
                self.match(SQLiteParser.CHECK_)
                self.state = 565
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 566
                self.expr(0)
                self.state = 567
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.FOREIGN_]:
                self.state = 569
                self.match(SQLiteParser.FOREIGN_)
                self.state = 570
                self.match(SQLiteParser.KEY_)
                self.state = 571
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 572
                self.column_name()
                self.state = 577
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 573
                    self.match(SQLiteParser.COMMA)
                    self.state = 574
                    self.column_name()
                    self.state = 579
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 580
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 581
                self.foreign_key_clause()
                pass
            else:
                raise NoViableAltException(self)

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


    class Foreign_key_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REFERENCES_(self):
            return self.getToken(SQLiteParser.REFERENCES_, 0)

        def foreign_table(self):
            return self.getTypedRuleContext(SQLiteParser.Foreign_tableContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

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

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.NameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.NameContext,i)


        def DEFERRABLE_(self):
            return self.getToken(SQLiteParser.DEFERRABLE_, 0)

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

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

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

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

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

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

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

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

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

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

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def INITIALLY_(self):
            return self.getToken(SQLiteParser.INITIALLY_, 0)

        def DEFERRED_(self):
            return self.getToken(SQLiteParser.DEFERRED_, 0)

        def IMMEDIATE_(self):
            return self.getToken(SQLiteParser.IMMEDIATE_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_foreign_key_clause

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

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




    def foreign_key_clause(self):

        localctx = SQLiteParser.Foreign_key_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_foreign_key_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 585
            self.match(SQLiteParser.REFERENCES_)
            self.state = 586
            self.foreign_table()
            self.state = 598
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 587
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 588
                self.column_name()
                self.state = 593
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 589
                    self.match(SQLiteParser.COMMA)
                    self.state = 590
                    self.column_name()
                    self.state = 595
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 596
                self.match(SQLiteParser.CLOSE_PAR)


            self.state = 614
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.MATCH_ or _la==SQLiteParser.ON_:
                self.state = 612
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.ON_]:
                    self.state = 600
                    self.match(SQLiteParser.ON_)
                    self.state = 601
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.DELETE_ or _la==SQLiteParser.UPDATE_):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 608
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SQLiteParser.SET_]:
                        self.state = 602
                        self.match(SQLiteParser.SET_)
                        self.state = 603
                        _la = self._input.LA(1)
                        if not(_la==SQLiteParser.DEFAULT_ or _la==SQLiteParser.NULL_):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass
                    elif token in [SQLiteParser.CASCADE_]:
                        self.state = 604
                        self.match(SQLiteParser.CASCADE_)
                        pass
                    elif token in [SQLiteParser.RESTRICT_]:
                        self.state = 605
                        self.match(SQLiteParser.RESTRICT_)
                        pass
                    elif token in [SQLiteParser.NO_]:
                        self.state = 606
                        self.match(SQLiteParser.NO_)
                        self.state = 607
                        self.match(SQLiteParser.ACTION_)
                        pass
                    else:
                        raise NoViableAltException(self)

                    pass
                elif token in [SQLiteParser.MATCH_]:
                    self.state = 610
                    self.match(SQLiteParser.MATCH_)
                    self.state = 611
                    self.name()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 625
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
            if la_ == 1:
                self.state = 618
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.NOT_:
                    self.state = 617
                    self.match(SQLiteParser.NOT_)


                self.state = 620
                self.match(SQLiteParser.DEFERRABLE_)
                self.state = 623
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.INITIALLY_:
                    self.state = 621
                    self.match(SQLiteParser.INITIALLY_)
                    self.state = 622
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.DEFERRED_ or _la==SQLiteParser.IMMEDIATE_):
                        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 Conflict_clauseContext(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(SQLiteParser.ON_, 0)

        def CONFLICT_(self):
            return self.getToken(SQLiteParser.CONFLICT_, 0)

        def ROLLBACK_(self):
            return self.getToken(SQLiteParser.ROLLBACK_, 0)

        def ABORT_(self):
            return self.getToken(SQLiteParser.ABORT_, 0)

        def FAIL_(self):
            return self.getToken(SQLiteParser.FAIL_, 0)

        def IGNORE_(self):
            return self.getToken(SQLiteParser.IGNORE_, 0)

        def REPLACE_(self):
            return self.getToken(SQLiteParser.REPLACE_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_conflict_clause

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

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




    def conflict_clause(self):

        localctx = SQLiteParser.Conflict_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_conflict_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 627
            self.match(SQLiteParser.ON_)
            self.state = 628
            self.match(SQLiteParser.CONFLICT_)
            self.state = 629
            _la = self._input.LA(1)
            if not(_la==SQLiteParser.ABORT_ or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.FAIL_ - 72)) | (1 << (SQLiteParser.IGNORE_ - 72)) | (1 << (SQLiteParser.REPLACE_ - 72)) | (1 << (SQLiteParser.ROLLBACK_ - 72)))) != 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 Create_trigger_stmtContext(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(SQLiteParser.CREATE_, 0)

        def TRIGGER_(self):
            return self.getToken(SQLiteParser.TRIGGER_, 0)

        def trigger_name(self):
            return self.getTypedRuleContext(SQLiteParser.Trigger_nameContext,0)


        def ON_(self):
            return self.getToken(SQLiteParser.ON_, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def BEGIN_(self):
            return self.getToken(SQLiteParser.BEGIN_, 0)

        def END_(self):
            return self.getToken(SQLiteParser.END_, 0)

        def DELETE_(self):
            return self.getToken(SQLiteParser.DELETE_, 0)

        def INSERT_(self):
            return self.getToken(SQLiteParser.INSERT_, 0)

        def UPDATE_(self):
            return self.getToken(SQLiteParser.UPDATE_, 0)

        def IF_(self):
            return self.getToken(SQLiteParser.IF_, 0)

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def EXISTS_(self):
            return self.getToken(SQLiteParser.EXISTS_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def BEFORE_(self):
            return self.getToken(SQLiteParser.BEFORE_, 0)

        def AFTER_(self):
            return self.getToken(SQLiteParser.AFTER_, 0)

        def INSTEAD_(self):
            return self.getToken(SQLiteParser.INSTEAD_, 0)

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

        def FOR_(self):
            return self.getToken(SQLiteParser.FOR_, 0)

        def EACH_(self):
            return self.getToken(SQLiteParser.EACH_, 0)

        def ROW_(self):
            return self.getToken(SQLiteParser.ROW_, 0)

        def WHEN_(self):
            return self.getToken(SQLiteParser.WHEN_, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


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

        def TEMP_(self):
            return self.getToken(SQLiteParser.TEMP_, 0)

        def TEMPORARY_(self):
            return self.getToken(SQLiteParser.TEMPORARY_, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def update_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Update_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Update_stmtContext,i)


        def insert_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Insert_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Insert_stmtContext,i)


        def delete_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Delete_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Delete_stmtContext,i)


        def select_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,i)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_create_trigger_stmt

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

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




    def create_trigger_stmt(self):

        localctx = SQLiteParser.Create_trigger_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_create_trigger_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 631
            self.match(SQLiteParser.CREATE_)
            self.state = 633
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_:
                self.state = 632
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 635
            self.match(SQLiteParser.TRIGGER_)
            self.state = 639
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
            if la_ == 1:
                self.state = 636
                self.match(SQLiteParser.IF_)
                self.state = 637
                self.match(SQLiteParser.NOT_)
                self.state = 638
                self.match(SQLiteParser.EXISTS_)


            self.state = 644
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 641
                self.schema_name()
                self.state = 642
                self.match(SQLiteParser.DOT)


            self.state = 646
            self.trigger_name()
            self.state = 651
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.BEFORE_]:
                self.state = 647
                self.match(SQLiteParser.BEFORE_)
                pass
            elif token in [SQLiteParser.AFTER_]:
                self.state = 648
                self.match(SQLiteParser.AFTER_)
                pass
            elif token in [SQLiteParser.INSTEAD_]:
                self.state = 649
                self.match(SQLiteParser.INSTEAD_)
                self.state = 650
                self.match(SQLiteParser.OF_)
                pass
            elif token in [SQLiteParser.DELETE_, SQLiteParser.INSERT_, SQLiteParser.UPDATE_]:
                pass
            else:
                pass
            self.state = 667
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.DELETE_]:
                self.state = 653
                self.match(SQLiteParser.DELETE_)
                pass
            elif token in [SQLiteParser.INSERT_]:
                self.state = 654
                self.match(SQLiteParser.INSERT_)
                pass
            elif token in [SQLiteParser.UPDATE_]:
                self.state = 655
                self.match(SQLiteParser.UPDATE_)
                self.state = 665
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.OF_:
                    self.state = 656
                    self.match(SQLiteParser.OF_)
                    self.state = 657
                    self.column_name()
                    self.state = 662
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 658
                        self.match(SQLiteParser.COMMA)
                        self.state = 659
                        self.column_name()
                        self.state = 664
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                pass
            else:
                raise NoViableAltException(self)

            self.state = 669
            self.match(SQLiteParser.ON_)
            self.state = 670
            self.table_name()
            self.state = 674
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.FOR_:
                self.state = 671
                self.match(SQLiteParser.FOR_)
                self.state = 672
                self.match(SQLiteParser.EACH_)
                self.state = 673
                self.match(SQLiteParser.ROW_)


            self.state = 678
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WHEN_:
                self.state = 676
                self.match(SQLiteParser.WHEN_)
                self.state = 677
                self.expr(0)


            self.state = 680
            self.match(SQLiteParser.BEGIN_)
            self.state = 689 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 685
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
                if la_ == 1:
                    self.state = 681
                    self.update_stmt()
                    pass

                elif la_ == 2:
                    self.state = 682
                    self.insert_stmt()
                    pass

                elif la_ == 3:
                    self.state = 683
                    self.delete_stmt()
                    pass

                elif la_ == 4:
                    self.state = 684
                    self.select_stmt()
                    pass


                self.state = 687
                self.match(SQLiteParser.SCOL)
                self.state = 691 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SQLiteParser.DELETE_ or ((((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & ((1 << (SQLiteParser.INSERT_ - 88)) | (1 << (SQLiteParser.REPLACE_ - 88)) | (1 << (SQLiteParser.SELECT_ - 88)) | (1 << (SQLiteParser.UPDATE_ - 88)) | (1 << (SQLiteParser.VALUES_ - 88)) | (1 << (SQLiteParser.WITH_ - 88)))) != 0)):
                    break

            self.state = 693
            self.match(SQLiteParser.END_)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Create_view_stmtContext(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(SQLiteParser.CREATE_, 0)

        def VIEW_(self):
            return self.getToken(SQLiteParser.VIEW_, 0)

        def view_name(self):
            return self.getTypedRuleContext(SQLiteParser.View_nameContext,0)


        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def IF_(self):
            return self.getToken(SQLiteParser.IF_, 0)

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def EXISTS_(self):
            return self.getToken(SQLiteParser.EXISTS_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def TEMP_(self):
            return self.getToken(SQLiteParser.TEMP_, 0)

        def TEMPORARY_(self):
            return self.getToken(SQLiteParser.TEMPORARY_, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_create_view_stmt

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

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




    def create_view_stmt(self):

        localctx = SQLiteParser.Create_view_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_create_view_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 695
            self.match(SQLiteParser.CREATE_)
            self.state = 697
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_:
                self.state = 696
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 699
            self.match(SQLiteParser.VIEW_)
            self.state = 703
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
            if la_ == 1:
                self.state = 700
                self.match(SQLiteParser.IF_)
                self.state = 701
                self.match(SQLiteParser.NOT_)
                self.state = 702
                self.match(SQLiteParser.EXISTS_)


            self.state = 708
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.state = 705
                self.schema_name()
                self.state = 706
                self.match(SQLiteParser.DOT)


            self.state = 710
            self.view_name()
            self.state = 722
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 711
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 712
                self.column_name()
                self.state = 717
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 713
                    self.match(SQLiteParser.COMMA)
                    self.state = 714
                    self.column_name()
                    self.state = 719
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 720
                self.match(SQLiteParser.CLOSE_PAR)


            self.state = 724
            self.match(SQLiteParser.AS_)
            self.state = 725
            self.select_stmt()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Create_virtual_table_stmtContext(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(SQLiteParser.CREATE_, 0)

        def VIRTUAL_(self):
            return self.getToken(SQLiteParser.VIRTUAL_, 0)

        def TABLE_(self):
            return self.getToken(SQLiteParser.TABLE_, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def USING_(self):
            return self.getToken(SQLiteParser.USING_, 0)

        def module_name(self):
            return self.getTypedRuleContext(SQLiteParser.Module_nameContext,0)


        def IF_(self):
            return self.getToken(SQLiteParser.IF_, 0)

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def EXISTS_(self):
            return self.getToken(SQLiteParser.EXISTS_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def module_argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Module_argumentContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Module_argumentContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_create_virtual_table_stmt

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

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




    def create_virtual_table_stmt(self):

        localctx = SQLiteParser.Create_virtual_table_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_create_virtual_table_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 727
            self.match(SQLiteParser.CREATE_)
            self.state = 728
            self.match(SQLiteParser.VIRTUAL_)
            self.state = 729
            self.match(SQLiteParser.TABLE_)
            self.state = 733
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.state = 730
                self.match(SQLiteParser.IF_)
                self.state = 731
                self.match(SQLiteParser.NOT_)
                self.state = 732
                self.match(SQLiteParser.EXISTS_)


            self.state = 738
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
            if la_ == 1:
                self.state = 735
                self.schema_name()
                self.state = 736
                self.match(SQLiteParser.DOT)


            self.state = 740
            self.table_name()
            self.state = 741
            self.match(SQLiteParser.USING_)
            self.state = 742
            self.module_name()
            self.state = 754
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 743
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 744
                self.module_argument()
                self.state = 749
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 745
                    self.match(SQLiteParser.COMMA)
                    self.state = 746
                    self.module_argument()
                    self.state = 751
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 752
                self.match(SQLiteParser.CLOSE_PAR)


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


    class With_clauseContext(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(SQLiteParser.WITH_, 0)

        def cte_table_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Cte_table_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Cte_table_nameContext,i)


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

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

        def select_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,i)


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

        def RECURSIVE_(self):
            return self.getToken(SQLiteParser.RECURSIVE_, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_with_clause

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

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




    def with_clause(self):

        localctx = SQLiteParser.With_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_with_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 756
            self.match(SQLiteParser.WITH_)
            self.state = 758
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
            if la_ == 1:
                self.state = 757
                self.match(SQLiteParser.RECURSIVE_)


            self.state = 760
            self.cte_table_name()
            self.state = 761
            self.match(SQLiteParser.AS_)
            self.state = 762
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 763
            self.select_stmt()
            self.state = 764
            self.match(SQLiteParser.CLOSE_PAR)
            self.state = 774
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 765
                self.match(SQLiteParser.COMMA)
                self.state = 766
                self.cte_table_name()
                self.state = 767
                self.match(SQLiteParser.AS_)
                self.state = 768
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 769
                self.select_stmt()
                self.state = 770
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 776
                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 Cte_table_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_cte_table_name

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

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




    def cte_table_name(self):

        localctx = SQLiteParser.Cte_table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_cte_table_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 777
            self.table_name()
            self.state = 789
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 778
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 779
                self.column_name()
                self.state = 784
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 780
                    self.match(SQLiteParser.COMMA)
                    self.state = 781
                    self.column_name()
                    self.state = 786
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 787
                self.match(SQLiteParser.CLOSE_PAR)


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


    class Recursive_cteContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def cte_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Cte_table_nameContext,0)


        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def initial_select(self):
            return self.getTypedRuleContext(SQLiteParser.Initial_selectContext,0)


        def UNION_(self):
            return self.getToken(SQLiteParser.UNION_, 0)

        def recursive_select(self):
            return self.getTypedRuleContext(SQLiteParser.Recursive_selectContext,0)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def ALL_(self):
            return self.getToken(SQLiteParser.ALL_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_recursive_cte

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

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




    def recursive_cte(self):

        localctx = SQLiteParser.Recursive_cteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_recursive_cte)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 791
            self.cte_table_name()
            self.state = 792
            self.match(SQLiteParser.AS_)
            self.state = 793
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 794
            self.initial_select()
            self.state = 795
            self.match(SQLiteParser.UNION_)
            self.state = 797
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.ALL_:
                self.state = 796
                self.match(SQLiteParser.ALL_)


            self.state = 799
            self.recursive_select()
            self.state = 800
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Common_table_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

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

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


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

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_common_table_expression

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

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




    def common_table_expression(self):

        localctx = SQLiteParser.Common_table_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_common_table_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 802
            self.table_name()
            self.state = 814
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 803
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 804
                self.column_name()
                self.state = 809
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 805
                    self.match(SQLiteParser.COMMA)
                    self.state = 806
                    self.column_name()
                    self.state = 811
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 812
                self.match(SQLiteParser.CLOSE_PAR)


            self.state = 816
            self.match(SQLiteParser.AS_)
            self.state = 817
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 818
            self.select_stmt()
            self.state = 819
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Delete_stmtContext(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(SQLiteParser.DELETE_, 0)

        def FROM_(self):
            return self.getToken(SQLiteParser.FROM_, 0)

        def qualified_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0)


        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def WHERE_(self):
            return self.getToken(SQLiteParser.WHERE_, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def returning_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Returning_clauseContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_delete_stmt

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

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




    def delete_stmt(self):

        localctx = SQLiteParser.Delete_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_delete_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 822
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WITH_:
                self.state = 821
                self.with_clause()


            self.state = 824
            self.match(SQLiteParser.DELETE_)
            self.state = 825
            self.match(SQLiteParser.FROM_)
            self.state = 826
            self.qualified_table_name()
            self.state = 829
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WHERE_:
                self.state = 827
                self.match(SQLiteParser.WHERE_)
                self.state = 828
                self.expr(0)


            self.state = 832
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.RETURNING_:
                self.state = 831
                self.returning_clause()


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


    class Delete_stmt_limitedContext(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(SQLiteParser.DELETE_, 0)

        def FROM_(self):
            return self.getToken(SQLiteParser.FROM_, 0)

        def qualified_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0)


        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def WHERE_(self):
            return self.getToken(SQLiteParser.WHERE_, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def returning_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Returning_clauseContext,0)


        def limit_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0)


        def order_by_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_delete_stmt_limited

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

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




    def delete_stmt_limited(self):

        localctx = SQLiteParser.Delete_stmt_limitedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_delete_stmt_limited)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 835
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WITH_:
                self.state = 834
                self.with_clause()


            self.state = 837
            self.match(SQLiteParser.DELETE_)
            self.state = 838
            self.match(SQLiteParser.FROM_)
            self.state = 839
            self.qualified_table_name()
            self.state = 842
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WHERE_:
                self.state = 840
                self.match(SQLiteParser.WHERE_)
                self.state = 841
                self.expr(0)


            self.state = 845
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.RETURNING_:
                self.state = 844
                self.returning_clause()


            self.state = 851
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.LIMIT_ or _la==SQLiteParser.ORDER_:
                self.state = 848
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ORDER_:
                    self.state = 847
                    self.order_by_stmt()


                self.state = 850
                self.limit_stmt()


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


    class Detach_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DETACH_(self):
            return self.getToken(SQLiteParser.DETACH_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


        def DATABASE_(self):
            return self.getToken(SQLiteParser.DATABASE_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_detach_stmt

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

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




    def detach_stmt(self):

        localctx = SQLiteParser.Detach_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_detach_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 853
            self.match(SQLiteParser.DETACH_)
            self.state = 855
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
            if la_ == 1:
                self.state = 854
                self.match(SQLiteParser.DATABASE_)


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


    class Drop_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_(self):
            return self.getToken(SQLiteParser.DROP_, 0)

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def INDEX_(self):
            return self.getToken(SQLiteParser.INDEX_, 0)

        def TABLE_(self):
            return self.getToken(SQLiteParser.TABLE_, 0)

        def TRIGGER_(self):
            return self.getToken(SQLiteParser.TRIGGER_, 0)

        def VIEW_(self):
            return self.getToken(SQLiteParser.VIEW_, 0)

        def IF_(self):
            return self.getToken(SQLiteParser.IF_, 0)

        def EXISTS_(self):
            return self.getToken(SQLiteParser.EXISTS_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_drop_stmt

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

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




    def drop_stmt(self):

        localctx = SQLiteParser.Drop_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_drop_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 859
            self.match(SQLiteParser.DROP_)
            self.state = 860
            localctx.object_ = self._input.LT(1)
            _la = self._input.LA(1)
            if not(((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (SQLiteParser.INDEX_ - 84)) | (1 << (SQLiteParser.TABLE_ - 84)) | (1 << (SQLiteParser.TRIGGER_ - 84)) | (1 << (SQLiteParser.VIEW_ - 84)))) != 0)):
                localctx.object_ = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 863
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.state = 861
                self.match(SQLiteParser.IF_)
                self.state = 862
                self.match(SQLiteParser.EXISTS_)


            self.state = 868
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.state = 865
                self.schema_name()
                self.state = 866
                self.match(SQLiteParser.DOT)


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


    class ExprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def literal_value(self):
            return self.getTypedRuleContext(SQLiteParser.Literal_valueContext,0)


        def BIND_PARAMETER(self):
            return self.getToken(SQLiteParser.BIND_PARAMETER, 0)

        def column_name(self):
            return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0)


        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


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

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


        def unary_operator(self):
            return self.getTypedRuleContext(SQLiteParser.Unary_operatorContext,0)


        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def function_name(self):
            return self.getTypedRuleContext(SQLiteParser.Function_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

        def filter_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Filter_clauseContext,0)


        def over_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Over_clauseContext,0)


        def DISTINCT_(self):
            return self.getToken(SQLiteParser.DISTINCT_, 0)

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

        def CAST_(self):
            return self.getToken(SQLiteParser.CAST_, 0)

        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def type_name(self):
            return self.getTypedRuleContext(SQLiteParser.Type_nameContext,0)


        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def EXISTS_(self):
            return self.getToken(SQLiteParser.EXISTS_, 0)

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def CASE_(self):
            return self.getToken(SQLiteParser.CASE_, 0)

        def END_(self):
            return self.getToken(SQLiteParser.END_, 0)

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

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

        def ELSE_(self):
            return self.getToken(SQLiteParser.ELSE_, 0)

        def raise_function(self):
            return self.getTypedRuleContext(SQLiteParser.Raise_functionContext,0)


        def PIPE2(self):
            return self.getToken(SQLiteParser.PIPE2, 0)

        def DIV(self):
            return self.getToken(SQLiteParser.DIV, 0)

        def MOD(self):
            return self.getToken(SQLiteParser.MOD, 0)

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

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

        def LT2(self):
            return self.getToken(SQLiteParser.LT2, 0)

        def GT2(self):
            return self.getToken(SQLiteParser.GT2, 0)

        def AMP(self):
            return self.getToken(SQLiteParser.AMP, 0)

        def PIPE(self):
            return self.getToken(SQLiteParser.PIPE, 0)

        def LT(self):
            return self.getToken(SQLiteParser.LT, 0)

        def LT_EQ(self):
            return self.getToken(SQLiteParser.LT_EQ, 0)

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

        def GT_EQ(self):
            return self.getToken(SQLiteParser.GT_EQ, 0)

        def ASSIGN(self):
            return self.getToken(SQLiteParser.ASSIGN, 0)

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

        def NOT_EQ1(self):
            return self.getToken(SQLiteParser.NOT_EQ1, 0)

        def NOT_EQ2(self):
            return self.getToken(SQLiteParser.NOT_EQ2, 0)

        def IS_(self):
            return self.getToken(SQLiteParser.IS_, 0)

        def IN_(self):
            return self.getToken(SQLiteParser.IN_, 0)

        def LIKE_(self):
            return self.getToken(SQLiteParser.LIKE_, 0)

        def GLOB_(self):
            return self.getToken(SQLiteParser.GLOB_, 0)

        def MATCH_(self):
            return self.getToken(SQLiteParser.MATCH_, 0)

        def REGEXP_(self):
            return self.getToken(SQLiteParser.REGEXP_, 0)

        def AND_(self):
            return self.getToken(SQLiteParser.AND_, 0)

        def OR_(self):
            return self.getToken(SQLiteParser.OR_, 0)

        def BETWEEN_(self):
            return self.getToken(SQLiteParser.BETWEEN_, 0)

        def COLLATE_(self):
            return self.getToken(SQLiteParser.COLLATE_, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def ESCAPE_(self):
            return self.getToken(SQLiteParser.ESCAPE_, 0)

        def ISNULL_(self):
            return self.getToken(SQLiteParser.ISNULL_, 0)

        def NOTNULL_(self):
            return self.getToken(SQLiteParser.NOTNULL_, 0)

        def NULL_(self):
            return self.getToken(SQLiteParser.NULL_, 0)

        def table_function_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_function_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_expr

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

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



    def expr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SQLiteParser.ExprContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 64
        self.enterRecursionRule(localctx, 64, self.RULE_expr, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 960
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,120,self._ctx)
            if la_ == 1:
                self.state = 873
                self.literal_value()
                pass

            elif la_ == 2:
                self.state = 874
                self.match(SQLiteParser.BIND_PARAMETER)
                pass

            elif la_ == 3:
                self.state = 883
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
                if la_ == 1:
                    self.state = 878
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
                    if la_ == 1:
                        self.state = 875
                        self.schema_name()
                        self.state = 876
                        self.match(SQLiteParser.DOT)


                    self.state = 880
                    self.table_name()
                    self.state = 881
                    self.match(SQLiteParser.DOT)


                self.state = 885
                self.column_name()
                pass

            elif la_ == 4:
                self.state = 886
                self.unary_operator()
                self.state = 887
                self.expr(21)
                pass

            elif la_ == 5:
                self.state = 889
                self.function_name()
                self.state = 890
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 903
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]:
                    self.state = 892
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
                    if la_ == 1:
                        self.state = 891
                        self.match(SQLiteParser.DISTINCT_)


                    self.state = 894
                    self.expr(0)
                    self.state = 899
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 895
                        self.match(SQLiteParser.COMMA)
                        self.state = 896
                        self.expr(0)
                        self.state = 901
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [SQLiteParser.STAR]:
                    self.state = 902
                    self.match(SQLiteParser.STAR)
                    pass
                elif token in [SQLiteParser.CLOSE_PAR]:
                    pass
                else:
                    pass
                self.state = 905
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 907
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
                if la_ == 1:
                    self.state = 906
                    self.filter_clause()


                self.state = 910
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
                if la_ == 1:
                    self.state = 909
                    self.over_clause()


                pass

            elif la_ == 6:
                self.state = 912
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 913
                self.expr(0)
                self.state = 918
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 914
                    self.match(SQLiteParser.COMMA)
                    self.state = 915
                    self.expr(0)
                    self.state = 920
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 921
                self.match(SQLiteParser.CLOSE_PAR)
                pass

            elif la_ == 7:
                self.state = 923
                self.match(SQLiteParser.CAST_)
                self.state = 924
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 925
                self.expr(0)
                self.state = 926
                self.match(SQLiteParser.AS_)
                self.state = 927
                self.type_name()
                self.state = 928
                self.match(SQLiteParser.CLOSE_PAR)
                pass

            elif la_ == 8:
                self.state = 934
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.EXISTS_ or _la==SQLiteParser.NOT_:
                    self.state = 931
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.NOT_:
                        self.state = 930
                        self.match(SQLiteParser.NOT_)


                    self.state = 933
                    self.match(SQLiteParser.EXISTS_)


                self.state = 936
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 937
                self.select_stmt()
                self.state = 938
                self.match(SQLiteParser.CLOSE_PAR)
                pass

            elif la_ == 9:
                self.state = 940
                self.match(SQLiteParser.CASE_)
                self.state = 942
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                if la_ == 1:
                    self.state = 941
                    self.expr(0)


                self.state = 949 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 944
                    self.match(SQLiteParser.WHEN_)
                    self.state = 945
                    self.expr(0)
                    self.state = 946
                    self.match(SQLiteParser.THEN_)
                    self.state = 947
                    self.expr(0)
                    self.state = 951 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==SQLiteParser.WHEN_):
                        break

                self.state = 955
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ELSE_:
                    self.state = 953
                    self.match(SQLiteParser.ELSE_)
                    self.state = 954
                    self.expr(0)


                self.state = 957
                self.match(SQLiteParser.END_)
                pass

            elif la_ == 10:
                self.state = 959
                self.raise_function()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1081
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,136,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 = 1079
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
                    if la_ == 1:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 962
                        if not self.precpred(self._ctx, 20):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
                        self.state = 963
                        self.match(SQLiteParser.PIPE2)
                        self.state = 964
                        self.expr(21)
                        pass

                    elif la_ == 2:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 965
                        if not self.precpred(self._ctx, 19):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
                        self.state = 966
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.STAR) | (1 << SQLiteParser.DIV) | (1 << SQLiteParser.MOD))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 967
                        self.expr(20)
                        pass

                    elif la_ == 3:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 968
                        if not self.precpred(self._ctx, 18):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
                        self.state = 969
                        _la = self._input.LA(1)
                        if not(_la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 970
                        self.expr(19)
                        pass

                    elif la_ == 4:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 971
                        if not self.precpred(self._ctx, 17):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
                        self.state = 972
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.LT2) | (1 << SQLiteParser.GT2) | (1 << SQLiteParser.AMP) | (1 << SQLiteParser.PIPE))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 973
                        self.expr(18)
                        pass

                    elif la_ == 5:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 974
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 975
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.LT) | (1 << SQLiteParser.LT_EQ) | (1 << SQLiteParser.GT) | (1 << SQLiteParser.GT_EQ))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 976
                        self.expr(17)
                        pass

                    elif la_ == 6:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 977
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 990
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
                        if la_ == 1:
                            self.state = 978
                            self.match(SQLiteParser.ASSIGN)
                            pass

                        elif la_ == 2:
                            self.state = 979
                            self.match(SQLiteParser.EQ)
                            pass

                        elif la_ == 3:
                            self.state = 980
                            self.match(SQLiteParser.NOT_EQ1)
                            pass

                        elif la_ == 4:
                            self.state = 981
                            self.match(SQLiteParser.NOT_EQ2)
                            pass

                        elif la_ == 5:
                            self.state = 982
                            self.match(SQLiteParser.IS_)
                            pass

                        elif la_ == 6:
                            self.state = 983
                            self.match(SQLiteParser.IS_)
                            self.state = 984
                            self.match(SQLiteParser.NOT_)
                            pass

                        elif la_ == 7:
                            self.state = 985
                            self.match(SQLiteParser.IN_)
                            pass

                        elif la_ == 8:
                            self.state = 986
                            self.match(SQLiteParser.LIKE_)
                            pass

                        elif la_ == 9:
                            self.state = 987
                            self.match(SQLiteParser.GLOB_)
                            pass

                        elif la_ == 10:
                            self.state = 988
                            self.match(SQLiteParser.MATCH_)
                            pass

                        elif la_ == 11:
                            self.state = 989
                            self.match(SQLiteParser.REGEXP_)
                            pass


                        self.state = 992
                        self.expr(16)
                        pass

                    elif la_ == 7:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 993
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 994
                        self.match(SQLiteParser.AND_)
                        self.state = 995
                        self.expr(15)
                        pass

                    elif la_ == 8:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 996
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 997
                        self.match(SQLiteParser.OR_)
                        self.state = 998
                        self.expr(14)
                        pass

                    elif la_ == 9:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 999
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 1000
                        self.match(SQLiteParser.IS_)
                        self.state = 1002
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
                        if la_ == 1:
                            self.state = 1001
                            self.match(SQLiteParser.NOT_)


                        self.state = 1004
                        self.expr(7)
                        pass

                    elif la_ == 10:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1005
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1007
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SQLiteParser.NOT_:
                            self.state = 1006
                            self.match(SQLiteParser.NOT_)


                        self.state = 1009
                        self.match(SQLiteParser.BETWEEN_)
                        self.state = 1010
                        self.expr(0)
                        self.state = 1011
                        self.match(SQLiteParser.AND_)
                        self.state = 1012
                        self.expr(6)
                        pass

                    elif la_ == 11:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1014
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1015
                        self.match(SQLiteParser.COLLATE_)
                        self.state = 1016
                        self.collation_name()
                        pass

                    elif la_ == 12:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1017
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1019
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SQLiteParser.NOT_:
                            self.state = 1018
                            self.match(SQLiteParser.NOT_)


                        self.state = 1021
                        _la = self._input.LA(1)
                        if not(((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (SQLiteParser.GLOB_ - 77)) | (1 << (SQLiteParser.LIKE_ - 77)) | (1 << (SQLiteParser.MATCH_ - 77)) | (1 << (SQLiteParser.REGEXP_ - 77)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1022
                        self.expr(0)
                        self.state = 1025
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
                        if la_ == 1:
                            self.state = 1023
                            self.match(SQLiteParser.ESCAPE_)
                            self.state = 1024
                            self.expr(0)


                        pass

                    elif la_ == 13:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1027
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1032
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [SQLiteParser.ISNULL_]:
                            self.state = 1028
                            self.match(SQLiteParser.ISNULL_)
                            pass
                        elif token in [SQLiteParser.NOTNULL_]:
                            self.state = 1029
                            self.match(SQLiteParser.NOTNULL_)
                            pass
                        elif token in [SQLiteParser.NOT_]:
                            self.state = 1030
                            self.match(SQLiteParser.NOT_)
                            self.state = 1031
                            self.match(SQLiteParser.NULL_)
                            pass
                        else:
                            raise NoViableAltException(self)

                        pass

                    elif la_ == 14:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1034
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1036
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SQLiteParser.NOT_:
                            self.state = 1035
                            self.match(SQLiteParser.NOT_)


                        self.state = 1038
                        self.match(SQLiteParser.IN_)
                        self.state = 1077
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
                        if la_ == 1:
                            self.state = 1039
                            self.match(SQLiteParser.OPEN_PAR)
                            self.state = 1049
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
                            if la_ == 1:
                                self.state = 1040
                                self.select_stmt()

                            elif la_ == 2:
                                self.state = 1041
                                self.expr(0)
                                self.state = 1046
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)
                                while _la==SQLiteParser.COMMA:
                                    self.state = 1042
                                    self.match(SQLiteParser.COMMA)
                                    self.state = 1043
                                    self.expr(0)
                                    self.state = 1048
                                    self._errHandler.sync(self)
                                    _la = self._input.LA(1)



                            self.state = 1051
                            self.match(SQLiteParser.CLOSE_PAR)
                            pass

                        elif la_ == 2:
                            self.state = 1055
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
                            if la_ == 1:
                                self.state = 1052
                                self.schema_name()
                                self.state = 1053
                                self.match(SQLiteParser.DOT)


                            self.state = 1057
                            self.table_name()
                            pass

                        elif la_ == 3:
                            self.state = 1061
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
                            if la_ == 1:
                                self.state = 1058
                                self.schema_name()
                                self.state = 1059
                                self.match(SQLiteParser.DOT)


                            self.state = 1063
                            self.table_function_name()
                            self.state = 1064
                            self.match(SQLiteParser.OPEN_PAR)
                            self.state = 1073
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.OPEN_PAR) | (1 << SQLiteParser.PLUS) | (1 << SQLiteParser.MINUS) | (1 << SQLiteParser.TILDE) | (1 << SQLiteParser.ABORT_) | (1 << SQLiteParser.ACTION_) | (1 << SQLiteParser.ADD_) | (1 << SQLiteParser.AFTER_) | (1 << SQLiteParser.ALL_) | (1 << SQLiteParser.ALTER_) | (1 << SQLiteParser.ANALYZE_) | (1 << SQLiteParser.AND_) | (1 << SQLiteParser.AS_) | (1 << SQLiteParser.ASC_) | (1 << SQLiteParser.ATTACH_) | (1 << SQLiteParser.AUTOINCREMENT_) | (1 << SQLiteParser.BEFORE_) | (1 << SQLiteParser.BEGIN_) | (1 << SQLiteParser.BETWEEN_) | (1 << SQLiteParser.BY_) | (1 << SQLiteParser.CASCADE_) | (1 << SQLiteParser.CASE_) | (1 << SQLiteParser.CAST_) | (1 << SQLiteParser.CHECK_) | (1 << SQLiteParser.COLLATE_) | (1 << SQLiteParser.COLUMN_) | (1 << SQLiteParser.COMMIT_) | (1 << SQLiteParser.CONFLICT_) | (1 << SQLiteParser.CONSTRAINT_) | (1 << SQLiteParser.CREATE_) | (1 << SQLiteParser.CROSS_) | (1 << SQLiteParser.CURRENT_DATE_) | (1 << SQLiteParser.CURRENT_TIME_) | (1 << SQLiteParser.CURRENT_TIMESTAMP_) | (1 << SQLiteParser.DATABASE_) | (1 << SQLiteParser.DEFAULT_) | (1 << SQLiteParser.DEFERRABLE_) | (1 << SQLiteParser.DEFERRED_) | (1 << SQLiteParser.DELETE_) | (1 << SQLiteParser.DESC_) | (1 << SQLiteParser.DETACH_) | (1 << SQLiteParser.DISTINCT_) | (1 << SQLiteParser.DROP_))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SQLiteParser.EACH_ - 64)) | (1 << (SQLiteParser.ELSE_ - 64)) | (1 << (SQLiteParser.END_ - 64)) | (1 << (SQLiteParser.ESCAPE_ - 64)) | (1 << (SQLiteParser.EXCEPT_ - 64)) | (1 << (SQLiteParser.EXCLUSIVE_ - 64)) | (1 << (SQLiteParser.EXISTS_ - 64)) | (1 << (SQLiteParser.EXPLAIN_ - 64)) | (1 << (SQLiteParser.FAIL_ - 64)) | (1 << (SQLiteParser.FOR_ - 64)) | (1 << (SQLiteParser.FOREIGN_ - 64)) | (1 << (SQLiteParser.FROM_ - 64)) | (1 << (SQLiteParser.FULL_ - 64)) | (1 << (SQLiteParser.GLOB_ - 64)) | (1 << (SQLiteParser.GROUP_ - 64)) | (1 << (SQLiteParser.HAVING_ - 64)) | (1 << (SQLiteParser.IF_ - 64)) | (1 << (SQLiteParser.IGNORE_ - 64)) | (1 << (SQLiteParser.IMMEDIATE_ - 64)) | (1 << (SQLiteParser.IN_ - 64)) | (1 << (SQLiteParser.INDEX_ - 64)) | (1 << (SQLiteParser.INDEXED_ - 64)) | (1 << (SQLiteParser.INITIALLY_ - 64)) | (1 << (SQLiteParser.INNER_ - 64)) | (1 << (SQLiteParser.INSERT_ - 64)) | (1 << (SQLiteParser.INSTEAD_ - 64)) | (1 << (SQLiteParser.INTERSECT_ - 64)) | (1 << (SQLiteParser.INTO_ - 64)) | (1 << (SQLiteParser.IS_ - 64)) | (1 << (SQLiteParser.ISNULL_ - 64)) | (1 << (SQLiteParser.JOIN_ - 64)) | (1 << (SQLiteParser.KEY_ - 64)) | (1 << (SQLiteParser.LEFT_ - 64)) | (1 << (SQLiteParser.LIKE_ - 64)) | (1 << (SQLiteParser.LIMIT_ - 64)) | (1 << (SQLiteParser.MATCH_ - 64)) | (1 << (SQLiteParser.NATURAL_ - 64)) | (1 << (SQLiteParser.NO_ - 64)) | (1 << (SQLiteParser.NOT_ - 64)) | (1 << (SQLiteParser.NOTNULL_ - 64)) | (1 << (SQLiteParser.NULL_ - 64)) | (1 << (SQLiteParser.OF_ - 64)) | (1 << (SQLiteParser.OFFSET_ - 64)) | (1 << (SQLiteParser.ON_ - 64)) | (1 << (SQLiteParser.OR_ - 64)) | (1 << (SQLiteParser.ORDER_ - 64)) | (1 << (SQLiteParser.OUTER_ - 64)) | (1 << (SQLiteParser.PLAN_ - 64)) | (1 << (SQLiteParser.PRAGMA_ - 64)) | (1 << (SQLiteParser.PRIMARY_ - 64)) | (1 << (SQLiteParser.QUERY_ - 64)) | (1 << (SQLiteParser.RAISE_ - 64)) | (1 << (SQLiteParser.RECURSIVE_ - 64)) | (1 << (SQLiteParser.REFERENCES_ - 64)) | (1 << (SQLiteParser.REGEXP_ - 64)) | (1 << (SQLiteParser.REINDEX_ - 64)) | (1 << (SQLiteParser.RELEASE_ - 64)) | (1 << (SQLiteParser.RENAME_ - 64)) | (1 << (SQLiteParser.REPLACE_ - 64)) | (1 << (SQLiteParser.RESTRICT_ - 64)) | (1 << (SQLiteParser.RIGHT_ - 64)) | (1 << (SQLiteParser.ROLLBACK_ - 64)) | (1 << (SQLiteParser.ROW_ - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.ROWS_ - 128)) | (1 << (SQLiteParser.SAVEPOINT_ - 128)) | (1 << (SQLiteParser.SELECT_ - 128)) | (1 << (SQLiteParser.SET_ - 128)) | (1 << (SQLiteParser.TABLE_ - 128)) | (1 << (SQLiteParser.TEMP_ - 128)) | (1 << (SQLiteParser.TEMPORARY_ - 128)) | (1 << (SQLiteParser.THEN_ - 128)) | (1 << (SQLiteParser.TO_ - 128)) | (1 << (SQLiteParser.TRANSACTION_ - 128)) | (1 << (SQLiteParser.TRIGGER_ - 128)) | (1 << (SQLiteParser.UNION_ - 128)) | (1 << (SQLiteParser.UNIQUE_ - 128)) | (1 << (SQLiteParser.UPDATE_ - 128)) | (1 << (SQLiteParser.USING_ - 128)) | (1 << (SQLiteParser.VACUUM_ - 128)) | (1 << (SQLiteParser.VALUES_ - 128)) | (1 << (SQLiteParser.VIEW_ - 128)) | (1 << (SQLiteParser.VIRTUAL_ - 128)) | (1 << (SQLiteParser.WHEN_ - 128)) | (1 << (SQLiteParser.WHERE_ - 128)) | (1 << (SQLiteParser.WITH_ - 128)) | (1 << (SQLiteParser.WITHOUT_ - 128)) | (1 << (SQLiteParser.FIRST_VALUE_ - 128)) | (1 << (SQLiteParser.OVER_ - 128)) | (1 << (SQLiteParser.PARTITION_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.PRECEDING_ - 128)) | (1 << (SQLiteParser.UNBOUNDED_ - 128)) | (1 << (SQLiteParser.CURRENT_ - 128)) | (1 << (SQLiteParser.FOLLOWING_ - 128)) | (1 << (SQLiteParser.CUME_DIST_ - 128)) | (1 << (SQLiteParser.DENSE_RANK_ - 128)) | (1 << (SQLiteParser.LAG_ - 128)) | (1 << (SQLiteParser.LAST_VALUE_ - 128)) | (1 << (SQLiteParser.LEAD_ - 128)) | (1 << (SQLiteParser.NTH_VALUE_ - 128)) | (1 << (SQLiteParser.NTILE_ - 128)) | (1 << (SQLiteParser.PERCENT_RANK_ - 128)) | (1 << (SQLiteParser.RANK_ - 128)) | (1 << (SQLiteParser.ROW_NUMBER_ - 128)) | (1 << (SQLiteParser.GENERATED_ - 128)) | (1 << (SQLiteParser.ALWAYS_ - 128)) | (1 << (SQLiteParser.STORED_ - 128)) | (1 << (SQLiteParser.TRUE_ - 128)) | (1 << (SQLiteParser.FALSE_ - 128)) | (1 << (SQLiteParser.WINDOW_ - 128)) | (1 << (SQLiteParser.NULLS_ - 128)) | (1 << (SQLiteParser.FIRST_ - 128)) | (1 << (SQLiteParser.LAST_ - 128)) | (1 << (SQLiteParser.FILTER_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)) | (1 << (SQLiteParser.EXCLUDE_ - 128)) | (1 << (SQLiteParser.IDENTIFIER - 128)) | (1 << (SQLiteParser.NUMERIC_LITERAL - 128)) | (1 << (SQLiteParser.BIND_PARAMETER - 128)) | (1 << (SQLiteParser.STRING_LITERAL - 128)) | (1 << (SQLiteParser.BLOB_LITERAL - 128)))) != 0):
                                self.state = 1065
                                self.expr(0)
                                self.state = 1070
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)
                                while _la==SQLiteParser.COMMA:
                                    self.state = 1066
                                    self.match(SQLiteParser.COMMA)
                                    self.state = 1067
                                    self.expr(0)
                                    self.state = 1072
                                    self._errHandler.sync(self)
                                    _la = self._input.LA(1)



                            self.state = 1075
                            self.match(SQLiteParser.CLOSE_PAR)
                            pass


                        pass

             
                self.state = 1083
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,136,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 Raise_functionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RAISE_(self):
            return self.getToken(SQLiteParser.RAISE_, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def IGNORE_(self):
            return self.getToken(SQLiteParser.IGNORE_, 0)

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

        def error_message(self):
            return self.getTypedRuleContext(SQLiteParser.Error_messageContext,0)


        def ROLLBACK_(self):
            return self.getToken(SQLiteParser.ROLLBACK_, 0)

        def ABORT_(self):
            return self.getToken(SQLiteParser.ABORT_, 0)

        def FAIL_(self):
            return self.getToken(SQLiteParser.FAIL_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_raise_function

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

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




    def raise_function(self):

        localctx = SQLiteParser.Raise_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_raise_function)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1084
            self.match(SQLiteParser.RAISE_)
            self.state = 1085
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1090
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.IGNORE_]:
                self.state = 1086
                self.match(SQLiteParser.IGNORE_)
                pass
            elif token in [SQLiteParser.ABORT_, SQLiteParser.FAIL_, SQLiteParser.ROLLBACK_]:
                self.state = 1087
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.ABORT_ or _la==SQLiteParser.FAIL_ or _la==SQLiteParser.ROLLBACK_):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1088
                self.match(SQLiteParser.COMMA)
                self.state = 1089
                self.error_message()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1092
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Literal_valueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NUMERIC_LITERAL(self):
            return self.getToken(SQLiteParser.NUMERIC_LITERAL, 0)

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

        def BLOB_LITERAL(self):
            return self.getToken(SQLiteParser.BLOB_LITERAL, 0)

        def NULL_(self):
            return self.getToken(SQLiteParser.NULL_, 0)

        def TRUE_(self):
            return self.getToken(SQLiteParser.TRUE_, 0)

        def FALSE_(self):
            return self.getToken(SQLiteParser.FALSE_, 0)

        def CURRENT_TIME_(self):
            return self.getToken(SQLiteParser.CURRENT_TIME_, 0)

        def CURRENT_DATE_(self):
            return self.getToken(SQLiteParser.CURRENT_DATE_, 0)

        def CURRENT_TIMESTAMP_(self):
            return self.getToken(SQLiteParser.CURRENT_TIMESTAMP_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_literal_value

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

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




    def literal_value(self):

        localctx = SQLiteParser.Literal_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_literal_value)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1094
            _la = self._input.LA(1)
            if not(((((_la - 52)) & ~0x3f) == 0 and ((1 << (_la - 52)) & ((1 << (SQLiteParser.CURRENT_DATE_ - 52)) | (1 << (SQLiteParser.CURRENT_TIME_ - 52)) | (1 << (SQLiteParser.CURRENT_TIMESTAMP_ - 52)) | (1 << (SQLiteParser.NULL_ - 52)))) != 0) or ((((_la - 172)) & ~0x3f) == 0 and ((1 << (_la - 172)) & ((1 << (SQLiteParser.TRUE_ - 172)) | (1 << (SQLiteParser.FALSE_ - 172)) | (1 << (SQLiteParser.NUMERIC_LITERAL - 172)) | (1 << (SQLiteParser.STRING_LITERAL - 172)) | (1 << (SQLiteParser.BLOB_LITERAL - 172)))) != 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 Insert_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INTO_(self):
            return self.getToken(SQLiteParser.INTO_, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def INSERT_(self):
            return self.getToken(SQLiteParser.INSERT_, 0)

        def REPLACE_(self):
            return self.getToken(SQLiteParser.REPLACE_, 0)

        def OR_(self):
            return self.getToken(SQLiteParser.OR_, 0)

        def DEFAULT_(self):
            return self.getToken(SQLiteParser.DEFAULT_, 0)

        def VALUES_(self):
            return self.getToken(SQLiteParser.VALUES_, 0)

        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def ROLLBACK_(self):
            return self.getToken(SQLiteParser.ROLLBACK_, 0)

        def ABORT_(self):
            return self.getToken(SQLiteParser.ABORT_, 0)

        def FAIL_(self):
            return self.getToken(SQLiteParser.FAIL_, 0)

        def IGNORE_(self):
            return self.getToken(SQLiteParser.IGNORE_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def table_alias(self):
            return self.getTypedRuleContext(SQLiteParser.Table_aliasContext,0)


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

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


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

        def returning_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Returning_clauseContext,0)


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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def upsert_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Upsert_clauseContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_insert_stmt

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

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




    def insert_stmt(self):

        localctx = SQLiteParser.Insert_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_insert_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1097
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WITH_:
                self.state = 1096
                self.with_clause()


            self.state = 1104
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
            if la_ == 1:
                self.state = 1099
                self.match(SQLiteParser.INSERT_)
                pass

            elif la_ == 2:
                self.state = 1100
                self.match(SQLiteParser.REPLACE_)
                pass

            elif la_ == 3:
                self.state = 1101
                self.match(SQLiteParser.INSERT_)
                self.state = 1102
                self.match(SQLiteParser.OR_)
                self.state = 1103
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.ABORT_ or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.FAIL_ - 72)) | (1 << (SQLiteParser.IGNORE_ - 72)) | (1 << (SQLiteParser.REPLACE_ - 72)) | (1 << (SQLiteParser.ROLLBACK_ - 72)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass


            self.state = 1106
            self.match(SQLiteParser.INTO_)
            self.state = 1110
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
            if la_ == 1:
                self.state = 1107
                self.schema_name()
                self.state = 1108
                self.match(SQLiteParser.DOT)


            self.state = 1112
            self.table_name()
            self.state = 1115
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.AS_:
                self.state = 1113
                self.match(SQLiteParser.AS_)
                self.state = 1114
                self.table_alias()


            self.state = 1128
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 1117
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1118
                self.column_name()
                self.state = 1123
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1119
                    self.match(SQLiteParser.COMMA)
                    self.state = 1120
                    self.column_name()
                    self.state = 1125
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1126
                self.match(SQLiteParser.CLOSE_PAR)


            self.state = 1166
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.SELECT_, SQLiteParser.VALUES_, SQLiteParser.WITH_]:
                self.state = 1159
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,147,self._ctx)
                if la_ == 1:
                    self.state = 1130
                    self.match(SQLiteParser.VALUES_)
                    self.state = 1131
                    self.match(SQLiteParser.OPEN_PAR)
                    self.state = 1132
                    self.expr(0)
                    self.state = 1137
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1133
                        self.match(SQLiteParser.COMMA)
                        self.state = 1134
                        self.expr(0)
                        self.state = 1139
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1140
                    self.match(SQLiteParser.CLOSE_PAR)
                    self.state = 1155
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1141
                        self.match(SQLiteParser.COMMA)
                        self.state = 1142
                        self.match(SQLiteParser.OPEN_PAR)
                        self.state = 1143
                        self.expr(0)
                        self.state = 1148
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==SQLiteParser.COMMA:
                            self.state = 1144
                            self.match(SQLiteParser.COMMA)
                            self.state = 1145
                            self.expr(0)
                            self.state = 1150
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1151
                        self.match(SQLiteParser.CLOSE_PAR)
                        self.state = 1157
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass

                elif la_ == 2:
                    self.state = 1158
                    self.select_stmt()
                    pass


                self.state = 1162
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ON_:
                    self.state = 1161
                    self.upsert_clause()


                pass
            elif token in [SQLiteParser.DEFAULT_]:
                self.state = 1164
                self.match(SQLiteParser.DEFAULT_)
                self.state = 1165
                self.match(SQLiteParser.VALUES_)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1169
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.RETURNING_:
                self.state = 1168
                self.returning_clause()


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


    class Returning_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RETURNING_(self):
            return self.getToken(SQLiteParser.RETURNING_, 0)

        def result_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Result_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Result_columnContext,i)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_returning_clause

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

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




    def returning_clause(self):

        localctx = SQLiteParser.Returning_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_returning_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1171
            self.match(SQLiteParser.RETURNING_)
            self.state = 1172
            self.result_column()
            self.state = 1177
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1173
                self.match(SQLiteParser.COMMA)
                self.state = 1174
                self.result_column()
                self.state = 1179
                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 Upsert_clauseContext(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(SQLiteParser.ON_, 0)

        def CONFLICT_(self):
            return self.getToken(SQLiteParser.CONFLICT_, 0)

        def DO_(self):
            return self.getToken(SQLiteParser.DO_, 0)

        def NOTHING_(self):
            return self.getToken(SQLiteParser.NOTHING_, 0)

        def UPDATE_(self):
            return self.getToken(SQLiteParser.UPDATE_, 0)

        def SET_(self):
            return self.getToken(SQLiteParser.SET_, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def indexed_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Indexed_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Indexed_columnContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


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

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

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


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


        def getRuleIndex(self):
            return SQLiteParser.RULE_upsert_clause

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

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




    def upsert_clause(self):

        localctx = SQLiteParser.Upsert_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_upsert_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1180
            self.match(SQLiteParser.ON_)
            self.state = 1181
            self.match(SQLiteParser.CONFLICT_)
            self.state = 1196
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 1182
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1183
                self.indexed_column()
                self.state = 1188
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1184
                    self.match(SQLiteParser.COMMA)
                    self.state = 1185
                    self.indexed_column()
                    self.state = 1190
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1191
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1194
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.WHERE_:
                    self.state = 1192
                    self.match(SQLiteParser.WHERE_)
                    self.state = 1193
                    self.expr(0)




            self.state = 1198
            self.match(SQLiteParser.DO_)
            self.state = 1225
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.NOTHING_]:
                self.state = 1199
                self.match(SQLiteParser.NOTHING_)
                pass
            elif token in [SQLiteParser.UPDATE_]:
                self.state = 1200
                self.match(SQLiteParser.UPDATE_)
                self.state = 1201
                self.match(SQLiteParser.SET_)

                self.state = 1204
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,155,self._ctx)
                if la_ == 1:
                    self.state = 1202
                    self.column_name()
                    pass

                elif la_ == 2:
                    self.state = 1203
                    self.column_name_list()
                    pass


                self.state = 1206
                self.match(SQLiteParser.ASSIGN)
                self.state = 1207
                self.expr(0)
                self.state = 1218
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1208
                    self.match(SQLiteParser.COMMA)
                    self.state = 1211
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
                    if la_ == 1:
                        self.state = 1209
                        self.column_name()
                        pass

                    elif la_ == 2:
                        self.state = 1210
                        self.column_name_list()
                        pass


                    self.state = 1213
                    self.match(SQLiteParser.ASSIGN)
                    self.state = 1214
                    self.expr(0)
                    self.state = 1220
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1223
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.WHERE_:
                    self.state = 1221
                    self.match(SQLiteParser.WHERE_)
                    self.state = 1222
                    self.expr(0)


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

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

        def PRAGMA_(self):
            return self.getToken(SQLiteParser.PRAGMA_, 0)

        def pragma_name(self):
            return self.getTypedRuleContext(SQLiteParser.Pragma_nameContext,0)


        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def ASSIGN(self):
            return self.getToken(SQLiteParser.ASSIGN, 0)

        def pragma_value(self):
            return self.getTypedRuleContext(SQLiteParser.Pragma_valueContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_pragma_stmt

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

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




    def pragma_stmt(self):

        localctx = SQLiteParser.Pragma_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_pragma_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1227
            self.match(SQLiteParser.PRAGMA_)
            self.state = 1231
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
            if la_ == 1:
                self.state = 1228
                self.schema_name()
                self.state = 1229
                self.match(SQLiteParser.DOT)


            self.state = 1233
            self.pragma_name()
            self.state = 1240
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.ASSIGN]:
                self.state = 1234
                self.match(SQLiteParser.ASSIGN)
                self.state = 1235
                self.pragma_value()
                pass
            elif token in [SQLiteParser.OPEN_PAR]:
                self.state = 1236
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1237
                self.pragma_value()
                self.state = 1238
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.ATTACH_, SQLiteParser.BEGIN_, SQLiteParser.COMMIT_, SQLiteParser.CREATE_, SQLiteParser.DELETE_, SQLiteParser.DETACH_, SQLiteParser.DROP_, SQLiteParser.END_, SQLiteParser.EXPLAIN_, SQLiteParser.INSERT_, SQLiteParser.PRAGMA_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.REPLACE_, SQLiteParser.ROLLBACK_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.UPDATE_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.WITH_]:
                pass
            else:
                pass
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pragma_valueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def signed_number(self):
            return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0)


        def name(self):
            return self.getTypedRuleContext(SQLiteParser.NameContext,0)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_pragma_value

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

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




    def pragma_value(self):

        localctx = SQLiteParser.Pragma_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_pragma_value)
        try:
            self.state = 1245
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1242
                self.signed_number()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1243
                self.name()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1244
                self.match(SQLiteParser.STRING_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 Reindex_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REINDEX_(self):
            return self.getToken(SQLiteParser.REINDEX_, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_reindex_stmt

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

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




    def reindex_stmt(self):

        localctx = SQLiteParser.Reindex_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_reindex_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1247
            self.match(SQLiteParser.REINDEX_)
            self.state = 1258
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
            if la_ == 1:
                self.state = 1248
                self.collation_name()

            elif la_ == 2:
                self.state = 1252
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,163,self._ctx)
                if la_ == 1:
                    self.state = 1249
                    self.schema_name()
                    self.state = 1250
                    self.match(SQLiteParser.DOT)


                self.state = 1256
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
                if la_ == 1:
                    self.state = 1254
                    self.table_name()
                    pass

                elif la_ == 2:
                    self.state = 1255
                    self.index_name()
                    pass




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


    class Select_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def select_core(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_coreContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_coreContext,i)


        def common_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Common_table_stmtContext,0)


        def compound_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Compound_operatorContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Compound_operatorContext,i)


        def order_by_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0)


        def limit_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_select_stmt

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

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




    def select_stmt(self):

        localctx = SQLiteParser.Select_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_select_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1261
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WITH_:
                self.state = 1260
                self.common_table_stmt()


            self.state = 1263
            self.select_core()
            self.state = 1269
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,167,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1264
                    self.compound_operator()
                    self.state = 1265
                    self.select_core() 
                self.state = 1271
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,167,self._ctx)

            self.state = 1273
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.ORDER_:
                self.state = 1272
                self.order_by_stmt()


            self.state = 1276
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.LIMIT_:
                self.state = 1275
                self.limit_stmt()


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


    class Join_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def table_or_subquery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i)


        def join_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Join_operatorContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Join_operatorContext,i)


        def join_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Join_constraintContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Join_constraintContext,i)


        def getRuleIndex(self):
            return SQLiteParser.RULE_join_clause

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

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




    def join_clause(self):

        localctx = SQLiteParser.Join_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_join_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1278
            self.table_or_subquery()
            self.state = 1286
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA or _la==SQLiteParser.CROSS_ or ((((_la - 87)) & ~0x3f) == 0 and ((1 << (_la - 87)) & ((1 << (SQLiteParser.INNER_ - 87)) | (1 << (SQLiteParser.JOIN_ - 87)) | (1 << (SQLiteParser.LEFT_ - 87)) | (1 << (SQLiteParser.NATURAL_ - 87)))) != 0):
                self.state = 1279
                self.join_operator()
                self.state = 1280
                self.table_or_subquery()
                self.state = 1282
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,170,self._ctx)
                if la_ == 1:
                    self.state = 1281
                    self.join_constraint()


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

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

        def SELECT_(self):
            return self.getToken(SQLiteParser.SELECT_, 0)

        def result_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Result_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Result_columnContext,i)


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

        def FROM_(self):
            return self.getToken(SQLiteParser.FROM_, 0)

        def WHERE_(self):
            return self.getToken(SQLiteParser.WHERE_, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def GROUP_(self):
            return self.getToken(SQLiteParser.GROUP_, 0)

        def BY_(self):
            return self.getToken(SQLiteParser.BY_, 0)

        def WINDOW_(self):
            return self.getToken(SQLiteParser.WINDOW_, 0)

        def window_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Window_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Window_nameContext,i)


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

        def window_defn(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Window_defnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Window_defnContext,i)


        def DISTINCT_(self):
            return self.getToken(SQLiteParser.DISTINCT_, 0)

        def ALL_(self):
            return self.getToken(SQLiteParser.ALL_, 0)

        def table_or_subquery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i)


        def join_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Join_clauseContext,0)


        def HAVING_(self):
            return self.getToken(SQLiteParser.HAVING_, 0)

        def VALUES_(self):
            return self.getToken(SQLiteParser.VALUES_, 0)

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

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_select_core

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

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




    def select_core(self):

        localctx = SQLiteParser.Select_coreContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_select_core)
        self._la = 0 # Token type
        try:
            self.state = 1379
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.SELECT_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1289
                self.match(SQLiteParser.SELECT_)
                self.state = 1291
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
                if la_ == 1:
                    self.state = 1290
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.ALL_ or _la==SQLiteParser.DISTINCT_):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1293
                self.result_column()
                self.state = 1298
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1294
                    self.match(SQLiteParser.COMMA)
                    self.state = 1295
                    self.result_column()
                    self.state = 1300
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1313
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.FROM_:
                    self.state = 1301
                    self.match(SQLiteParser.FROM_)
                    self.state = 1311
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
                    if la_ == 1:
                        self.state = 1302
                        self.table_or_subquery()
                        self.state = 1307
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==SQLiteParser.COMMA:
                            self.state = 1303
                            self.match(SQLiteParser.COMMA)
                            self.state = 1304
                            self.table_or_subquery()
                            self.state = 1309
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        pass

                    elif la_ == 2:
                        self.state = 1310
                        self.join_clause()
                        pass




                self.state = 1317
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.WHERE_:
                    self.state = 1315
                    self.match(SQLiteParser.WHERE_)
                    self.state = 1316
                    self.expr(0)


                self.state = 1333
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.GROUP_:
                    self.state = 1319
                    self.match(SQLiteParser.GROUP_)
                    self.state = 1320
                    self.match(SQLiteParser.BY_)
                    self.state = 1321
                    self.expr(0)
                    self.state = 1326
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1322
                        self.match(SQLiteParser.COMMA)
                        self.state = 1323
                        self.expr(0)
                        self.state = 1328
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1331
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.HAVING_:
                        self.state = 1329
                        self.match(SQLiteParser.HAVING_)
                        self.state = 1330
                        self.expr(0)




                self.state = 1349
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.WINDOW_:
                    self.state = 1335
                    self.match(SQLiteParser.WINDOW_)
                    self.state = 1336
                    self.window_name()
                    self.state = 1337
                    self.match(SQLiteParser.AS_)
                    self.state = 1338
                    self.window_defn()
                    self.state = 1346
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1339
                        self.match(SQLiteParser.COMMA)
                        self.state = 1340
                        self.window_name()
                        self.state = 1341
                        self.match(SQLiteParser.AS_)
                        self.state = 1342
                        self.window_defn()
                        self.state = 1348
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                pass
            elif token in [SQLiteParser.VALUES_]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1351
                self.match(SQLiteParser.VALUES_)
                self.state = 1352
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1353
                self.expr(0)
                self.state = 1358
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1354
                    self.match(SQLiteParser.COMMA)
                    self.state = 1355
                    self.expr(0)
                    self.state = 1360
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1361
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1376
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1362
                    self.match(SQLiteParser.COMMA)
                    self.state = 1363
                    self.match(SQLiteParser.OPEN_PAR)
                    self.state = 1364
                    self.expr(0)
                    self.state = 1369
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1365
                        self.match(SQLiteParser.COMMA)
                        self.state = 1366
                        self.expr(0)
                        self.state = 1371
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1372
                    self.match(SQLiteParser.CLOSE_PAR)
                    self.state = 1378
                    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 Factored_select_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_factored_select_stmt

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

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




    def factored_select_stmt(self):

        localctx = SQLiteParser.Factored_select_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_factored_select_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1381
            self.select_stmt()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simple_select_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def select_core(self):
            return self.getTypedRuleContext(SQLiteParser.Select_coreContext,0)


        def common_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Common_table_stmtContext,0)


        def order_by_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0)


        def limit_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_simple_select_stmt

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

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




    def simple_select_stmt(self):

        localctx = SQLiteParser.Simple_select_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_simple_select_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1384
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WITH_:
                self.state = 1383
                self.common_table_stmt()


            self.state = 1386
            self.select_core()
            self.state = 1388
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.ORDER_:
                self.state = 1387
                self.order_by_stmt()


            self.state = 1391
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.LIMIT_:
                self.state = 1390
                self.limit_stmt()


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


    class Compound_select_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def select_core(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_coreContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_coreContext,i)


        def common_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Common_table_stmtContext,0)


        def order_by_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0)


        def limit_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0)


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

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

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

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_compound_select_stmt

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

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




    def compound_select_stmt(self):

        localctx = SQLiteParser.Compound_select_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_compound_select_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WITH_:
                self.state = 1393
                self.common_table_stmt()


            self.state = 1396
            self.select_core()
            self.state = 1406 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1403
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.UNION_]:
                    self.state = 1397
                    self.match(SQLiteParser.UNION_)
                    self.state = 1399
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.ALL_:
                        self.state = 1398
                        self.match(SQLiteParser.ALL_)


                    pass
                elif token in [SQLiteParser.INTERSECT_]:
                    self.state = 1401
                    self.match(SQLiteParser.INTERSECT_)
                    pass
                elif token in [SQLiteParser.EXCEPT_]:
                    self.state = 1402
                    self.match(SQLiteParser.EXCEPT_)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1405
                self.select_core()
                self.state = 1408 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SQLiteParser.EXCEPT_ or _la==SQLiteParser.INTERSECT_ or _la==SQLiteParser.UNION_):
                    break

            self.state = 1411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.ORDER_:
                self.state = 1410
                self.order_by_stmt()


            self.state = 1414
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.LIMIT_:
                self.state = 1413
                self.limit_stmt()


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


    class Table_or_subqueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def table_alias(self):
            return self.getTypedRuleContext(SQLiteParser.Table_aliasContext,0)


        def INDEXED_(self):
            return self.getToken(SQLiteParser.INDEXED_, 0)

        def BY_(self):
            return self.getToken(SQLiteParser.BY_, 0)

        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def table_function_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_function_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

        def table_or_subquery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i)


        def join_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Join_clauseContext,0)


        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_or_subquery

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

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




    def table_or_subquery(self):

        localctx = SQLiteParser.Table_or_subqueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_table_or_subquery)
        self._la = 0 # Token type
        try:
            self.state = 1480
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1419
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
                if la_ == 1:
                    self.state = 1416
                    self.schema_name()
                    self.state = 1417
                    self.match(SQLiteParser.DOT)


                self.state = 1421
                self.table_name()
                self.state = 1426
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
                if la_ == 1:
                    self.state = 1423
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
                    if la_ == 1:
                        self.state = 1422
                        self.match(SQLiteParser.AS_)


                    self.state = 1425
                    self.table_alias()


                self.state = 1433
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.INDEXED_]:
                    self.state = 1428
                    self.match(SQLiteParser.INDEXED_)
                    self.state = 1429
                    self.match(SQLiteParser.BY_)
                    self.state = 1430
                    self.index_name()
                    pass
                elif token in [SQLiteParser.NOT_]:
                    self.state = 1431
                    self.match(SQLiteParser.NOT_)
                    self.state = 1432
                    self.match(SQLiteParser.INDEXED_)
                    pass
                elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.CLOSE_PAR, SQLiteParser.COMMA, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.ATTACH_, SQLiteParser.BEGIN_, SQLiteParser.COMMIT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.DELETE_, SQLiteParser.DETACH_, SQLiteParser.DROP_, SQLiteParser.END_, SQLiteParser.EXCEPT_, SQLiteParser.EXPLAIN_, SQLiteParser.GROUP_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INTERSECT_, SQLiteParser.JOIN_, SQLiteParser.LEFT_, SQLiteParser.LIMIT_, SQLiteParser.NATURAL_, SQLiteParser.ON_, SQLiteParser.ORDER_, SQLiteParser.PRAGMA_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.REPLACE_, SQLiteParser.RETURNING_, SQLiteParser.ROLLBACK_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.UNION_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WINDOW_]:
                    pass
                else:
                    pass
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1438
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
                if la_ == 1:
                    self.state = 1435
                    self.schema_name()
                    self.state = 1436
                    self.match(SQLiteParser.DOT)


                self.state = 1440
                self.table_function_name()
                self.state = 1441
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1442
                self.expr(0)
                self.state = 1447
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1443
                    self.match(SQLiteParser.COMMA)
                    self.state = 1444
                    self.expr(0)
                    self.state = 1449
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1450
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1455
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
                if la_ == 1:
                    self.state = 1452
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,202,self._ctx)
                    if la_ == 1:
                        self.state = 1451
                        self.match(SQLiteParser.AS_)


                    self.state = 1454
                    self.table_alias()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1457
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1467
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
                if la_ == 1:
                    self.state = 1458
                    self.table_or_subquery()
                    self.state = 1463
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1459
                        self.match(SQLiteParser.COMMA)
                        self.state = 1460
                        self.table_or_subquery()
                        self.state = 1465
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass

                elif la_ == 2:
                    self.state = 1466
                    self.join_clause()
                    pass


                self.state = 1469
                self.match(SQLiteParser.CLOSE_PAR)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1471
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1472
                self.select_stmt()
                self.state = 1473
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1478
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,207,self._ctx)
                if la_ == 1:
                    self.state = 1475
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
                    if la_ == 1:
                        self.state = 1474
                        self.match(SQLiteParser.AS_)


                    self.state = 1477
                    self.table_alias()


                pass


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


    class Result_columnContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


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

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


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


        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_result_column

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

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




    def result_column(self):

        localctx = SQLiteParser.Result_columnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_result_column)
        self._la = 0 # Token type
        try:
            self.state = 1494
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,211,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1482
                self.match(SQLiteParser.STAR)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1483
                self.table_name()
                self.state = 1484
                self.match(SQLiteParser.DOT)
                self.state = 1485
                self.match(SQLiteParser.STAR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1487
                self.expr(0)
                self.state = 1492
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.AS_ or _la==SQLiteParser.IDENTIFIER or _la==SQLiteParser.STRING_LITERAL:
                    self.state = 1489
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.AS_:
                        self.state = 1488
                        self.match(SQLiteParser.AS_)


                    self.state = 1491
                    self.column_alias()


                pass


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


    class Join_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def JOIN_(self):
            return self.getToken(SQLiteParser.JOIN_, 0)

        def NATURAL_(self):
            return self.getToken(SQLiteParser.NATURAL_, 0)

        def LEFT_(self):
            return self.getToken(SQLiteParser.LEFT_, 0)

        def INNER_(self):
            return self.getToken(SQLiteParser.INNER_, 0)

        def CROSS_(self):
            return self.getToken(SQLiteParser.CROSS_, 0)

        def OUTER_(self):
            return self.getToken(SQLiteParser.OUTER_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_join_operator

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

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




    def join_operator(self):

        localctx = SQLiteParser.Join_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_join_operator)
        self._la = 0 # Token type
        try:
            self.state = 1509
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.COMMA]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1496
                self.match(SQLiteParser.COMMA)
                pass
            elif token in [SQLiteParser.CROSS_, SQLiteParser.INNER_, SQLiteParser.JOIN_, SQLiteParser.LEFT_, SQLiteParser.NATURAL_]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1498
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.NATURAL_:
                    self.state = 1497
                    self.match(SQLiteParser.NATURAL_)


                self.state = 1506
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.LEFT_]:
                    self.state = 1500
                    self.match(SQLiteParser.LEFT_)
                    self.state = 1502
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.OUTER_:
                        self.state = 1501
                        self.match(SQLiteParser.OUTER_)


                    pass
                elif token in [SQLiteParser.INNER_]:
                    self.state = 1504
                    self.match(SQLiteParser.INNER_)
                    pass
                elif token in [SQLiteParser.CROSS_]:
                    self.state = 1505
                    self.match(SQLiteParser.CROSS_)
                    pass
                elif token in [SQLiteParser.JOIN_]:
                    pass
                else:
                    pass
                self.state = 1508
                self.match(SQLiteParser.JOIN_)
                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 Join_constraintContext(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(SQLiteParser.ON_, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def USING_(self):
            return self.getToken(SQLiteParser.USING_, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_join_constraint

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

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




    def join_constraint(self):

        localctx = SQLiteParser.Join_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_join_constraint)
        self._la = 0 # Token type
        try:
            self.state = 1525
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.ON_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1511
                self.match(SQLiteParser.ON_)
                self.state = 1512
                self.expr(0)
                pass
            elif token in [SQLiteParser.USING_]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1513
                self.match(SQLiteParser.USING_)
                self.state = 1514
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1515
                self.column_name()
                self.state = 1520
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1516
                    self.match(SQLiteParser.COMMA)
                    self.state = 1517
                    self.column_name()
                    self.state = 1522
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1523
                self.match(SQLiteParser.CLOSE_PAR)
                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 Compound_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNION_(self):
            return self.getToken(SQLiteParser.UNION_, 0)

        def ALL_(self):
            return self.getToken(SQLiteParser.ALL_, 0)

        def INTERSECT_(self):
            return self.getToken(SQLiteParser.INTERSECT_, 0)

        def EXCEPT_(self):
            return self.getToken(SQLiteParser.EXCEPT_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_compound_operator

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

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




    def compound_operator(self):

        localctx = SQLiteParser.Compound_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_compound_operator)
        self._la = 0 # Token type
        try:
            self.state = 1533
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.UNION_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1527
                self.match(SQLiteParser.UNION_)
                self.state = 1529
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ALL_:
                    self.state = 1528
                    self.match(SQLiteParser.ALL_)


                pass
            elif token in [SQLiteParser.INTERSECT_]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1531
                self.match(SQLiteParser.INTERSECT_)
                pass
            elif token in [SQLiteParser.EXCEPT_]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1532
                self.match(SQLiteParser.EXCEPT_)
                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 Update_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UPDATE_(self):
            return self.getToken(SQLiteParser.UPDATE_, 0)

        def qualified_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0)


        def SET_(self):
            return self.getToken(SQLiteParser.SET_, 0)

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


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


        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def OR_(self):
            return self.getToken(SQLiteParser.OR_, 0)

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

        def FROM_(self):
            return self.getToken(SQLiteParser.FROM_, 0)

        def WHERE_(self):
            return self.getToken(SQLiteParser.WHERE_, 0)

        def returning_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Returning_clauseContext,0)


        def ROLLBACK_(self):
            return self.getToken(SQLiteParser.ROLLBACK_, 0)

        def ABORT_(self):
            return self.getToken(SQLiteParser.ABORT_, 0)

        def REPLACE_(self):
            return self.getToken(SQLiteParser.REPLACE_, 0)

        def FAIL_(self):
            return self.getToken(SQLiteParser.FAIL_, 0)

        def IGNORE_(self):
            return self.getToken(SQLiteParser.IGNORE_, 0)

        def table_or_subquery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i)


        def join_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Join_clauseContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_update_stmt

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

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




    def update_stmt(self):

        localctx = SQLiteParser.Update_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_update_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1536
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WITH_:
                self.state = 1535
                self.with_clause()


            self.state = 1538
            self.match(SQLiteParser.UPDATE_)
            self.state = 1541
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,221,self._ctx)
            if la_ == 1:
                self.state = 1539
                self.match(SQLiteParser.OR_)
                self.state = 1540
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.ABORT_ or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.FAIL_ - 72)) | (1 << (SQLiteParser.IGNORE_ - 72)) | (1 << (SQLiteParser.REPLACE_ - 72)) | (1 << (SQLiteParser.ROLLBACK_ - 72)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1543
            self.qualified_table_name()
            self.state = 1544
            self.match(SQLiteParser.SET_)
            self.state = 1547
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,222,self._ctx)
            if la_ == 1:
                self.state = 1545
                self.column_name()
                pass

            elif la_ == 2:
                self.state = 1546
                self.column_name_list()
                pass


            self.state = 1549
            self.match(SQLiteParser.ASSIGN)
            self.state = 1550
            self.expr(0)
            self.state = 1561
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1551
                self.match(SQLiteParser.COMMA)
                self.state = 1554
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
                if la_ == 1:
                    self.state = 1552
                    self.column_name()
                    pass

                elif la_ == 2:
                    self.state = 1553
                    self.column_name_list()
                    pass


                self.state = 1556
                self.match(SQLiteParser.ASSIGN)
                self.state = 1557
                self.expr(0)
                self.state = 1563
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1576
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.FROM_:
                self.state = 1564
                self.match(SQLiteParser.FROM_)
                self.state = 1574
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,226,self._ctx)
                if la_ == 1:
                    self.state = 1565
                    self.table_or_subquery()
                    self.state = 1570
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1566
                        self.match(SQLiteParser.COMMA)
                        self.state = 1567
                        self.table_or_subquery()
                        self.state = 1572
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass

                elif la_ == 2:
                    self.state = 1573
                    self.join_clause()
                    pass




            self.state = 1580
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WHERE_:
                self.state = 1578
                self.match(SQLiteParser.WHERE_)
                self.state = 1579
                self.expr(0)


            self.state = 1583
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.RETURNING_:
                self.state = 1582
                self.returning_clause()


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


    class Column_name_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_column_name_list

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

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




    def column_name_list(self):

        localctx = SQLiteParser.Column_name_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_column_name_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1585
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1586
            self.column_name()
            self.state = 1591
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1587
                self.match(SQLiteParser.COMMA)
                self.state = 1588
                self.column_name()
                self.state = 1593
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1594
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Update_stmt_limitedContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UPDATE_(self):
            return self.getToken(SQLiteParser.UPDATE_, 0)

        def qualified_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0)


        def SET_(self):
            return self.getToken(SQLiteParser.SET_, 0)

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


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


        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def OR_(self):
            return self.getToken(SQLiteParser.OR_, 0)

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

        def WHERE_(self):
            return self.getToken(SQLiteParser.WHERE_, 0)

        def returning_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Returning_clauseContext,0)


        def limit_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0)


        def ROLLBACK_(self):
            return self.getToken(SQLiteParser.ROLLBACK_, 0)

        def ABORT_(self):
            return self.getToken(SQLiteParser.ABORT_, 0)

        def REPLACE_(self):
            return self.getToken(SQLiteParser.REPLACE_, 0)

        def FAIL_(self):
            return self.getToken(SQLiteParser.FAIL_, 0)

        def IGNORE_(self):
            return self.getToken(SQLiteParser.IGNORE_, 0)

        def order_by_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_update_stmt_limited

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

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




    def update_stmt_limited(self):

        localctx = SQLiteParser.Update_stmt_limitedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_update_stmt_limited)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1597
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WITH_:
                self.state = 1596
                self.with_clause()


            self.state = 1599
            self.match(SQLiteParser.UPDATE_)
            self.state = 1602
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,232,self._ctx)
            if la_ == 1:
                self.state = 1600
                self.match(SQLiteParser.OR_)
                self.state = 1601
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.ABORT_ or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.FAIL_ - 72)) | (1 << (SQLiteParser.IGNORE_ - 72)) | (1 << (SQLiteParser.REPLACE_ - 72)) | (1 << (SQLiteParser.ROLLBACK_ - 72)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1604
            self.qualified_table_name()
            self.state = 1605
            self.match(SQLiteParser.SET_)
            self.state = 1608
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
            if la_ == 1:
                self.state = 1606
                self.column_name()
                pass

            elif la_ == 2:
                self.state = 1607
                self.column_name_list()
                pass


            self.state = 1610
            self.match(SQLiteParser.ASSIGN)
            self.state = 1611
            self.expr(0)
            self.state = 1622
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1612
                self.match(SQLiteParser.COMMA)
                self.state = 1615
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
                if la_ == 1:
                    self.state = 1613
                    self.column_name()
                    pass

                elif la_ == 2:
                    self.state = 1614
                    self.column_name_list()
                    pass


                self.state = 1617
                self.match(SQLiteParser.ASSIGN)
                self.state = 1618
                self.expr(0)
                self.state = 1624
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1627
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.WHERE_:
                self.state = 1625
                self.match(SQLiteParser.WHERE_)
                self.state = 1626
                self.expr(0)


            self.state = 1630
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.RETURNING_:
                self.state = 1629
                self.returning_clause()


            self.state = 1636
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.LIMIT_ or _la==SQLiteParser.ORDER_:
                self.state = 1633
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ORDER_:
                    self.state = 1632
                    self.order_by_stmt()


                self.state = 1635
                self.limit_stmt()


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


    class Qualified_table_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


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

        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def alias(self):
            return self.getTypedRuleContext(SQLiteParser.AliasContext,0)


        def INDEXED_(self):
            return self.getToken(SQLiteParser.INDEXED_, 0)

        def BY_(self):
            return self.getToken(SQLiteParser.BY_, 0)

        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_qualified_table_name

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

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




    def qualified_table_name(self):

        localctx = SQLiteParser.Qualified_table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_qualified_table_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1641
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,240,self._ctx)
            if la_ == 1:
                self.state = 1638
                self.schema_name()
                self.state = 1639
                self.match(SQLiteParser.DOT)


            self.state = 1643
            self.table_name()
            self.state = 1646
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.AS_:
                self.state = 1644
                self.match(SQLiteParser.AS_)
                self.state = 1645
                self.alias()


            self.state = 1653
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.INDEXED_]:
                self.state = 1648
                self.match(SQLiteParser.INDEXED_)
                self.state = 1649
                self.match(SQLiteParser.BY_)
                self.state = 1650
                self.index_name()
                pass
            elif token in [SQLiteParser.NOT_]:
                self.state = 1651
                self.match(SQLiteParser.NOT_)
                self.state = 1652
                self.match(SQLiteParser.INDEXED_)
                pass
            elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.ATTACH_, SQLiteParser.BEGIN_, SQLiteParser.COMMIT_, SQLiteParser.CREATE_, SQLiteParser.DELETE_, SQLiteParser.DETACH_, SQLiteParser.DROP_, SQLiteParser.END_, SQLiteParser.EXPLAIN_, SQLiteParser.INSERT_, SQLiteParser.LIMIT_, SQLiteParser.ORDER_, SQLiteParser.PRAGMA_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.REPLACE_, SQLiteParser.RETURNING_, SQLiteParser.ROLLBACK_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.UPDATE_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.WHERE_, SQLiteParser.WITH_]:
                pass
            else:
                pass
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vacuum_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VACUUM_(self):
            return self.getToken(SQLiteParser.VACUUM_, 0)

        def schema_name(self):
            return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0)


        def INTO_(self):
            return self.getToken(SQLiteParser.INTO_, 0)

        def filename(self):
            return self.getTypedRuleContext(SQLiteParser.FilenameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_vacuum_stmt

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

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




    def vacuum_stmt(self):

        localctx = SQLiteParser.Vacuum_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_vacuum_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1655
            self.match(SQLiteParser.VACUUM_)
            self.state = 1657
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,243,self._ctx)
            if la_ == 1:
                self.state = 1656
                self.schema_name()


            self.state = 1661
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.INTO_:
                self.state = 1659
                self.match(SQLiteParser.INTO_)
                self.state = 1660
                self.filename()


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


    class Filter_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FILTER_(self):
            return self.getToken(SQLiteParser.FILTER_, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def WHERE_(self):
            return self.getToken(SQLiteParser.WHERE_, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_filter_clause

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

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




    def filter_clause(self):

        localctx = SQLiteParser.Filter_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_filter_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1663
            self.match(SQLiteParser.FILTER_)
            self.state = 1664
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1665
            self.match(SQLiteParser.WHERE_)
            self.state = 1666
            self.expr(0)
            self.state = 1667
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Window_defnContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def ORDER_(self):
            return self.getToken(SQLiteParser.ORDER_, 0)

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

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


        def base_window_name(self):
            return self.getTypedRuleContext(SQLiteParser.Base_window_nameContext,0)


        def PARTITION_(self):
            return self.getToken(SQLiteParser.PARTITION_, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def frame_spec(self):
            return self.getTypedRuleContext(SQLiteParser.Frame_specContext,0)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_window_defn

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

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




    def window_defn(self):

        localctx = SQLiteParser.Window_defnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_window_defn)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1669
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1671
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
            if la_ == 1:
                self.state = 1670
                self.base_window_name()


            self.state = 1683
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.PARTITION_:
                self.state = 1673
                self.match(SQLiteParser.PARTITION_)
                self.state = 1674
                self.match(SQLiteParser.BY_)
                self.state = 1675
                self.expr(0)
                self.state = 1680
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1676
                    self.match(SQLiteParser.COMMA)
                    self.state = 1677
                    self.expr(0)
                    self.state = 1682
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1685
            self.match(SQLiteParser.ORDER_)
            self.state = 1686
            self.match(SQLiteParser.BY_)
            self.state = 1687
            self.ordering_term()
            self.state = 1692
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1688
                self.match(SQLiteParser.COMMA)
                self.state = 1689
                self.ordering_term()
                self.state = 1694
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1696
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.ROWS_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)))) != 0):
                self.state = 1695
                self.frame_spec()


            self.state = 1698
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Over_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OVER_(self):
            return self.getToken(SQLiteParser.OVER_, 0)

        def window_name(self):
            return self.getTypedRuleContext(SQLiteParser.Window_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def base_window_name(self):
            return self.getTypedRuleContext(SQLiteParser.Base_window_nameContext,0)


        def PARTITION_(self):
            return self.getToken(SQLiteParser.PARTITION_, 0)

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def ORDER_(self):
            return self.getToken(SQLiteParser.ORDER_, 0)

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


        def frame_spec(self):
            return self.getTypedRuleContext(SQLiteParser.Frame_specContext,0)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_over_clause

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

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




    def over_clause(self):

        localctx = SQLiteParser.Over_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_over_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1700
            self.match(SQLiteParser.OVER_)
            self.state = 1734
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
            if la_ == 1:
                self.state = 1701
                self.window_name()
                pass

            elif la_ == 2:
                self.state = 1702
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1704
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,250,self._ctx)
                if la_ == 1:
                    self.state = 1703
                    self.base_window_name()


                self.state = 1716
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.PARTITION_:
                    self.state = 1706
                    self.match(SQLiteParser.PARTITION_)
                    self.state = 1707
                    self.match(SQLiteParser.BY_)
                    self.state = 1708
                    self.expr(0)
                    self.state = 1713
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1709
                        self.match(SQLiteParser.COMMA)
                        self.state = 1710
                        self.expr(0)
                        self.state = 1715
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1728
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ORDER_:
                    self.state = 1718
                    self.match(SQLiteParser.ORDER_)
                    self.state = 1719
                    self.match(SQLiteParser.BY_)
                    self.state = 1720
                    self.ordering_term()
                    self.state = 1725
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1721
                        self.match(SQLiteParser.COMMA)
                        self.state = 1722
                        self.ordering_term()
                        self.state = 1727
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1731
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.ROWS_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)))) != 0):
                    self.state = 1730
                    self.frame_spec()


                self.state = 1733
                self.match(SQLiteParser.CLOSE_PAR)
                pass


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


    class Frame_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def frame_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Frame_clauseContext,0)


        def EXCLUDE_(self):
            return self.getToken(SQLiteParser.EXCLUDE_, 0)

        def CURRENT_(self):
            return self.getToken(SQLiteParser.CURRENT_, 0)

        def ROW_(self):
            return self.getToken(SQLiteParser.ROW_, 0)

        def GROUP_(self):
            return self.getToken(SQLiteParser.GROUP_, 0)

        def TIES_(self):
            return self.getToken(SQLiteParser.TIES_, 0)

        def NO_(self):
            return self.getToken(SQLiteParser.NO_, 0)

        def OTHERS_(self):
            return self.getToken(SQLiteParser.OTHERS_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_frame_spec

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

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




    def frame_spec(self):

        localctx = SQLiteParser.Frame_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_frame_spec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1736
            self.frame_clause()
            self.state = 1744
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.EXCLUDE_]:
                self.state = 1737
                self.match(SQLiteParser.EXCLUDE_)

                self.state = 1738
                self.match(SQLiteParser.NO_)
                self.state = 1739
                self.match(SQLiteParser.OTHERS_)
                pass
            elif token in [SQLiteParser.CURRENT_]:
                self.state = 1740
                self.match(SQLiteParser.CURRENT_)
                self.state = 1741
                self.match(SQLiteParser.ROW_)
                pass
            elif token in [SQLiteParser.GROUP_]:
                self.state = 1742
                self.match(SQLiteParser.GROUP_)
                pass
            elif token in [SQLiteParser.TIES_]:
                self.state = 1743
                self.match(SQLiteParser.TIES_)
                pass
            elif token in [SQLiteParser.CLOSE_PAR]:
                pass
            else:
                pass
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Frame_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RANGE_(self):
            return self.getToken(SQLiteParser.RANGE_, 0)

        def ROWS_(self):
            return self.getToken(SQLiteParser.ROWS_, 0)

        def GROUPS_(self):
            return self.getToken(SQLiteParser.GROUPS_, 0)

        def frame_single(self):
            return self.getTypedRuleContext(SQLiteParser.Frame_singleContext,0)


        def BETWEEN_(self):
            return self.getToken(SQLiteParser.BETWEEN_, 0)

        def frame_left(self):
            return self.getTypedRuleContext(SQLiteParser.Frame_leftContext,0)


        def AND_(self):
            return self.getToken(SQLiteParser.AND_, 0)

        def frame_right(self):
            return self.getTypedRuleContext(SQLiteParser.Frame_rightContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_frame_clause

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

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




    def frame_clause(self):

        localctx = SQLiteParser.Frame_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_frame_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1746
            _la = self._input.LA(1)
            if not(((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.ROWS_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1753
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
            if la_ == 1:
                self.state = 1747
                self.frame_single()
                pass

            elif la_ == 2:
                self.state = 1748
                self.match(SQLiteParser.BETWEEN_)
                self.state = 1749
                self.frame_left()
                self.state = 1750
                self.match(SQLiteParser.AND_)
                self.state = 1751
                self.frame_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 Simple_function_invocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def simple_func(self):
            return self.getTypedRuleContext(SQLiteParser.Simple_funcContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


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

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_simple_function_invocation

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

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




    def simple_function_invocation(self):

        localctx = SQLiteParser.Simple_function_invocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_simple_function_invocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1755
            self.simple_func()
            self.state = 1756
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1766
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]:
                self.state = 1757
                self.expr(0)
                self.state = 1762
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1758
                    self.match(SQLiteParser.COMMA)
                    self.state = 1759
                    self.expr(0)
                    self.state = 1764
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [SQLiteParser.STAR]:
                self.state = 1765
                self.match(SQLiteParser.STAR)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1768
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Aggregate_function_invocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def aggregate_func(self):
            return self.getTypedRuleContext(SQLiteParser.Aggregate_funcContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


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

        def filter_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Filter_clauseContext,0)


        def DISTINCT_(self):
            return self.getToken(SQLiteParser.DISTINCT_, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_aggregate_function_invocation

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

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




    def aggregate_function_invocation(self):

        localctx = SQLiteParser.Aggregate_function_invocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_aggregate_function_invocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1770
            self.aggregate_func()
            self.state = 1771
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1784
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]:
                self.state = 1773
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
                if la_ == 1:
                    self.state = 1772
                    self.match(SQLiteParser.DISTINCT_)


                self.state = 1775
                self.expr(0)
                self.state = 1780
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1776
                    self.match(SQLiteParser.COMMA)
                    self.state = 1777
                    self.expr(0)
                    self.state = 1782
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [SQLiteParser.STAR]:
                self.state = 1783
                self.match(SQLiteParser.STAR)
                pass
            elif token in [SQLiteParser.CLOSE_PAR]:
                pass
            else:
                pass
            self.state = 1786
            self.match(SQLiteParser.CLOSE_PAR)
            self.state = 1788
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.FILTER_:
                self.state = 1787
                self.filter_clause()


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


    class Window_function_invocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def window_function(self):
            return self.getTypedRuleContext(SQLiteParser.Window_functionContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def OVER_(self):
            return self.getToken(SQLiteParser.OVER_, 0)

        def window_defn(self):
            return self.getTypedRuleContext(SQLiteParser.Window_defnContext,0)


        def window_name(self):
            return self.getTypedRuleContext(SQLiteParser.Window_nameContext,0)


        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


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

        def filter_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Filter_clauseContext,0)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_window_function_invocation

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

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




    def window_function_invocation(self):

        localctx = SQLiteParser.Window_function_invocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_window_function_invocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1790
            self.window_function()
            self.state = 1791
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1801
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]:
                self.state = 1792
                self.expr(0)
                self.state = 1797
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1793
                    self.match(SQLiteParser.COMMA)
                    self.state = 1794
                    self.expr(0)
                    self.state = 1799
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [SQLiteParser.STAR]:
                self.state = 1800
                self.match(SQLiteParser.STAR)
                pass
            elif token in [SQLiteParser.CLOSE_PAR]:
                pass
            else:
                pass
            self.state = 1803
            self.match(SQLiteParser.CLOSE_PAR)
            self.state = 1805
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.FILTER_:
                self.state = 1804
                self.filter_clause()


            self.state = 1807
            self.match(SQLiteParser.OVER_)
            self.state = 1810
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,268,self._ctx)
            if la_ == 1:
                self.state = 1808
                self.window_defn()
                pass

            elif la_ == 2:
                self.state = 1809
                self.window_name()
                pass


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


    class Common_table_stmtContext(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(SQLiteParser.WITH_, 0)

        def common_table_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Common_table_expressionContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Common_table_expressionContext,i)


        def RECURSIVE_(self):
            return self.getToken(SQLiteParser.RECURSIVE_, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_common_table_stmt

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

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




    def common_table_stmt(self):

        localctx = SQLiteParser.Common_table_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_common_table_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1812
            self.match(SQLiteParser.WITH_)
            self.state = 1814
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,269,self._ctx)
            if la_ == 1:
                self.state = 1813
                self.match(SQLiteParser.RECURSIVE_)


            self.state = 1816
            self.common_table_expression()
            self.state = 1821
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1817
                self.match(SQLiteParser.COMMA)
                self.state = 1818
                self.common_table_expression()
                self.state = 1823
                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 Order_by_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ORDER_(self):
            return self.getToken(SQLiteParser.ORDER_, 0)

        def BY_(self):
            return self.getToken(SQLiteParser.BY_, 0)

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_order_by_stmt

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

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




    def order_by_stmt(self):

        localctx = SQLiteParser.Order_by_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_order_by_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1824
            self.match(SQLiteParser.ORDER_)
            self.state = 1825
            self.match(SQLiteParser.BY_)
            self.state = 1826
            self.ordering_term()
            self.state = 1831
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1827
                self.match(SQLiteParser.COMMA)
                self.state = 1828
                self.ordering_term()
                self.state = 1833
                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 Limit_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LIMIT_(self):
            return self.getToken(SQLiteParser.LIMIT_, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def OFFSET_(self):
            return self.getToken(SQLiteParser.OFFSET_, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_limit_stmt

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

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




    def limit_stmt(self):

        localctx = SQLiteParser.Limit_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_limit_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1834
            self.match(SQLiteParser.LIMIT_)
            self.state = 1835
            self.expr(0)
            self.state = 1838
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.COMMA or _la==SQLiteParser.OFFSET_:
                self.state = 1836
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.COMMA or _la==SQLiteParser.OFFSET_):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1837
                self.expr(0)


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


    class Ordering_termContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def COLLATE_(self):
            return self.getToken(SQLiteParser.COLLATE_, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def asc_desc(self):
            return self.getTypedRuleContext(SQLiteParser.Asc_descContext,0)


        def NULLS_(self):
            return self.getToken(SQLiteParser.NULLS_, 0)

        def FIRST_(self):
            return self.getToken(SQLiteParser.FIRST_, 0)

        def LAST_(self):
            return self.getToken(SQLiteParser.LAST_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_ordering_term

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

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




    def ordering_term(self):

        localctx = SQLiteParser.Ordering_termContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_ordering_term)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1840
            self.expr(0)
            self.state = 1843
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.COLLATE_:
                self.state = 1841
                self.match(SQLiteParser.COLLATE_)
                self.state = 1842
                self.collation_name()


            self.state = 1846
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_:
                self.state = 1845
                self.asc_desc()


            self.state = 1850
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.NULLS_:
                self.state = 1848
                self.match(SQLiteParser.NULLS_)
                self.state = 1849
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.FIRST_ or _la==SQLiteParser.LAST_):
                    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 Asc_descContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ASC_(self):
            return self.getToken(SQLiteParser.ASC_, 0)

        def DESC_(self):
            return self.getToken(SQLiteParser.DESC_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_asc_desc

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

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




    def asc_desc(self):

        localctx = SQLiteParser.Asc_descContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_asc_desc)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1852
            _la = self._input.LA(1)
            if not(_la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Frame_leftContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def PRECEDING_(self):
            return self.getToken(SQLiteParser.PRECEDING_, 0)

        def FOLLOWING_(self):
            return self.getToken(SQLiteParser.FOLLOWING_, 0)

        def CURRENT_(self):
            return self.getToken(SQLiteParser.CURRENT_, 0)

        def ROW_(self):
            return self.getToken(SQLiteParser.ROW_, 0)

        def UNBOUNDED_(self):
            return self.getToken(SQLiteParser.UNBOUNDED_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_frame_left

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

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




    def frame_left(self):

        localctx = SQLiteParser.Frame_leftContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_frame_left)
        try:
            self.state = 1864
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,276,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1854
                self.expr(0)
                self.state = 1855
                self.match(SQLiteParser.PRECEDING_)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1857
                self.expr(0)
                self.state = 1858
                self.match(SQLiteParser.FOLLOWING_)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1860
                self.match(SQLiteParser.CURRENT_)
                self.state = 1861
                self.match(SQLiteParser.ROW_)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1862
                self.match(SQLiteParser.UNBOUNDED_)
                self.state = 1863
                self.match(SQLiteParser.PRECEDING_)
                pass


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


    class Frame_rightContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def PRECEDING_(self):
            return self.getToken(SQLiteParser.PRECEDING_, 0)

        def FOLLOWING_(self):
            return self.getToken(SQLiteParser.FOLLOWING_, 0)

        def CURRENT_(self):
            return self.getToken(SQLiteParser.CURRENT_, 0)

        def ROW_(self):
            return self.getToken(SQLiteParser.ROW_, 0)

        def UNBOUNDED_(self):
            return self.getToken(SQLiteParser.UNBOUNDED_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_frame_right

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

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




    def frame_right(self):

        localctx = SQLiteParser.Frame_rightContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_frame_right)
        try:
            self.state = 1876
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,277,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1866
                self.expr(0)
                self.state = 1867
                self.match(SQLiteParser.PRECEDING_)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1869
                self.expr(0)
                self.state = 1870
                self.match(SQLiteParser.FOLLOWING_)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1872
                self.match(SQLiteParser.CURRENT_)
                self.state = 1873
                self.match(SQLiteParser.ROW_)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1874
                self.match(SQLiteParser.UNBOUNDED_)
                self.state = 1875
                self.match(SQLiteParser.FOLLOWING_)
                pass


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


    class Frame_singleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def PRECEDING_(self):
            return self.getToken(SQLiteParser.PRECEDING_, 0)

        def UNBOUNDED_(self):
            return self.getToken(SQLiteParser.UNBOUNDED_, 0)

        def CURRENT_(self):
            return self.getToken(SQLiteParser.CURRENT_, 0)

        def ROW_(self):
            return self.getToken(SQLiteParser.ROW_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_frame_single

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

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




    def frame_single(self):

        localctx = SQLiteParser.Frame_singleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_frame_single)
        try:
            self.state = 1885
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,278,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1878
                self.expr(0)
                self.state = 1879
                self.match(SQLiteParser.PRECEDING_)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1881
                self.match(SQLiteParser.UNBOUNDED_)
                self.state = 1882
                self.match(SQLiteParser.PRECEDING_)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1883
                self.match(SQLiteParser.CURRENT_)
                self.state = 1884
                self.match(SQLiteParser.ROW_)
                pass


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


    class Window_functionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


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

        def OVER_(self):
            return self.getToken(SQLiteParser.OVER_, 0)

        def order_by_expr_asc_desc(self):
            return self.getTypedRuleContext(SQLiteParser.Order_by_expr_asc_descContext,0)


        def FIRST_VALUE_(self):
            return self.getToken(SQLiteParser.FIRST_VALUE_, 0)

        def LAST_VALUE_(self):
            return self.getToken(SQLiteParser.LAST_VALUE_, 0)

        def partition_by(self):
            return self.getTypedRuleContext(SQLiteParser.Partition_byContext,0)


        def frame_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Frame_clauseContext,0)


        def CUME_DIST_(self):
            return self.getToken(SQLiteParser.CUME_DIST_, 0)

        def PERCENT_RANK_(self):
            return self.getToken(SQLiteParser.PERCENT_RANK_, 0)

        def order_by_expr(self):
            return self.getTypedRuleContext(SQLiteParser.Order_by_exprContext,0)


        def DENSE_RANK_(self):
            return self.getToken(SQLiteParser.DENSE_RANK_, 0)

        def RANK_(self):
            return self.getToken(SQLiteParser.RANK_, 0)

        def ROW_NUMBER_(self):
            return self.getToken(SQLiteParser.ROW_NUMBER_, 0)

        def LAG_(self):
            return self.getToken(SQLiteParser.LAG_, 0)

        def LEAD_(self):
            return self.getToken(SQLiteParser.LEAD_, 0)

        def offset(self):
            return self.getTypedRuleContext(SQLiteParser.OffsetContext,0)


        def default_value(self):
            return self.getTypedRuleContext(SQLiteParser.Default_valueContext,0)


        def NTH_VALUE_(self):
            return self.getToken(SQLiteParser.NTH_VALUE_, 0)

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

        def signed_number(self):
            return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0)


        def NTILE_(self):
            return self.getToken(SQLiteParser.NTILE_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_window_function

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

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




    def window_function(self):

        localctx = SQLiteParser.Window_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_window_function)
        self._la = 0 # Token type
        try:
            self.state = 1972
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.FIRST_VALUE_, SQLiteParser.LAST_VALUE_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1887
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.FIRST_VALUE_ or _la==SQLiteParser.LAST_VALUE_):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1888
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1889
                self.expr(0)
                self.state = 1890
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1891
                self.match(SQLiteParser.OVER_)
                self.state = 1892
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1894
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.PARTITION_:
                    self.state = 1893
                    self.partition_by()


                self.state = 1896
                self.order_by_expr_asc_desc()
                self.state = 1898
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.ROWS_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)))) != 0):
                    self.state = 1897
                    self.frame_clause()


                self.state = 1900
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.CUME_DIST_, SQLiteParser.PERCENT_RANK_]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1902
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.CUME_DIST_ or _la==SQLiteParser.PERCENT_RANK_):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1903
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1904
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1905
                self.match(SQLiteParser.OVER_)
                self.state = 1906
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1908
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.PARTITION_:
                    self.state = 1907
                    self.partition_by()


                self.state = 1911
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ORDER_:
                    self.state = 1910
                    self.order_by_expr()


                self.state = 1913
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.DENSE_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1914
                _la = self._input.LA(1)
                if not(((((_la - 160)) & ~0x3f) == 0 and ((1 << (_la - 160)) & ((1 << (SQLiteParser.DENSE_RANK_ - 160)) | (1 << (SQLiteParser.RANK_ - 160)) | (1 << (SQLiteParser.ROW_NUMBER_ - 160)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1915
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1916
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1917
                self.match(SQLiteParser.OVER_)
                self.state = 1918
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1920
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.PARTITION_:
                    self.state = 1919
                    self.partition_by()


                self.state = 1922
                self.order_by_expr_asc_desc()
                self.state = 1923
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.LAG_, SQLiteParser.LEAD_]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1925
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.LAG_ or _la==SQLiteParser.LEAD_):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1926
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1927
                self.expr(0)
                self.state = 1929
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,284,self._ctx)
                if la_ == 1:
                    self.state = 1928
                    self.offset()


                self.state = 1932
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.COMMA:
                    self.state = 1931
                    self.default_value()


                self.state = 1934
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1935
                self.match(SQLiteParser.OVER_)
                self.state = 1936
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1938
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.PARTITION_:
                    self.state = 1937
                    self.partition_by()


                self.state = 1940
                self.order_by_expr_asc_desc()
                self.state = 1941
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.NTH_VALUE_]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1943
                self.match(SQLiteParser.NTH_VALUE_)
                self.state = 1944
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1945
                self.expr(0)
                self.state = 1946
                self.match(SQLiteParser.COMMA)
                self.state = 1947
                self.signed_number()
                self.state = 1948
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1949
                self.match(SQLiteParser.OVER_)
                self.state = 1950
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.PARTITION_:
                    self.state = 1951
                    self.partition_by()


                self.state = 1954
                self.order_by_expr_asc_desc()
                self.state = 1956
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.ROWS_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)))) != 0):
                    self.state = 1955
                    self.frame_clause()


                self.state = 1958
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.NTILE_]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1960
                self.match(SQLiteParser.NTILE_)
                self.state = 1961
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1962
                self.expr(0)
                self.state = 1963
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1964
                self.match(SQLiteParser.OVER_)
                self.state = 1965
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1967
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.PARTITION_:
                    self.state = 1966
                    self.partition_by()


                self.state = 1969
                self.order_by_expr_asc_desc()
                self.state = 1970
                self.match(SQLiteParser.CLOSE_PAR)
                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 OffsetContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def signed_number(self):
            return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_offset

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

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




    def offset(self):

        localctx = SQLiteParser.OffsetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_offset)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1974
            self.match(SQLiteParser.COMMA)
            self.state = 1975
            self.signed_number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Default_valueContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def signed_number(self):
            return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_default_value

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

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




    def default_value(self):

        localctx = SQLiteParser.Default_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_default_value)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1977
            self.match(SQLiteParser.COMMA)
            self.state = 1978
            self.signed_number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Partition_byContext(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(SQLiteParser.PARTITION_, 0)

        def BY_(self):
            return self.getToken(SQLiteParser.BY_, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def getRuleIndex(self):
            return SQLiteParser.RULE_partition_by

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

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




    def partition_by(self):

        localctx = SQLiteParser.Partition_byContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_partition_by)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1980
            self.match(SQLiteParser.PARTITION_)
            self.state = 1981
            self.match(SQLiteParser.BY_)
            self.state = 1983 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1982
                    self.expr(0)

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

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

        def ORDER_(self):
            return self.getToken(SQLiteParser.ORDER_, 0)

        def BY_(self):
            return self.getToken(SQLiteParser.BY_, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def getRuleIndex(self):
            return SQLiteParser.RULE_order_by_expr

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

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




    def order_by_expr(self):

        localctx = SQLiteParser.Order_by_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_order_by_expr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1987
            self.match(SQLiteParser.ORDER_)
            self.state = 1988
            self.match(SQLiteParser.BY_)
            self.state = 1990 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1989
                self.expr(0)
                self.state = 1992 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.OPEN_PAR) | (1 << SQLiteParser.PLUS) | (1 << SQLiteParser.MINUS) | (1 << SQLiteParser.TILDE) | (1 << SQLiteParser.ABORT_) | (1 << SQLiteParser.ACTION_) | (1 << SQLiteParser.ADD_) | (1 << SQLiteParser.AFTER_) | (1 << SQLiteParser.ALL_) | (1 << SQLiteParser.ALTER_) | (1 << SQLiteParser.ANALYZE_) | (1 << SQLiteParser.AND_) | (1 << SQLiteParser.AS_) | (1 << SQLiteParser.ASC_) | (1 << SQLiteParser.ATTACH_) | (1 << SQLiteParser.AUTOINCREMENT_) | (1 << SQLiteParser.BEFORE_) | (1 << SQLiteParser.BEGIN_) | (1 << SQLiteParser.BETWEEN_) | (1 << SQLiteParser.BY_) | (1 << SQLiteParser.CASCADE_) | (1 << SQLiteParser.CASE_) | (1 << SQLiteParser.CAST_) | (1 << SQLiteParser.CHECK_) | (1 << SQLiteParser.COLLATE_) | (1 << SQLiteParser.COLUMN_) | (1 << SQLiteParser.COMMIT_) | (1 << SQLiteParser.CONFLICT_) | (1 << SQLiteParser.CONSTRAINT_) | (1 << SQLiteParser.CREATE_) | (1 << SQLiteParser.CROSS_) | (1 << SQLiteParser.CURRENT_DATE_) | (1 << SQLiteParser.CURRENT_TIME_) | (1 << SQLiteParser.CURRENT_TIMESTAMP_) | (1 << SQLiteParser.DATABASE_) | (1 << SQLiteParser.DEFAULT_) | (1 << SQLiteParser.DEFERRABLE_) | (1 << SQLiteParser.DEFERRED_) | (1 << SQLiteParser.DELETE_) | (1 << SQLiteParser.DESC_) | (1 << SQLiteParser.DETACH_) | (1 << SQLiteParser.DISTINCT_) | (1 << SQLiteParser.DROP_))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SQLiteParser.EACH_ - 64)) | (1 << (SQLiteParser.ELSE_ - 64)) | (1 << (SQLiteParser.END_ - 64)) | (1 << (SQLiteParser.ESCAPE_ - 64)) | (1 << (SQLiteParser.EXCEPT_ - 64)) | (1 << (SQLiteParser.EXCLUSIVE_ - 64)) | (1 << (SQLiteParser.EXISTS_ - 64)) | (1 << (SQLiteParser.EXPLAIN_ - 64)) | (1 << (SQLiteParser.FAIL_ - 64)) | (1 << (SQLiteParser.FOR_ - 64)) | (1 << (SQLiteParser.FOREIGN_ - 64)) | (1 << (SQLiteParser.FROM_ - 64)) | (1 << (SQLiteParser.FULL_ - 64)) | (1 << (SQLiteParser.GLOB_ - 64)) | (1 << (SQLiteParser.GROUP_ - 64)) | (1 << (SQLiteParser.HAVING_ - 64)) | (1 << (SQLiteParser.IF_ - 64)) | (1 << (SQLiteParser.IGNORE_ - 64)) | (1 << (SQLiteParser.IMMEDIATE_ - 64)) | (1 << (SQLiteParser.IN_ - 64)) | (1 << (SQLiteParser.INDEX_ - 64)) | (1 << (SQLiteParser.INDEXED_ - 64)) | (1 << (SQLiteParser.INITIALLY_ - 64)) | (1 << (SQLiteParser.INNER_ - 64)) | (1 << (SQLiteParser.INSERT_ - 64)) | (1 << (SQLiteParser.INSTEAD_ - 64)) | (1 << (SQLiteParser.INTERSECT_ - 64)) | (1 << (SQLiteParser.INTO_ - 64)) | (1 << (SQLiteParser.IS_ - 64)) | (1 << (SQLiteParser.ISNULL_ - 64)) | (1 << (SQLiteParser.JOIN_ - 64)) | (1 << (SQLiteParser.KEY_ - 64)) | (1 << (SQLiteParser.LEFT_ - 64)) | (1 << (SQLiteParser.LIKE_ - 64)) | (1 << (SQLiteParser.LIMIT_ - 64)) | (1 << (SQLiteParser.MATCH_ - 64)) | (1 << (SQLiteParser.NATURAL_ - 64)) | (1 << (SQLiteParser.NO_ - 64)) | (1 << (SQLiteParser.NOT_ - 64)) | (1 << (SQLiteParser.NOTNULL_ - 64)) | (1 << (SQLiteParser.NULL_ - 64)) | (1 << (SQLiteParser.OF_ - 64)) | (1 << (SQLiteParser.OFFSET_ - 64)) | (1 << (SQLiteParser.ON_ - 64)) | (1 << (SQLiteParser.OR_ - 64)) | (1 << (SQLiteParser.ORDER_ - 64)) | (1 << (SQLiteParser.OUTER_ - 64)) | (1 << (SQLiteParser.PLAN_ - 64)) | (1 << (SQLiteParser.PRAGMA_ - 64)) | (1 << (SQLiteParser.PRIMARY_ - 64)) | (1 << (SQLiteParser.QUERY_ - 64)) | (1 << (SQLiteParser.RAISE_ - 64)) | (1 << (SQLiteParser.RECURSIVE_ - 64)) | (1 << (SQLiteParser.REFERENCES_ - 64)) | (1 << (SQLiteParser.REGEXP_ - 64)) | (1 << (SQLiteParser.REINDEX_ - 64)) | (1 << (SQLiteParser.RELEASE_ - 64)) | (1 << (SQLiteParser.RENAME_ - 64)) | (1 << (SQLiteParser.REPLACE_ - 64)) | (1 << (SQLiteParser.RESTRICT_ - 64)) | (1 << (SQLiteParser.RIGHT_ - 64)) | (1 << (SQLiteParser.ROLLBACK_ - 64)) | (1 << (SQLiteParser.ROW_ - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.ROWS_ - 128)) | (1 << (SQLiteParser.SAVEPOINT_ - 128)) | (1 << (SQLiteParser.SELECT_ - 128)) | (1 << (SQLiteParser.SET_ - 128)) | (1 << (SQLiteParser.TABLE_ - 128)) | (1 << (SQLiteParser.TEMP_ - 128)) | (1 << (SQLiteParser.TEMPORARY_ - 128)) | (1 << (SQLiteParser.THEN_ - 128)) | (1 << (SQLiteParser.TO_ - 128)) | (1 << (SQLiteParser.TRANSACTION_ - 128)) | (1 << (SQLiteParser.TRIGGER_ - 128)) | (1 << (SQLiteParser.UNION_ - 128)) | (1 << (SQLiteParser.UNIQUE_ - 128)) | (1 << (SQLiteParser.UPDATE_ - 128)) | (1 << (SQLiteParser.USING_ - 128)) | (1 << (SQLiteParser.VACUUM_ - 128)) | (1 << (SQLiteParser.VALUES_ - 128)) | (1 << (SQLiteParser.VIEW_ - 128)) | (1 << (SQLiteParser.VIRTUAL_ - 128)) | (1 << (SQLiteParser.WHEN_ - 128)) | (1 << (SQLiteParser.WHERE_ - 128)) | (1 << (SQLiteParser.WITH_ - 128)) | (1 << (SQLiteParser.WITHOUT_ - 128)) | (1 << (SQLiteParser.FIRST_VALUE_ - 128)) | (1 << (SQLiteParser.OVER_ - 128)) | (1 << (SQLiteParser.PARTITION_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.PRECEDING_ - 128)) | (1 << (SQLiteParser.UNBOUNDED_ - 128)) | (1 << (SQLiteParser.CURRENT_ - 128)) | (1 << (SQLiteParser.FOLLOWING_ - 128)) | (1 << (SQLiteParser.CUME_DIST_ - 128)) | (1 << (SQLiteParser.DENSE_RANK_ - 128)) | (1 << (SQLiteParser.LAG_ - 128)) | (1 << (SQLiteParser.LAST_VALUE_ - 128)) | (1 << (SQLiteParser.LEAD_ - 128)) | (1 << (SQLiteParser.NTH_VALUE_ - 128)) | (1 << (SQLiteParser.NTILE_ - 128)) | (1 << (SQLiteParser.PERCENT_RANK_ - 128)) | (1 << (SQLiteParser.RANK_ - 128)) | (1 << (SQLiteParser.ROW_NUMBER_ - 128)) | (1 << (SQLiteParser.GENERATED_ - 128)) | (1 << (SQLiteParser.ALWAYS_ - 128)) | (1 << (SQLiteParser.STORED_ - 128)) | (1 << (SQLiteParser.TRUE_ - 128)) | (1 << (SQLiteParser.FALSE_ - 128)) | (1 << (SQLiteParser.WINDOW_ - 128)) | (1 << (SQLiteParser.NULLS_ - 128)) | (1 << (SQLiteParser.FIRST_ - 128)) | (1 << (SQLiteParser.LAST_ - 128)) | (1 << (SQLiteParser.FILTER_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)) | (1 << (SQLiteParser.EXCLUDE_ - 128)) | (1 << (SQLiteParser.IDENTIFIER - 128)) | (1 << (SQLiteParser.NUMERIC_LITERAL - 128)) | (1 << (SQLiteParser.BIND_PARAMETER - 128)) | (1 << (SQLiteParser.STRING_LITERAL - 128)) | (1 << (SQLiteParser.BLOB_LITERAL - 128)))) != 0)):
                    break

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


    class Order_by_expr_asc_descContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ORDER_(self):
            return self.getToken(SQLiteParser.ORDER_, 0)

        def BY_(self):
            return self.getToken(SQLiteParser.BY_, 0)

        def expr_asc_desc(self):
            return self.getTypedRuleContext(SQLiteParser.Expr_asc_descContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_order_by_expr_asc_desc

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

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




    def order_by_expr_asc_desc(self):

        localctx = SQLiteParser.Order_by_expr_asc_descContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_order_by_expr_asc_desc)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1994
            self.match(SQLiteParser.ORDER_)
            self.state = 1995
            self.match(SQLiteParser.BY_)
            self.state = 1996
            self.expr_asc_desc()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Expr_asc_descContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def asc_desc(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Asc_descContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Asc_descContext,i)


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

        def getRuleIndex(self):
            return SQLiteParser.RULE_expr_asc_desc

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

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




    def expr_asc_desc(self):

        localctx = SQLiteParser.Expr_asc_descContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_expr_asc_desc)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1998
            self.expr(0)
            self.state = 2000
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_:
                self.state = 1999
                self.asc_desc()


            self.state = 2009
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 2002
                self.match(SQLiteParser.COMMA)
                self.state = 2003
                self.expr(0)
                self.state = 2005
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_:
                    self.state = 2004
                    self.asc_desc()


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

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

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_initial_select

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

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




    def initial_select(self):

        localctx = SQLiteParser.Initial_selectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_initial_select)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2012
            self.select_stmt()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Recursive_selectContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_recursive_select

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

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




    def recursive_select(self):

        localctx = SQLiteParser.Recursive_selectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_recursive_select)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2014
            self.select_stmt()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Unary_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_unary_operator

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

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




    def unary_operator(self):

        localctx = SQLiteParser.Unary_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_unary_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2016
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.PLUS) | (1 << SQLiteParser.MINUS) | (1 << SQLiteParser.TILDE))) != 0) or _la==SQLiteParser.NOT_):
                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 Error_messageContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_error_message

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

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




    def error_message(self):

        localctx = SQLiteParser.Error_messageContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_error_message)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2018
            self.match(SQLiteParser.STRING_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Module_argumentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def column_def(self):
            return self.getTypedRuleContext(SQLiteParser.Column_defContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_module_argument

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

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




    def module_argument(self):

        localctx = SQLiteParser.Module_argumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_module_argument)
        try:
            self.state = 2022
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,296,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2020
                self.expr(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2021
                self.column_def()
                pass


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


    class Column_aliasContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(SQLiteParser.IDENTIFIER, 0)

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

        def getRuleIndex(self):
            return SQLiteParser.RULE_column_alias

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

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




    def column_alias(self):

        localctx = SQLiteParser.Column_aliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_column_alias)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2024
            _la = self._input.LA(1)
            if not(_la==SQLiteParser.IDENTIFIER or _la==SQLiteParser.STRING_LITERAL):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class KeywordContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ABORT_(self):
            return self.getToken(SQLiteParser.ABORT_, 0)

        def ACTION_(self):
            return self.getToken(SQLiteParser.ACTION_, 0)

        def ADD_(self):
            return self.getToken(SQLiteParser.ADD_, 0)

        def AFTER_(self):
            return self.getToken(SQLiteParser.AFTER_, 0)

        def ALL_(self):
            return self.getToken(SQLiteParser.ALL_, 0)

        def ALTER_(self):
            return self.getToken(SQLiteParser.ALTER_, 0)

        def ANALYZE_(self):
            return self.getToken(SQLiteParser.ANALYZE_, 0)

        def AND_(self):
            return self.getToken(SQLiteParser.AND_, 0)

        def AS_(self):
            return self.getToken(SQLiteParser.AS_, 0)

        def ASC_(self):
            return self.getToken(SQLiteParser.ASC_, 0)

        def ATTACH_(self):
            return self.getToken(SQLiteParser.ATTACH_, 0)

        def AUTOINCREMENT_(self):
            return self.getToken(SQLiteParser.AUTOINCREMENT_, 0)

        def BEFORE_(self):
            return self.getToken(SQLiteParser.BEFORE_, 0)

        def BEGIN_(self):
            return self.getToken(SQLiteParser.BEGIN_, 0)

        def BETWEEN_(self):
            return self.getToken(SQLiteParser.BETWEEN_, 0)

        def BY_(self):
            return self.getToken(SQLiteParser.BY_, 0)

        def CASCADE_(self):
            return self.getToken(SQLiteParser.CASCADE_, 0)

        def CASE_(self):
            return self.getToken(SQLiteParser.CASE_, 0)

        def CAST_(self):
            return self.getToken(SQLiteParser.CAST_, 0)

        def CHECK_(self):
            return self.getToken(SQLiteParser.CHECK_, 0)

        def COLLATE_(self):
            return self.getToken(SQLiteParser.COLLATE_, 0)

        def COLUMN_(self):
            return self.getToken(SQLiteParser.COLUMN_, 0)

        def COMMIT_(self):
            return self.getToken(SQLiteParser.COMMIT_, 0)

        def CONFLICT_(self):
            return self.getToken(SQLiteParser.CONFLICT_, 0)

        def CONSTRAINT_(self):
            return self.getToken(SQLiteParser.CONSTRAINT_, 0)

        def CREATE_(self):
            return self.getToken(SQLiteParser.CREATE_, 0)

        def CROSS_(self):
            return self.getToken(SQLiteParser.CROSS_, 0)

        def CURRENT_DATE_(self):
            return self.getToken(SQLiteParser.CURRENT_DATE_, 0)

        def CURRENT_TIME_(self):
            return self.getToken(SQLiteParser.CURRENT_TIME_, 0)

        def CURRENT_TIMESTAMP_(self):
            return self.getToken(SQLiteParser.CURRENT_TIMESTAMP_, 0)

        def DATABASE_(self):
            return self.getToken(SQLiteParser.DATABASE_, 0)

        def DEFAULT_(self):
            return self.getToken(SQLiteParser.DEFAULT_, 0)

        def DEFERRABLE_(self):
            return self.getToken(SQLiteParser.DEFERRABLE_, 0)

        def DEFERRED_(self):
            return self.getToken(SQLiteParser.DEFERRED_, 0)

        def DELETE_(self):
            return self.getToken(SQLiteParser.DELETE_, 0)

        def DESC_(self):
            return self.getToken(SQLiteParser.DESC_, 0)

        def DETACH_(self):
            return self.getToken(SQLiteParser.DETACH_, 0)

        def DISTINCT_(self):
            return self.getToken(SQLiteParser.DISTINCT_, 0)

        def DROP_(self):
            return self.getToken(SQLiteParser.DROP_, 0)

        def EACH_(self):
            return self.getToken(SQLiteParser.EACH_, 0)

        def ELSE_(self):
            return self.getToken(SQLiteParser.ELSE_, 0)

        def END_(self):
            return self.getToken(SQLiteParser.END_, 0)

        def ESCAPE_(self):
            return self.getToken(SQLiteParser.ESCAPE_, 0)

        def EXCEPT_(self):
            return self.getToken(SQLiteParser.EXCEPT_, 0)

        def EXCLUSIVE_(self):
            return self.getToken(SQLiteParser.EXCLUSIVE_, 0)

        def EXISTS_(self):
            return self.getToken(SQLiteParser.EXISTS_, 0)

        def EXPLAIN_(self):
            return self.getToken(SQLiteParser.EXPLAIN_, 0)

        def FAIL_(self):
            return self.getToken(SQLiteParser.FAIL_, 0)

        def FOR_(self):
            return self.getToken(SQLiteParser.FOR_, 0)

        def FOREIGN_(self):
            return self.getToken(SQLiteParser.FOREIGN_, 0)

        def FROM_(self):
            return self.getToken(SQLiteParser.FROM_, 0)

        def FULL_(self):
            return self.getToken(SQLiteParser.FULL_, 0)

        def GLOB_(self):
            return self.getToken(SQLiteParser.GLOB_, 0)

        def GROUP_(self):
            return self.getToken(SQLiteParser.GROUP_, 0)

        def HAVING_(self):
            return self.getToken(SQLiteParser.HAVING_, 0)

        def IF_(self):
            return self.getToken(SQLiteParser.IF_, 0)

        def IGNORE_(self):
            return self.getToken(SQLiteParser.IGNORE_, 0)

        def IMMEDIATE_(self):
            return self.getToken(SQLiteParser.IMMEDIATE_, 0)

        def IN_(self):
            return self.getToken(SQLiteParser.IN_, 0)

        def INDEX_(self):
            return self.getToken(SQLiteParser.INDEX_, 0)

        def INDEXED_(self):
            return self.getToken(SQLiteParser.INDEXED_, 0)

        def INITIALLY_(self):
            return self.getToken(SQLiteParser.INITIALLY_, 0)

        def INNER_(self):
            return self.getToken(SQLiteParser.INNER_, 0)

        def INSERT_(self):
            return self.getToken(SQLiteParser.INSERT_, 0)

        def INSTEAD_(self):
            return self.getToken(SQLiteParser.INSTEAD_, 0)

        def INTERSECT_(self):
            return self.getToken(SQLiteParser.INTERSECT_, 0)

        def INTO_(self):
            return self.getToken(SQLiteParser.INTO_, 0)

        def IS_(self):
            return self.getToken(SQLiteParser.IS_, 0)

        def ISNULL_(self):
            return self.getToken(SQLiteParser.ISNULL_, 0)

        def JOIN_(self):
            return self.getToken(SQLiteParser.JOIN_, 0)

        def KEY_(self):
            return self.getToken(SQLiteParser.KEY_, 0)

        def LEFT_(self):
            return self.getToken(SQLiteParser.LEFT_, 0)

        def LIKE_(self):
            return self.getToken(SQLiteParser.LIKE_, 0)

        def LIMIT_(self):
            return self.getToken(SQLiteParser.LIMIT_, 0)

        def MATCH_(self):
            return self.getToken(SQLiteParser.MATCH_, 0)

        def NATURAL_(self):
            return self.getToken(SQLiteParser.NATURAL_, 0)

        def NO_(self):
            return self.getToken(SQLiteParser.NO_, 0)

        def NOT_(self):
            return self.getToken(SQLiteParser.NOT_, 0)

        def NOTNULL_(self):
            return self.getToken(SQLiteParser.NOTNULL_, 0)

        def NULL_(self):
            return self.getToken(SQLiteParser.NULL_, 0)

        def OF_(self):
            return self.getToken(SQLiteParser.OF_, 0)

        def OFFSET_(self):
            return self.getToken(SQLiteParser.OFFSET_, 0)

        def ON_(self):
            return self.getToken(SQLiteParser.ON_, 0)

        def OR_(self):
            return self.getToken(SQLiteParser.OR_, 0)

        def ORDER_(self):
            return self.getToken(SQLiteParser.ORDER_, 0)

        def OUTER_(self):
            return self.getToken(SQLiteParser.OUTER_, 0)

        def PLAN_(self):
            return self.getToken(SQLiteParser.PLAN_, 0)

        def PRAGMA_(self):
            return self.getToken(SQLiteParser.PRAGMA_, 0)

        def PRIMARY_(self):
            return self.getToken(SQLiteParser.PRIMARY_, 0)

        def QUERY_(self):
            return self.getToken(SQLiteParser.QUERY_, 0)

        def RAISE_(self):
            return self.getToken(SQLiteParser.RAISE_, 0)

        def RECURSIVE_(self):
            return self.getToken(SQLiteParser.RECURSIVE_, 0)

        def REFERENCES_(self):
            return self.getToken(SQLiteParser.REFERENCES_, 0)

        def REGEXP_(self):
            return self.getToken(SQLiteParser.REGEXP_, 0)

        def REINDEX_(self):
            return self.getToken(SQLiteParser.REINDEX_, 0)

        def RELEASE_(self):
            return self.getToken(SQLiteParser.RELEASE_, 0)

        def RENAME_(self):
            return self.getToken(SQLiteParser.RENAME_, 0)

        def REPLACE_(self):
            return self.getToken(SQLiteParser.REPLACE_, 0)

        def RESTRICT_(self):
            return self.getToken(SQLiteParser.RESTRICT_, 0)

        def RIGHT_(self):
            return self.getToken(SQLiteParser.RIGHT_, 0)

        def ROLLBACK_(self):
            return self.getToken(SQLiteParser.ROLLBACK_, 0)

        def ROW_(self):
            return self.getToken(SQLiteParser.ROW_, 0)

        def ROWS_(self):
            return self.getToken(SQLiteParser.ROWS_, 0)

        def SAVEPOINT_(self):
            return self.getToken(SQLiteParser.SAVEPOINT_, 0)

        def SELECT_(self):
            return self.getToken(SQLiteParser.SELECT_, 0)

        def SET_(self):
            return self.getToken(SQLiteParser.SET_, 0)

        def TABLE_(self):
            return self.getToken(SQLiteParser.TABLE_, 0)

        def TEMP_(self):
            return self.getToken(SQLiteParser.TEMP_, 0)

        def TEMPORARY_(self):
            return self.getToken(SQLiteParser.TEMPORARY_, 0)

        def THEN_(self):
            return self.getToken(SQLiteParser.THEN_, 0)

        def TO_(self):
            return self.getToken(SQLiteParser.TO_, 0)

        def TRANSACTION_(self):
            return self.getToken(SQLiteParser.TRANSACTION_, 0)

        def TRIGGER_(self):
            return self.getToken(SQLiteParser.TRIGGER_, 0)

        def UNION_(self):
            return self.getToken(SQLiteParser.UNION_, 0)

        def UNIQUE_(self):
            return self.getToken(SQLiteParser.UNIQUE_, 0)

        def UPDATE_(self):
            return self.getToken(SQLiteParser.UPDATE_, 0)

        def USING_(self):
            return self.getToken(SQLiteParser.USING_, 0)

        def VACUUM_(self):
            return self.getToken(SQLiteParser.VACUUM_, 0)

        def VALUES_(self):
            return self.getToken(SQLiteParser.VALUES_, 0)

        def VIEW_(self):
            return self.getToken(SQLiteParser.VIEW_, 0)

        def VIRTUAL_(self):
            return self.getToken(SQLiteParser.VIRTUAL_, 0)

        def WHEN_(self):
            return self.getToken(SQLiteParser.WHEN_, 0)

        def WHERE_(self):
            return self.getToken(SQLiteParser.WHERE_, 0)

        def WITH_(self):
            return self.getToken(SQLiteParser.WITH_, 0)

        def WITHOUT_(self):
            return self.getToken(SQLiteParser.WITHOUT_, 0)

        def FIRST_VALUE_(self):
            return self.getToken(SQLiteParser.FIRST_VALUE_, 0)

        def OVER_(self):
            return self.getToken(SQLiteParser.OVER_, 0)

        def PARTITION_(self):
            return self.getToken(SQLiteParser.PARTITION_, 0)

        def RANGE_(self):
            return self.getToken(SQLiteParser.RANGE_, 0)

        def PRECEDING_(self):
            return self.getToken(SQLiteParser.PRECEDING_, 0)

        def UNBOUNDED_(self):
            return self.getToken(SQLiteParser.UNBOUNDED_, 0)

        def CURRENT_(self):
            return self.getToken(SQLiteParser.CURRENT_, 0)

        def FOLLOWING_(self):
            return self.getToken(SQLiteParser.FOLLOWING_, 0)

        def CUME_DIST_(self):
            return self.getToken(SQLiteParser.CUME_DIST_, 0)

        def DENSE_RANK_(self):
            return self.getToken(SQLiteParser.DENSE_RANK_, 0)

        def LAG_(self):
            return self.getToken(SQLiteParser.LAG_, 0)

        def LAST_VALUE_(self):
            return self.getToken(SQLiteParser.LAST_VALUE_, 0)

        def LEAD_(self):
            return self.getToken(SQLiteParser.LEAD_, 0)

        def NTH_VALUE_(self):
            return self.getToken(SQLiteParser.NTH_VALUE_, 0)

        def NTILE_(self):
            return self.getToken(SQLiteParser.NTILE_, 0)

        def PERCENT_RANK_(self):
            return self.getToken(SQLiteParser.PERCENT_RANK_, 0)

        def RANK_(self):
            return self.getToken(SQLiteParser.RANK_, 0)

        def ROW_NUMBER_(self):
            return self.getToken(SQLiteParser.ROW_NUMBER_, 0)

        def GENERATED_(self):
            return self.getToken(SQLiteParser.GENERATED_, 0)

        def ALWAYS_(self):
            return self.getToken(SQLiteParser.ALWAYS_, 0)

        def STORED_(self):
            return self.getToken(SQLiteParser.STORED_, 0)

        def TRUE_(self):
            return self.getToken(SQLiteParser.TRUE_, 0)

        def FALSE_(self):
            return self.getToken(SQLiteParser.FALSE_, 0)

        def WINDOW_(self):
            return self.getToken(SQLiteParser.WINDOW_, 0)

        def NULLS_(self):
            return self.getToken(SQLiteParser.NULLS_, 0)

        def FIRST_(self):
            return self.getToken(SQLiteParser.FIRST_, 0)

        def LAST_(self):
            return self.getToken(SQLiteParser.LAST_, 0)

        def FILTER_(self):
            return self.getToken(SQLiteParser.FILTER_, 0)

        def GROUPS_(self):
            return self.getToken(SQLiteParser.GROUPS_, 0)

        def EXCLUDE_(self):
            return self.getToken(SQLiteParser.EXCLUDE_, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_keyword

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

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




    def keyword(self):

        localctx = SQLiteParser.KeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_keyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2026
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.ABORT_) | (1 << SQLiteParser.ACTION_) | (1 << SQLiteParser.ADD_) | (1 << SQLiteParser.AFTER_) | (1 << SQLiteParser.ALL_) | (1 << SQLiteParser.ALTER_) | (1 << SQLiteParser.ANALYZE_) | (1 << SQLiteParser.AND_) | (1 << SQLiteParser.AS_) | (1 << SQLiteParser.ASC_) | (1 << SQLiteParser.ATTACH_) | (1 << SQLiteParser.AUTOINCREMENT_) | (1 << SQLiteParser.BEFORE_) | (1 << SQLiteParser.BEGIN_) | (1 << SQLiteParser.BETWEEN_) | (1 << SQLiteParser.BY_) | (1 << SQLiteParser.CASCADE_) | (1 << SQLiteParser.CASE_) | (1 << SQLiteParser.CAST_) | (1 << SQLiteParser.CHECK_) | (1 << SQLiteParser.COLLATE_) | (1 << SQLiteParser.COLUMN_) | (1 << SQLiteParser.COMMIT_) | (1 << SQLiteParser.CONFLICT_) | (1 << SQLiteParser.CONSTRAINT_) | (1 << SQLiteParser.CREATE_) | (1 << SQLiteParser.CROSS_) | (1 << SQLiteParser.CURRENT_DATE_) | (1 << SQLiteParser.CURRENT_TIME_) | (1 << SQLiteParser.CURRENT_TIMESTAMP_) | (1 << SQLiteParser.DATABASE_) | (1 << SQLiteParser.DEFAULT_) | (1 << SQLiteParser.DEFERRABLE_) | (1 << SQLiteParser.DEFERRED_) | (1 << SQLiteParser.DELETE_) | (1 << SQLiteParser.DESC_) | (1 << SQLiteParser.DETACH_) | (1 << SQLiteParser.DISTINCT_) | (1 << SQLiteParser.DROP_))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SQLiteParser.EACH_ - 64)) | (1 << (SQLiteParser.ELSE_ - 64)) | (1 << (SQLiteParser.END_ - 64)) | (1 << (SQLiteParser.ESCAPE_ - 64)) | (1 << (SQLiteParser.EXCEPT_ - 64)) | (1 << (SQLiteParser.EXCLUSIVE_ - 64)) | (1 << (SQLiteParser.EXISTS_ - 64)) | (1 << (SQLiteParser.EXPLAIN_ - 64)) | (1 << (SQLiteParser.FAIL_ - 64)) | (1 << (SQLiteParser.FOR_ - 64)) | (1 << (SQLiteParser.FOREIGN_ - 64)) | (1 << (SQLiteParser.FROM_ - 64)) | (1 << (SQLiteParser.FULL_ - 64)) | (1 << (SQLiteParser.GLOB_ - 64)) | (1 << (SQLiteParser.GROUP_ - 64)) | (1 << (SQLiteParser.HAVING_ - 64)) | (1 << (SQLiteParser.IF_ - 64)) | (1 << (SQLiteParser.IGNORE_ - 64)) | (1 << (SQLiteParser.IMMEDIATE_ - 64)) | (1 << (SQLiteParser.IN_ - 64)) | (1 << (SQLiteParser.INDEX_ - 64)) | (1 << (SQLiteParser.INDEXED_ - 64)) | (1 << (SQLiteParser.INITIALLY_ - 64)) | (1 << (SQLiteParser.INNER_ - 64)) | (1 << (SQLiteParser.INSERT_ - 64)) | (1 << (SQLiteParser.INSTEAD_ - 64)) | (1 << (SQLiteParser.INTERSECT_ - 64)) | (1 << (SQLiteParser.INTO_ - 64)) | (1 << (SQLiteParser.IS_ - 64)) | (1 << (SQLiteParser.ISNULL_ - 64)) | (1 << (SQLiteParser.JOIN_ - 64)) | (1 << (SQLiteParser.KEY_ - 64)) | (1 << (SQLiteParser.LEFT_ - 64)) | (1 << (SQLiteParser.LIKE_ - 64)) | (1 << (SQLiteParser.LIMIT_ - 64)) | (1 << (SQLiteParser.MATCH_ - 64)) | (1 << (SQLiteParser.NATURAL_ - 64)) | (1 << (SQLiteParser.NO_ - 64)) | (1 << (SQLiteParser.NOT_ - 64)) | (1 << (SQLiteParser.NOTNULL_ - 64)) | (1 << (SQLiteParser.NULL_ - 64)) | (1 << (SQLiteParser.OF_ - 64)) | (1 << (SQLiteParser.OFFSET_ - 64)) | (1 << (SQLiteParser.ON_ - 64)) | (1 << (SQLiteParser.OR_ - 64)) | (1 << (SQLiteParser.ORDER_ - 64)) | (1 << (SQLiteParser.OUTER_ - 64)) | (1 << (SQLiteParser.PLAN_ - 64)) | (1 << (SQLiteParser.PRAGMA_ - 64)) | (1 << (SQLiteParser.PRIMARY_ - 64)) | (1 << (SQLiteParser.QUERY_ - 64)) | (1 << (SQLiteParser.RAISE_ - 64)) | (1 << (SQLiteParser.RECURSIVE_ - 64)) | (1 << (SQLiteParser.REFERENCES_ - 64)) | (1 << (SQLiteParser.REGEXP_ - 64)) | (1 << (SQLiteParser.REINDEX_ - 64)) | (1 << (SQLiteParser.RELEASE_ - 64)) | (1 << (SQLiteParser.RENAME_ - 64)) | (1 << (SQLiteParser.REPLACE_ - 64)) | (1 << (SQLiteParser.RESTRICT_ - 64)) | (1 << (SQLiteParser.RIGHT_ - 64)) | (1 << (SQLiteParser.ROLLBACK_ - 64)) | (1 << (SQLiteParser.ROW_ - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.ROWS_ - 128)) | (1 << (SQLiteParser.SAVEPOINT_ - 128)) | (1 << (SQLiteParser.SELECT_ - 128)) | (1 << (SQLiteParser.SET_ - 128)) | (1 << (SQLiteParser.TABLE_ - 128)) | (1 << (SQLiteParser.TEMP_ - 128)) | (1 << (SQLiteParser.TEMPORARY_ - 128)) | (1 << (SQLiteParser.THEN_ - 128)) | (1 << (SQLiteParser.TO_ - 128)) | (1 << (SQLiteParser.TRANSACTION_ - 128)) | (1 << (SQLiteParser.TRIGGER_ - 128)) | (1 << (SQLiteParser.UNION_ - 128)) | (1 << (SQLiteParser.UNIQUE_ - 128)) | (1 << (SQLiteParser.UPDATE_ - 128)) | (1 << (SQLiteParser.USING_ - 128)) | (1 << (SQLiteParser.VACUUM_ - 128)) | (1 << (SQLiteParser.VALUES_ - 128)) | (1 << (SQLiteParser.VIEW_ - 128)) | (1 << (SQLiteParser.VIRTUAL_ - 128)) | (1 << (SQLiteParser.WHEN_ - 128)) | (1 << (SQLiteParser.WHERE_ - 128)) | (1 << (SQLiteParser.WITH_ - 128)) | (1 << (SQLiteParser.WITHOUT_ - 128)) | (1 << (SQLiteParser.FIRST_VALUE_ - 128)) | (1 << (SQLiteParser.OVER_ - 128)) | (1 << (SQLiteParser.PARTITION_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.PRECEDING_ - 128)) | (1 << (SQLiteParser.UNBOUNDED_ - 128)) | (1 << (SQLiteParser.CURRENT_ - 128)) | (1 << (SQLiteParser.FOLLOWING_ - 128)) | (1 << (SQLiteParser.CUME_DIST_ - 128)) | (1 << (SQLiteParser.DENSE_RANK_ - 128)) | (1 << (SQLiteParser.LAG_ - 128)) | (1 << (SQLiteParser.LAST_VALUE_ - 128)) | (1 << (SQLiteParser.LEAD_ - 128)) | (1 << (SQLiteParser.NTH_VALUE_ - 128)) | (1 << (SQLiteParser.NTILE_ - 128)) | (1 << (SQLiteParser.PERCENT_RANK_ - 128)) | (1 << (SQLiteParser.RANK_ - 128)) | (1 << (SQLiteParser.ROW_NUMBER_ - 128)) | (1 << (SQLiteParser.GENERATED_ - 128)) | (1 << (SQLiteParser.ALWAYS_ - 128)) | (1 << (SQLiteParser.STORED_ - 128)) | (1 << (SQLiteParser.TRUE_ - 128)) | (1 << (SQLiteParser.FALSE_ - 128)) | (1 << (SQLiteParser.WINDOW_ - 128)) | (1 << (SQLiteParser.NULLS_ - 128)) | (1 << (SQLiteParser.FIRST_ - 128)) | (1 << (SQLiteParser.LAST_ - 128)) | (1 << (SQLiteParser.FILTER_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)) | (1 << (SQLiteParser.EXCLUDE_ - 128)))) != 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 NameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_name

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

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




    def name(self):

        localctx = SQLiteParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2028
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Function_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_function_name

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

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




    def function_name(self):

        localctx = SQLiteParser.Function_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_function_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2030
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Schema_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_schema_name

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

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




    def schema_name(self):

        localctx = SQLiteParser.Schema_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_schema_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2032
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_name

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

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




    def table_name(self):

        localctx = SQLiteParser.Table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_table_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2034
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_or_index_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_or_index_name

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

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




    def table_or_index_name(self):

        localctx = SQLiteParser.Table_or_index_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_table_or_index_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2036
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class New_table_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_new_table_name

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

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




    def new_table_name(self):

        localctx = SQLiteParser.New_table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_new_table_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2038
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Column_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_column_name

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

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




    def column_name(self):

        localctx = SQLiteParser.Column_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_column_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2040
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Collation_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_collation_name

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

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




    def collation_name(self):

        localctx = SQLiteParser.Collation_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_collation_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2042
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Foreign_tableContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_foreign_table

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

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




    def foreign_table(self):

        localctx = SQLiteParser.Foreign_tableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_foreign_table)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2044
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Index_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_index_name

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

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




    def index_name(self):

        localctx = SQLiteParser.Index_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_index_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2046
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Trigger_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_trigger_name

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

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




    def trigger_name(self):

        localctx = SQLiteParser.Trigger_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_trigger_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2048
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class View_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_view_name

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

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




    def view_name(self):

        localctx = SQLiteParser.View_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_view_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2050
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Module_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_module_name

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

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




    def module_name(self):

        localctx = SQLiteParser.Module_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_module_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2052
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pragma_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_pragma_name

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

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




    def pragma_name(self):

        localctx = SQLiteParser.Pragma_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_pragma_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2054
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Savepoint_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_savepoint_name

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

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




    def savepoint_name(self):

        localctx = SQLiteParser.Savepoint_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_savepoint_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2056
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_aliasContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_alias

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

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




    def table_alias(self):

        localctx = SQLiteParser.Table_aliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_table_alias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2058
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Transaction_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_transaction_name

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

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




    def transaction_name(self):

        localctx = SQLiteParser.Transaction_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_transaction_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2060
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Window_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_window_name

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

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




    def window_name(self):

        localctx = SQLiteParser.Window_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_window_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2062
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AliasContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_alias

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

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




    def alias(self):

        localctx = SQLiteParser.AliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_alias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2064
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FilenameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_filename

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

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




    def filename(self):

        localctx = SQLiteParser.FilenameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_filename)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2066
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Base_window_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_base_window_name

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

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




    def base_window_name(self):

        localctx = SQLiteParser.Base_window_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_base_window_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2068
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simple_funcContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_simple_func

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

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




    def simple_func(self):

        localctx = SQLiteParser.Simple_funcContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_simple_func)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2070
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Aggregate_funcContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_aggregate_func

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

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




    def aggregate_func(self):

        localctx = SQLiteParser.Aggregate_funcContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_aggregate_func)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2072
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_function_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_function_name

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

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




    def table_function_name(self):

        localctx = SQLiteParser.Table_function_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_table_function_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2074
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Any_nameContext(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.getToken(SQLiteParser.IDENTIFIER, 0)

        def keyword(self):
            return self.getTypedRuleContext(SQLiteParser.KeywordContext,0)


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

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_any_name

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

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




    def any_name(self):

        localctx = SQLiteParser.Any_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_any_name)
        try:
            self.state = 2083
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2076
                self.match(SQLiteParser.IDENTIFIER)
                pass
            elif token in [SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2077
                self.keyword()
                pass
            elif token in [SQLiteParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2078
                self.match(SQLiteParser.STRING_LITERAL)
                pass
            elif token in [SQLiteParser.OPEN_PAR]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2079
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 2080
                self.any_name()
                self.state = 2081
                self.match(SQLiteParser.CLOSE_PAR)
                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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[32] = self.expr_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 expr_sempred(self, localctx:ExprContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 20)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 19)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 18)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 17)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 16)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 15)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 14)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 13)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 4)
         




