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

def serializedATN():
    return [
        4,1,101,1404,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,1,0,3,0,180,8,0,1,0,1,0,3,
        0,184,8,0,1,0,3,0,187,8,0,1,0,3,0,190,8,0,1,0,1,0,1,1,1,1,3,1,196,
        8,1,1,2,1,2,5,2,200,8,2,10,2,12,2,203,9,2,1,3,1,3,3,3,207,8,3,1,
        4,1,4,3,4,211,8,4,1,4,1,4,3,4,215,8,4,1,4,3,4,218,8,4,1,4,3,4,221,
        8,4,1,4,1,4,3,4,225,8,4,1,4,1,4,3,4,229,8,4,3,4,231,8,4,1,5,1,5,
        3,5,235,8,5,1,5,1,5,1,6,1,6,3,6,241,8,6,1,6,1,6,3,6,245,8,6,1,6,
        3,6,248,8,6,1,7,1,7,3,7,252,8,7,1,7,1,7,1,8,1,8,3,8,258,8,8,1,8,
        1,8,1,9,3,9,263,8,9,1,9,3,9,266,8,9,1,9,3,9,269,8,9,1,9,1,9,3,9,
        273,8,9,1,9,3,9,276,8,9,1,9,3,9,279,8,9,1,9,3,9,282,8,9,1,9,3,9,
        285,8,9,1,9,3,9,288,8,9,1,10,1,10,3,10,292,8,10,1,10,3,10,295,8,
        10,1,10,1,10,3,10,299,8,10,1,10,5,10,302,8,10,10,10,12,10,305,9,
        10,1,11,1,11,3,11,309,8,11,1,11,1,11,3,11,313,8,11,1,11,3,11,316,
        8,11,1,12,1,12,3,12,320,8,12,1,12,3,12,323,8,12,1,13,1,13,3,13,327,
        8,13,1,13,1,13,3,13,331,8,13,1,13,1,13,3,13,335,8,13,1,13,1,13,3,
        13,339,8,13,1,13,5,13,342,8,13,10,13,12,13,345,9,13,1,14,1,14,3,
        14,349,8,14,5,14,351,8,14,10,14,12,14,354,9,14,1,14,1,14,1,14,3,
        14,359,8,14,4,14,361,8,14,11,14,12,14,362,1,14,3,14,366,8,14,1,14,
        3,14,369,8,14,3,14,371,8,14,1,15,1,15,3,15,375,8,15,5,15,377,8,15,
        10,15,12,15,380,9,15,1,15,1,15,3,15,384,8,15,5,15,386,8,15,10,15,
        12,15,389,9,15,1,15,1,15,3,15,393,8,15,1,15,1,15,1,16,1,16,3,16,
        399,8,16,1,16,1,16,3,16,403,8,16,1,16,1,16,1,17,1,17,3,17,409,8,
        17,1,17,1,17,3,17,413,8,17,1,17,1,17,3,17,417,8,17,1,17,1,17,1,18,
        1,18,1,18,3,18,424,8,18,1,19,1,19,1,19,1,19,1,19,3,19,431,8,19,1,
        20,1,20,3,20,435,8,20,1,20,1,20,3,20,439,8,20,1,20,1,20,1,21,1,21,
        3,21,445,8,21,1,21,1,21,3,21,449,8,21,1,21,1,21,3,21,453,8,21,1,
        21,5,21,456,8,21,10,21,12,21,459,9,21,1,22,1,22,3,22,463,8,22,1,
        22,1,22,1,22,3,22,468,8,22,1,23,1,23,3,23,472,8,23,1,23,1,23,3,23,
        476,8,23,1,23,1,23,3,23,480,8,23,1,23,1,23,3,23,484,8,23,1,23,3,
        23,487,8,23,1,24,1,24,3,24,491,8,24,1,24,3,24,494,8,24,1,24,3,24,
        497,8,24,1,24,1,24,1,25,1,25,3,25,503,8,25,1,25,1,25,3,25,507,8,
        25,1,25,5,25,510,8,25,10,25,12,25,513,9,25,1,25,3,25,516,8,25,1,
        25,3,25,519,8,25,1,26,1,26,3,26,523,8,26,1,26,1,26,3,26,527,8,26,
        3,26,529,8,26,1,26,1,26,1,27,1,27,3,27,535,8,27,1,27,1,27,3,27,539,
        8,27,1,27,5,27,542,8,27,10,27,12,27,545,9,27,1,28,1,28,3,28,549,
        8,28,1,28,1,28,3,28,553,8,28,1,28,1,28,1,29,1,29,3,29,559,8,29,1,
        29,1,29,3,29,563,8,29,1,29,1,29,3,29,567,8,29,1,29,5,29,570,8,29,
        10,29,12,29,573,9,29,1,30,1,30,3,30,577,8,30,1,30,1,30,3,30,581,
        8,30,1,30,1,30,1,30,1,30,3,30,587,8,30,1,30,1,30,3,30,591,8,30,1,
        30,1,30,1,30,1,30,3,30,597,8,30,1,30,1,30,3,30,601,8,30,1,31,1,31,
        3,31,605,8,31,1,31,4,31,608,8,31,11,31,12,31,609,1,32,1,32,3,32,
        614,8,32,1,32,1,32,1,33,1,33,3,33,620,8,33,1,33,3,33,623,8,33,1,
        34,1,34,3,34,627,8,34,1,34,1,34,1,35,1,35,3,35,633,8,35,1,35,1,35,
        3,35,637,8,35,1,35,5,35,640,8,35,10,35,12,35,643,9,35,1,36,1,36,
        3,36,647,8,36,1,36,1,36,3,36,651,8,36,1,36,5,36,654,8,36,10,36,12,
        36,657,9,36,1,37,1,37,3,37,661,8,37,1,37,1,37,3,37,665,8,37,1,37,
        5,37,668,8,37,10,37,12,37,671,9,37,1,38,1,38,3,38,675,8,38,1,38,
        1,38,3,38,679,8,38,1,38,5,38,682,8,38,10,38,12,38,685,9,38,1,39,
        1,39,3,39,689,8,39,5,39,691,8,39,10,39,12,39,694,9,39,1,39,1,39,
        1,40,1,40,3,40,700,8,40,1,40,1,40,3,40,704,8,40,1,40,1,40,5,40,708,
        8,40,10,40,12,40,711,9,40,1,41,1,41,1,42,1,42,3,42,717,8,42,1,42,
        1,42,3,42,721,8,42,1,42,5,42,724,8,42,10,42,12,42,727,9,42,1,43,
        1,43,3,43,731,8,43,1,43,1,43,3,43,735,8,43,1,43,5,43,738,8,43,10,
        43,12,43,741,9,43,1,44,1,44,3,44,745,8,44,1,44,1,44,3,44,749,8,44,
        1,44,5,44,752,8,44,10,44,12,44,755,9,44,1,45,3,45,758,8,45,1,45,
        3,45,761,8,45,1,45,1,45,1,46,1,46,3,46,767,8,46,1,46,1,46,1,46,3,
        46,772,8,46,5,46,774,8,46,10,46,12,46,777,9,46,1,47,3,47,780,8,47,
        1,47,1,47,3,47,784,8,47,1,47,1,47,1,47,3,47,789,8,47,1,47,3,47,792,
        8,47,1,47,3,47,795,8,47,1,47,1,47,3,47,799,8,47,1,47,3,47,802,8,
        47,1,47,3,47,805,8,47,1,47,3,47,808,8,47,1,47,3,47,811,8,47,1,48,
        1,48,3,48,815,8,48,1,48,1,48,1,49,1,49,3,49,821,8,49,1,49,1,49,1,
        49,3,49,826,8,49,1,49,1,49,3,49,830,8,49,1,50,3,50,833,8,50,1,50,
        1,50,3,50,837,8,50,1,50,3,50,840,8,50,1,50,3,50,843,8,50,1,50,1,
        50,1,51,1,51,3,51,849,8,51,1,51,3,51,852,8,51,1,52,1,52,3,52,856,
        8,52,1,52,1,52,3,52,860,8,52,1,52,5,52,863,8,52,10,52,12,52,866,
        9,52,1,53,1,53,3,53,870,8,53,1,53,1,53,3,53,874,8,53,3,53,876,8,
        53,1,53,1,53,1,54,1,54,3,54,882,8,54,1,54,5,54,885,8,54,10,54,12,
        54,888,9,54,1,54,1,54,3,54,892,8,54,1,54,1,54,3,54,896,8,54,1,54,
        1,54,1,54,3,54,901,8,54,1,55,1,55,3,55,905,8,55,1,55,1,55,1,56,1,
        56,3,56,911,8,56,1,57,1,57,3,57,915,8,57,1,57,3,57,918,8,57,1,57,
        3,57,921,8,57,1,57,3,57,924,8,57,1,57,3,57,927,8,57,1,57,3,57,930,
        8,57,1,57,3,57,933,8,57,1,57,1,57,1,58,1,58,1,58,1,58,1,58,1,58,
        1,58,1,58,1,58,1,58,1,58,1,58,3,58,949,8,58,1,59,1,59,1,59,1,60,
        1,60,3,60,956,8,60,1,60,1,60,3,60,960,8,60,1,60,3,60,963,8,60,1,
        60,3,60,966,8,60,1,60,1,60,3,60,970,8,60,1,60,3,60,973,8,60,1,60,
        1,60,3,60,977,8,60,1,60,3,60,980,8,60,1,60,3,60,983,8,60,1,60,1,
        60,3,60,987,8,60,1,60,3,60,990,8,60,3,60,992,8,60,1,61,1,61,3,61,
        996,8,61,1,61,3,61,999,8,61,1,61,3,61,1002,8,61,1,61,3,61,1005,8,
        61,1,61,3,61,1008,8,61,1,61,3,61,1011,8,61,1,61,3,61,1014,8,61,1,
        61,3,61,1017,8,61,1,61,3,61,1020,8,61,1,61,1,61,1,62,1,62,3,62,1026,
        8,62,1,62,3,62,1029,8,62,1,62,3,62,1032,8,62,1,62,1,62,3,62,1036,
        8,62,1,62,3,62,1039,8,62,3,62,1041,8,62,1,63,1,63,3,63,1045,8,63,
        1,63,1,63,3,63,1049,8,63,1,63,1,63,3,63,1053,8,63,1,63,3,63,1056,
        8,63,1,63,3,63,1059,8,63,1,63,5,63,1062,8,63,10,63,12,63,1065,9,
        63,1,64,1,64,3,64,1069,8,64,1,64,3,64,1072,8,64,1,64,3,64,1075,8,
        64,1,64,1,64,1,65,1,65,3,65,1081,8,65,1,65,1,65,3,65,1085,8,65,1,
        65,1,65,3,65,1089,8,65,1,65,3,65,1092,8,65,1,65,1,65,1,66,1,66,3,
        66,1098,8,66,1,66,1,66,3,66,1102,8,66,1,66,5,66,1105,8,66,10,66,
        12,66,1108,9,66,1,67,1,67,3,67,1112,8,67,1,67,1,67,3,67,1116,8,67,
        1,67,1,67,3,67,1120,8,67,3,67,1122,8,67,1,67,1,67,3,67,1126,8,67,
        1,67,1,67,1,67,1,67,3,67,1132,8,67,1,67,1,67,3,67,1136,8,67,1,67,
        1,67,3,67,1140,8,67,3,67,1142,8,67,1,67,3,67,1145,8,67,1,67,3,67,
        1148,8,67,1,67,1,67,3,67,1152,8,67,1,68,1,68,3,68,1156,8,68,1,68,
        1,68,3,68,1160,8,68,1,68,1,68,1,69,1,69,3,69,1166,8,69,1,69,1,69,
        3,69,1170,8,69,1,69,1,69,3,69,1174,8,69,1,69,1,69,1,70,1,70,3,70,
        1180,8,70,1,70,1,70,3,70,1184,8,70,1,70,1,70,3,70,1188,8,70,3,70,
        1190,8,70,1,70,1,70,3,70,1194,8,70,1,70,3,70,1197,8,70,1,70,3,70,
        1200,8,70,1,70,1,70,3,70,1204,8,70,1,70,1,70,3,70,1208,8,70,1,70,
        1,70,1,71,1,71,3,71,1214,8,71,1,71,4,71,1217,8,71,11,71,12,71,1218,
        1,72,1,72,3,72,1223,8,72,1,72,1,72,3,72,1227,8,72,1,72,1,72,3,72,
        1231,8,72,1,72,3,72,1234,8,72,1,72,3,72,1237,8,72,1,72,1,72,1,73,
        1,73,3,73,1243,8,73,1,73,1,73,3,73,1247,8,73,1,73,1,73,3,73,1251,
        8,73,1,73,3,73,1254,8,73,1,74,1,74,3,74,1258,8,74,1,74,1,74,3,74,
        1262,8,74,1,74,1,74,3,74,1266,8,74,1,74,1,74,1,75,1,75,3,75,1272,
        8,75,1,75,1,75,3,75,1276,8,75,1,75,5,75,1279,8,75,10,75,12,75,1282,
        9,75,1,76,1,76,3,76,1286,8,76,1,76,3,76,1289,8,76,1,76,3,76,1292,
        8,76,1,76,1,76,3,76,1296,8,76,1,76,1,76,3,76,1300,8,76,1,76,1,76,
        3,76,1304,8,76,1,76,1,76,4,76,1308,8,76,11,76,12,76,1309,1,76,3,
        76,1313,8,76,1,76,1,76,3,76,1317,8,76,1,76,3,76,1320,8,76,1,76,3,
        76,1323,8,76,1,76,1,76,1,77,1,77,1,77,3,77,1330,8,77,1,78,1,78,1,
        78,1,78,1,78,1,78,1,78,3,78,1339,8,78,1,79,1,79,1,80,1,80,1,81,1,
        81,1,82,1,82,1,83,1,83,3,83,1351,8,83,1,83,3,83,1354,8,83,1,83,3,
        83,1357,8,83,1,83,1,83,1,84,1,84,3,84,1363,8,84,1,84,1,84,3,84,1367,
        8,84,1,84,1,84,3,84,1371,8,84,1,84,5,84,1374,8,84,10,84,12,84,1377,
        9,84,3,84,1379,8,84,1,84,3,84,1382,8,84,1,84,1,84,1,85,1,85,3,85,
        1388,8,85,1,85,1,85,3,85,1392,8,85,1,85,1,85,1,86,1,86,3,86,1398,
        8,86,1,87,1,87,1,88,1,88,1,88,0,0,89,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,0,10,2,0,37,38,42,43,2,0,40,40,47,47,1,0,1,2,2,0,1,1,
        3,7,1,0,18,19,2,0,20,21,23,23,1,0,33,36,1,0,71,72,4,0,30,35,89,89,
        92,93,95,95,1,0,36,88,1627,0,179,1,0,0,0,2,195,1,0,0,0,4,197,1,0,
        0,0,6,206,1,0,0,0,8,208,1,0,0,0,10,232,1,0,0,0,12,238,1,0,0,0,14,
        249,1,0,0,0,16,255,1,0,0,0,18,265,1,0,0,0,20,291,1,0,0,0,22,306,
        1,0,0,0,24,317,1,0,0,0,26,324,1,0,0,0,28,352,1,0,0,0,30,378,1,0,
        0,0,32,398,1,0,0,0,34,406,1,0,0,0,36,423,1,0,0,0,38,430,1,0,0,0,
        40,434,1,0,0,0,42,442,1,0,0,0,44,467,1,0,0,0,46,469,1,0,0,0,48,488,
        1,0,0,0,50,500,1,0,0,0,52,528,1,0,0,0,54,532,1,0,0,0,56,546,1,0,
        0,0,58,556,1,0,0,0,60,600,1,0,0,0,62,607,1,0,0,0,64,611,1,0,0,0,
        66,617,1,0,0,0,68,624,1,0,0,0,70,630,1,0,0,0,72,644,1,0,0,0,74,658,
        1,0,0,0,76,672,1,0,0,0,78,692,1,0,0,0,80,697,1,0,0,0,82,712,1,0,
        0,0,84,714,1,0,0,0,86,728,1,0,0,0,88,742,1,0,0,0,90,757,1,0,0,0,
        92,764,1,0,0,0,94,810,1,0,0,0,96,812,1,0,0,0,98,829,1,0,0,0,100,
        832,1,0,0,0,102,846,1,0,0,0,104,853,1,0,0,0,106,875,1,0,0,0,108,
        900,1,0,0,0,110,902,1,0,0,0,112,910,1,0,0,0,114,912,1,0,0,0,116,
        948,1,0,0,0,118,950,1,0,0,0,120,991,1,0,0,0,122,993,1,0,0,0,124,
        1023,1,0,0,0,126,1042,1,0,0,0,128,1066,1,0,0,0,130,1078,1,0,0,0,
        132,1095,1,0,0,0,134,1151,1,0,0,0,136,1153,1,0,0,0,138,1163,1,0,
        0,0,140,1177,1,0,0,0,142,1211,1,0,0,0,144,1220,1,0,0,0,146,1240,
        1,0,0,0,148,1255,1,0,0,0,150,1269,1,0,0,0,152,1283,1,0,0,0,154,1326,
        1,0,0,0,156,1338,1,0,0,0,158,1340,1,0,0,0,160,1342,1,0,0,0,162,1344,
        1,0,0,0,164,1346,1,0,0,0,166,1348,1,0,0,0,168,1360,1,0,0,0,170,1385,
        1,0,0,0,172,1397,1,0,0,0,174,1399,1,0,0,0,176,1401,1,0,0,0,178,180,
        5,99,0,0,179,178,1,0,0,0,179,180,1,0,0,0,180,181,1,0,0,0,181,183,
        3,2,1,0,182,184,5,99,0,0,183,182,1,0,0,0,183,184,1,0,0,0,184,186,
        1,0,0,0,185,187,5,9,0,0,186,185,1,0,0,0,186,187,1,0,0,0,187,189,
        1,0,0,0,188,190,5,99,0,0,189,188,1,0,0,0,189,190,1,0,0,0,190,191,
        1,0,0,0,191,192,5,0,0,1,192,1,1,0,0,0,193,196,3,4,2,0,194,196,3,
        8,4,0,195,193,1,0,0,0,195,194,1,0,0,0,196,3,1,0,0,0,197,201,3,6,
        3,0,198,200,3,128,64,0,199,198,1,0,0,0,200,203,1,0,0,0,201,199,1,
        0,0,0,201,202,1,0,0,0,202,5,1,0,0,0,203,201,1,0,0,0,204,207,3,28,
        14,0,205,207,3,30,15,0,206,204,1,0,0,0,206,205,1,0,0,0,207,7,1,0,
        0,0,208,210,5,28,0,0,209,211,5,99,0,0,210,209,1,0,0,0,210,211,1,
        0,0,0,211,212,1,0,0,0,212,214,3,132,66,0,213,215,5,99,0,0,214,213,
        1,0,0,0,214,215,1,0,0,0,215,217,1,0,0,0,216,218,3,48,24,0,217,216,
        1,0,0,0,217,218,1,0,0,0,218,230,1,0,0,0,219,221,5,99,0,0,220,219,
        1,0,0,0,220,221,1,0,0,0,221,222,1,0,0,0,222,224,5,29,0,0,223,225,
        5,99,0,0,224,223,1,0,0,0,224,225,1,0,0,0,225,228,1,0,0,0,226,229,
        5,23,0,0,227,229,3,50,25,0,228,226,1,0,0,0,228,227,1,0,0,0,229,231,
        1,0,0,0,230,220,1,0,0,0,230,231,1,0,0,0,231,9,1,0,0,0,232,234,5,
        53,0,0,233,235,5,99,0,0,234,233,1,0,0,0,234,235,1,0,0,0,235,236,
        1,0,0,0,236,237,3,18,9,0,237,11,1,0,0,0,238,240,5,57,0,0,239,241,
        5,99,0,0,240,239,1,0,0,0,240,241,1,0,0,0,241,242,1,0,0,0,242,247,
        3,18,9,0,243,245,5,99,0,0,244,243,1,0,0,0,244,245,1,0,0,0,245,246,
        1,0,0,0,246,248,3,68,34,0,247,244,1,0,0,0,247,248,1,0,0,0,248,13,
        1,0,0,0,249,251,5,55,0,0,250,252,5,99,0,0,251,250,1,0,0,0,251,252,
        1,0,0,0,252,253,1,0,0,0,253,254,3,72,36,0,254,15,1,0,0,0,255,257,
        5,46,0,0,256,258,5,99,0,0,257,256,1,0,0,0,257,258,1,0,0,0,258,259,
        1,0,0,0,259,260,3,72,36,0,260,17,1,0,0,0,261,263,5,99,0,0,262,261,
        1,0,0,0,262,263,1,0,0,0,263,264,1,0,0,0,264,266,5,63,0,0,265,262,
        1,0,0,0,265,266,1,0,0,0,266,268,1,0,0,0,267,269,5,99,0,0,268,267,
        1,0,0,0,268,269,1,0,0,0,269,270,1,0,0,0,270,275,3,20,10,0,271,273,
        5,99,0,0,272,271,1,0,0,0,272,273,1,0,0,0,273,274,1,0,0,0,274,276,
        3,26,13,0,275,272,1,0,0,0,275,276,1,0,0,0,276,281,1,0,0,0,277,279,
        5,99,0,0,278,277,1,0,0,0,278,279,1,0,0,0,279,280,1,0,0,0,280,282,
        3,14,7,0,281,278,1,0,0,0,281,282,1,0,0,0,282,287,1,0,0,0,283,285,
        5,99,0,0,284,283,1,0,0,0,284,285,1,0,0,0,285,286,1,0,0,0,286,288,
        3,16,8,0,287,284,1,0,0,0,287,288,1,0,0,0,288,19,1,0,0,0,289,292,
        5,23,0,0,290,292,3,22,11,0,291,289,1,0,0,0,291,290,1,0,0,0,292,303,
        1,0,0,0,293,295,5,99,0,0,294,293,1,0,0,0,294,295,1,0,0,0,295,296,
        1,0,0,0,296,298,5,11,0,0,297,299,5,99,0,0,298,297,1,0,0,0,298,299,
        1,0,0,0,299,300,1,0,0,0,300,302,3,22,11,0,301,294,1,0,0,0,302,305,
        1,0,0,0,303,301,1,0,0,0,303,304,1,0,0,0,304,21,1,0,0,0,305,303,1,
        0,0,0,306,315,3,72,36,0,307,309,5,99,0,0,308,307,1,0,0,0,308,309,
        1,0,0,0,309,310,1,0,0,0,310,312,5,61,0,0,311,313,5,99,0,0,312,311,
        1,0,0,0,312,313,1,0,0,0,313,314,1,0,0,0,314,316,3,174,87,0,315,308,
        1,0,0,0,315,316,1,0,0,0,316,23,1,0,0,0,317,322,3,72,36,0,318,320,
        5,99,0,0,319,318,1,0,0,0,319,320,1,0,0,0,320,321,1,0,0,0,321,323,
        7,0,0,0,322,319,1,0,0,0,322,323,1,0,0,0,323,25,1,0,0,0,324,326,5,
        51,0,0,325,327,5,99,0,0,326,325,1,0,0,0,326,327,1,0,0,0,327,328,
        1,0,0,0,328,330,5,39,0,0,329,331,5,99,0,0,330,329,1,0,0,0,330,331,
        1,0,0,0,331,332,1,0,0,0,332,343,3,24,12,0,333,335,5,99,0,0,334,333,
        1,0,0,0,334,335,1,0,0,0,335,336,1,0,0,0,336,338,5,11,0,0,337,339,
        5,99,0,0,338,337,1,0,0,0,338,339,1,0,0,0,339,340,1,0,0,0,340,342,
        3,24,12,0,341,334,1,0,0,0,342,345,1,0,0,0,343,341,1,0,0,0,343,344,
        1,0,0,0,344,27,1,0,0,0,345,343,1,0,0,0,346,348,3,36,18,0,347,349,
        5,99,0,0,348,347,1,0,0,0,348,349,1,0,0,0,349,351,1,0,0,0,350,346,
        1,0,0,0,351,354,1,0,0,0,352,350,1,0,0,0,352,353,1,0,0,0,353,370,
        1,0,0,0,354,352,1,0,0,0,355,371,3,10,5,0,356,358,3,38,19,0,357,359,
        5,99,0,0,358,357,1,0,0,0,358,359,1,0,0,0,359,361,1,0,0,0,360,356,
        1,0,0,0,361,362,1,0,0,0,362,360,1,0,0,0,362,363,1,0,0,0,363,368,
        1,0,0,0,364,366,5,99,0,0,365,364,1,0,0,0,365,366,1,0,0,0,366,367,
        1,0,0,0,367,369,3,10,5,0,368,365,1,0,0,0,368,369,1,0,0,0,369,371,
        1,0,0,0,370,355,1,0,0,0,370,360,1,0,0,0,371,29,1,0,0,0,372,374,3,
        36,18,0,373,375,5,99,0,0,374,373,1,0,0,0,374,375,1,0,0,0,375,377,
        1,0,0,0,376,372,1,0,0,0,377,380,1,0,0,0,378,376,1,0,0,0,378,379,
        1,0,0,0,379,387,1,0,0,0,380,378,1,0,0,0,381,383,3,38,19,0,382,384,
        5,99,0,0,383,382,1,0,0,0,383,384,1,0,0,0,384,386,1,0,0,0,385,381,
        1,0,0,0,386,389,1,0,0,0,387,385,1,0,0,0,387,388,1,0,0,0,388,390,
        1,0,0,0,389,387,1,0,0,0,390,392,3,12,6,0,391,393,5,99,0,0,392,391,
        1,0,0,0,392,393,1,0,0,0,393,394,1,0,0,0,394,395,3,28,14,0,395,31,
        1,0,0,0,396,397,5,50,0,0,397,399,5,99,0,0,398,396,1,0,0,0,398,399,
        1,0,0,0,399,400,1,0,0,0,400,402,5,47,0,0,401,403,5,99,0,0,402,401,
        1,0,0,0,402,403,1,0,0,0,403,404,1,0,0,0,404,405,3,66,33,0,405,33,
        1,0,0,0,406,408,5,59,0,0,407,409,5,99,0,0,408,407,1,0,0,0,408,409,
        1,0,0,0,409,410,1,0,0,0,410,412,3,72,36,0,411,413,5,99,0,0,412,411,
        1,0,0,0,412,413,1,0,0,0,413,414,1,0,0,0,414,416,5,61,0,0,415,417,
        5,99,0,0,416,415,1,0,0,0,416,417,1,0,0,0,417,418,1,0,0,0,418,419,
        3,174,87,0,419,35,1,0,0,0,420,424,3,32,16,0,421,424,3,34,17,0,422,
        424,3,46,23,0,423,420,1,0,0,0,423,421,1,0,0,0,423,422,1,0,0,0,424,
        37,1,0,0,0,425,431,3,64,32,0,426,431,3,54,27,0,427,431,3,40,20,0,
        428,431,3,58,29,0,429,431,3,42,21,0,430,425,1,0,0,0,430,426,1,0,
        0,0,430,427,1,0,0,0,430,428,1,0,0,0,430,429,1,0,0,0,431,39,1,0,0,
        0,432,433,5,44,0,0,433,435,5,99,0,0,434,432,1,0,0,0,434,435,1,0,
        0,0,435,436,1,0,0,0,436,438,5,41,0,0,437,439,5,99,0,0,438,437,1,
        0,0,0,438,439,1,0,0,0,439,440,1,0,0,0,440,441,3,150,75,0,441,41,
        1,0,0,0,442,444,5,52,0,0,443,445,5,99,0,0,444,443,1,0,0,0,444,445,
        1,0,0,0,445,446,1,0,0,0,446,457,3,44,22,0,447,449,5,99,0,0,448,447,
        1,0,0,0,448,449,1,0,0,0,449,450,1,0,0,0,450,452,5,11,0,0,451,453,
        5,99,0,0,452,451,1,0,0,0,452,453,1,0,0,0,453,454,1,0,0,0,454,456,
        3,44,22,0,455,448,1,0,0,0,456,459,1,0,0,0,457,455,1,0,0,0,457,458,
        1,0,0,0,458,43,1,0,0,0,459,457,1,0,0,0,460,462,3,174,87,0,461,463,
        5,99,0,0,462,461,1,0,0,0,462,463,1,0,0,0,463,464,1,0,0,0,464,465,
        3,62,31,0,465,468,1,0,0,0,466,468,3,104,52,0,467,460,1,0,0,0,467,
        466,1,0,0,0,468,45,1,0,0,0,469,471,5,28,0,0,470,472,5,99,0,0,471,
        470,1,0,0,0,471,472,1,0,0,0,472,473,1,0,0,0,473,475,3,132,66,0,474,
        476,5,99,0,0,475,474,1,0,0,0,475,476,1,0,0,0,476,477,1,0,0,0,477,
        486,3,48,24,0,478,480,5,99,0,0,479,478,1,0,0,0,479,480,1,0,0,0,480,
        481,1,0,0,0,481,483,5,29,0,0,482,484,5,99,0,0,483,482,1,0,0,0,483,
        484,1,0,0,0,484,485,1,0,0,0,485,487,3,50,25,0,486,479,1,0,0,0,486,
        487,1,0,0,0,487,47,1,0,0,0,488,490,5,12,0,0,489,491,5,99,0,0,490,
        489,1,0,0,0,490,491,1,0,0,0,491,493,1,0,0,0,492,494,3,150,75,0,493,
        492,1,0,0,0,493,494,1,0,0,0,494,496,1,0,0,0,495,497,5,99,0,0,496,
        495,1,0,0,0,496,497,1,0,0,0,497,498,1,0,0,0,498,499,5,13,0,0,499,
        49,1,0,0,0,500,511,3,52,26,0,501,503,5,99,0,0,502,501,1,0,0,0,502,
        503,1,0,0,0,503,504,1,0,0,0,504,506,5,11,0,0,505,507,5,99,0,0,506,
        505,1,0,0,0,506,507,1,0,0,0,507,508,1,0,0,0,508,510,3,52,26,0,509,
        502,1,0,0,0,510,513,1,0,0,0,511,509,1,0,0,0,511,512,1,0,0,0,512,
        518,1,0,0,0,513,511,1,0,0,0,514,516,5,99,0,0,515,514,1,0,0,0,515,
        516,1,0,0,0,516,517,1,0,0,0,517,519,3,68,34,0,518,515,1,0,0,0,518,
        519,1,0,0,0,519,51,1,0,0,0,520,522,3,174,87,0,521,523,5,99,0,0,522,
        521,1,0,0,0,522,523,1,0,0,0,523,524,1,0,0,0,524,526,5,61,0,0,525,
        527,5,99,0,0,526,525,1,0,0,0,526,527,1,0,0,0,527,529,1,0,0,0,528,
        520,1,0,0,0,528,529,1,0,0,0,529,530,1,0,0,0,530,531,3,174,87,0,531,
        53,1,0,0,0,532,534,5,48,0,0,533,535,5,99,0,0,534,533,1,0,0,0,534,
        535,1,0,0,0,535,536,1,0,0,0,536,543,3,106,53,0,537,539,5,99,0,0,
        538,537,1,0,0,0,538,539,1,0,0,0,539,540,1,0,0,0,540,542,3,56,28,
        0,541,538,1,0,0,0,542,545,1,0,0,0,543,541,1,0,0,0,543,544,1,0,0,
        0,544,55,1,0,0,0,545,543,1,0,0,0,546,548,5,49,0,0,547,549,5,99,0,
        0,548,547,1,0,0,0,548,549,1,0,0,0,549,550,1,0,0,0,550,552,7,1,0,
        0,551,553,5,99,0,0,552,551,1,0,0,0,552,553,1,0,0,0,553,554,1,0,0,
        0,554,555,3,58,29,0,555,57,1,0,0,0,556,558,5,54,0,0,557,559,5,99,
        0,0,558,557,1,0,0,0,558,559,1,0,0,0,559,560,1,0,0,0,560,571,3,60,
        30,0,561,563,5,99,0,0,562,561,1,0,0,0,562,563,1,0,0,0,563,564,1,
        0,0,0,564,566,5,11,0,0,565,567,5,99,0,0,566,565,1,0,0,0,566,567,
        1,0,0,0,567,568,1,0,0,0,568,570,3,60,30,0,569,562,1,0,0,0,570,573,
        1,0,0,0,571,569,1,0,0,0,571,572,1,0,0,0,572,59,1,0,0,0,573,571,1,
        0,0,0,574,576,3,104,52,0,575,577,5,99,0,0,576,575,1,0,0,0,576,577,
        1,0,0,0,577,578,1,0,0,0,578,580,5,1,0,0,579,581,5,99,0,0,580,579,
        1,0,0,0,580,581,1,0,0,0,581,582,1,0,0,0,582,583,3,72,36,0,583,601,
        1,0,0,0,584,586,3,174,87,0,585,587,5,99,0,0,586,585,1,0,0,0,586,
        587,1,0,0,0,587,588,1,0,0,0,588,590,7,2,0,0,589,591,5,99,0,0,590,
        589,1,0,0,0,590,591,1,0,0,0,591,592,1,0,0,0,592,593,3,72,36,0,593,
        601,1,0,0,0,594,596,3,174,87,0,595,597,5,99,0,0,596,595,1,0,0,0,
        596,597,1,0,0,0,597,598,1,0,0,0,598,599,3,62,31,0,599,601,1,0,0,
        0,600,574,1,0,0,0,600,584,1,0,0,0,600,594,1,0,0,0,601,61,1,0,0,0,
        602,604,5,25,0,0,603,605,5,99,0,0,604,603,1,0,0,0,604,605,1,0,0,
        0,605,606,1,0,0,0,606,608,3,172,86,0,607,602,1,0,0,0,608,609,1,0,
        0,0,609,607,1,0,0,0,609,610,1,0,0,0,610,63,1,0,0,0,611,613,5,40,
        0,0,612,614,5,99,0,0,613,612,1,0,0,0,613,614,1,0,0,0,614,615,1,0,
        0,0,615,616,3,70,35,0,616,65,1,0,0,0,617,622,3,70,35,0,618,620,5,
        99,0,0,619,618,1,0,0,0,619,620,1,0,0,0,620,621,1,0,0,0,621,623,3,
        68,34,0,622,619,1,0,0,0,622,623,1,0,0,0,623,67,1,0,0,0,624,626,5,
        56,0,0,625,627,5,99,0,0,626,625,1,0,0,0,626,627,1,0,0,0,627,628,
        1,0,0,0,628,629,3,72,36,0,629,69,1,0,0,0,630,641,3,106,53,0,631,
        633,5,99,0,0,632,631,1,0,0,0,632,633,1,0,0,0,633,634,1,0,0,0,634,
        636,5,11,0,0,635,637,5,99,0,0,636,635,1,0,0,0,636,637,1,0,0,0,637,
        638,1,0,0,0,638,640,3,106,53,0,639,632,1,0,0,0,640,643,1,0,0,0,641,
        639,1,0,0,0,641,642,1,0,0,0,642,71,1,0,0,0,643,641,1,0,0,0,644,655,
        3,74,37,0,645,647,5,99,0,0,646,645,1,0,0,0,646,647,1,0,0,0,647,648,
        1,0,0,0,648,650,5,68,0,0,649,651,5,99,0,0,650,649,1,0,0,0,650,651,
        1,0,0,0,651,652,1,0,0,0,652,654,3,74,37,0,653,646,1,0,0,0,654,657,
        1,0,0,0,655,653,1,0,0,0,655,656,1,0,0,0,656,73,1,0,0,0,657,655,1,
        0,0,0,658,669,3,76,38,0,659,661,5,99,0,0,660,659,1,0,0,0,660,661,
        1,0,0,0,661,662,1,0,0,0,662,664,5,70,0,0,663,665,5,99,0,0,664,663,
        1,0,0,0,664,665,1,0,0,0,665,666,1,0,0,0,666,668,3,76,38,0,667,660,
        1,0,0,0,668,671,1,0,0,0,669,667,1,0,0,0,669,670,1,0,0,0,670,75,1,
        0,0,0,671,669,1,0,0,0,672,683,3,78,39,0,673,675,5,99,0,0,674,673,
        1,0,0,0,674,675,1,0,0,0,675,676,1,0,0,0,676,678,5,60,0,0,677,679,
        5,99,0,0,678,677,1,0,0,0,678,679,1,0,0,0,679,680,1,0,0,0,680,682,
        3,78,39,0,681,674,1,0,0,0,682,685,1,0,0,0,683,681,1,0,0,0,683,684,
        1,0,0,0,684,77,1,0,0,0,685,683,1,0,0,0,686,688,5,67,0,0,687,689,
        5,99,0,0,688,687,1,0,0,0,688,689,1,0,0,0,689,691,1,0,0,0,690,686,
        1,0,0,0,691,694,1,0,0,0,692,690,1,0,0,0,692,693,1,0,0,0,693,695,
        1,0,0,0,694,692,1,0,0,0,695,696,3,80,40,0,696,79,1,0,0,0,697,709,
        3,84,42,0,698,700,5,99,0,0,699,698,1,0,0,0,699,700,1,0,0,0,700,701,
        1,0,0,0,701,703,3,82,41,0,702,704,5,99,0,0,703,702,1,0,0,0,703,704,
        1,0,0,0,704,705,1,0,0,0,705,706,3,84,42,0,706,708,1,0,0,0,707,699,
        1,0,0,0,708,711,1,0,0,0,709,707,1,0,0,0,709,710,1,0,0,0,710,81,1,
        0,0,0,711,709,1,0,0,0,712,713,7,3,0,0,713,83,1,0,0,0,714,725,3,86,
        43,0,715,717,5,99,0,0,716,715,1,0,0,0,716,717,1,0,0,0,717,718,1,
        0,0,0,718,720,7,4,0,0,719,721,5,99,0,0,720,719,1,0,0,0,720,721,1,
        0,0,0,721,722,1,0,0,0,722,724,3,86,43,0,723,716,1,0,0,0,724,727,
        1,0,0,0,725,723,1,0,0,0,725,726,1,0,0,0,726,85,1,0,0,0,727,725,1,
        0,0,0,728,739,3,88,44,0,729,731,5,99,0,0,730,729,1,0,0,0,730,731,
        1,0,0,0,731,732,1,0,0,0,732,734,7,5,0,0,733,735,5,99,0,0,734,733,
        1,0,0,0,734,735,1,0,0,0,735,736,1,0,0,0,736,738,3,88,44,0,737,730,
        1,0,0,0,738,741,1,0,0,0,739,737,1,0,0,0,739,740,1,0,0,0,740,87,1,
        0,0,0,741,739,1,0,0,0,742,753,3,90,45,0,743,745,5,99,0,0,744,743,
        1,0,0,0,744,745,1,0,0,0,745,746,1,0,0,0,746,748,5,22,0,0,747,749,
        5,99,0,0,748,747,1,0,0,0,748,749,1,0,0,0,749,750,1,0,0,0,750,752,
        3,90,45,0,751,744,1,0,0,0,752,755,1,0,0,0,753,751,1,0,0,0,753,754,
        1,0,0,0,754,89,1,0,0,0,755,753,1,0,0,0,756,758,7,4,0,0,757,756,1,
        0,0,0,757,758,1,0,0,0,758,760,1,0,0,0,759,761,5,99,0,0,760,759,1,
        0,0,0,760,761,1,0,0,0,761,762,1,0,0,0,762,763,3,92,46,0,763,91,1,
        0,0,0,764,775,3,102,51,0,765,767,5,99,0,0,766,765,1,0,0,0,766,767,
        1,0,0,0,767,771,1,0,0,0,768,772,3,96,48,0,769,772,3,94,47,0,770,
        772,3,100,50,0,771,768,1,0,0,0,771,769,1,0,0,0,771,770,1,0,0,0,772,
        774,1,0,0,0,773,766,1,0,0,0,774,777,1,0,0,0,775,773,1,0,0,0,775,
        776,1,0,0,0,776,93,1,0,0,0,777,775,1,0,0,0,778,780,5,99,0,0,779,
        778,1,0,0,0,779,780,1,0,0,0,780,781,1,0,0,0,781,783,5,65,0,0,782,
        784,5,99,0,0,783,782,1,0,0,0,783,784,1,0,0,0,784,785,1,0,0,0,785,
        811,3,102,51,0,786,788,5,16,0,0,787,789,5,99,0,0,788,787,1,0,0,0,
        788,789,1,0,0,0,789,804,1,0,0,0,790,792,3,72,36,0,791,790,1,0,0,
        0,791,792,1,0,0,0,792,794,1,0,0,0,793,795,5,99,0,0,794,793,1,0,0,
        0,794,795,1,0,0,0,795,796,1,0,0,0,796,798,5,8,0,0,797,799,5,99,0,
        0,798,797,1,0,0,0,798,799,1,0,0,0,799,801,1,0,0,0,800,802,3,72,36,
        0,801,800,1,0,0,0,801,802,1,0,0,0,802,805,1,0,0,0,803,805,3,72,36,
        0,804,791,1,0,0,0,804,803,1,0,0,0,805,807,1,0,0,0,806,808,5,99,0,
        0,807,806,1,0,0,0,807,808,1,0,0,0,808,809,1,0,0,0,809,811,5,17,0,
        0,810,779,1,0,0,0,810,786,1,0,0,0,811,95,1,0,0,0,812,814,3,98,49,
        0,813,815,5,99,0,0,814,813,1,0,0,0,814,815,1,0,0,0,815,816,1,0,0,
        0,816,817,3,102,51,0,817,97,1,0,0,0,818,820,5,69,0,0,819,821,5,99,
        0,0,820,819,1,0,0,0,820,821,1,0,0,0,821,822,1,0,0,0,822,830,5,57,
        0,0,823,825,5,64,0,0,824,826,5,99,0,0,825,824,1,0,0,0,825,826,1,
        0,0,0,826,827,1,0,0,0,827,830,5,57,0,0,828,830,5,62,0,0,829,818,
        1,0,0,0,829,823,1,0,0,0,829,828,1,0,0,0,830,99,1,0,0,0,831,833,5,
        99,0,0,832,831,1,0,0,0,832,833,1,0,0,0,833,834,1,0,0,0,834,836,5,
        66,0,0,835,837,5,99,0,0,836,835,1,0,0,0,836,837,1,0,0,0,837,839,
        1,0,0,0,838,840,5,67,0,0,839,838,1,0,0,0,839,840,1,0,0,0,840,842,
        1,0,0,0,841,843,5,99,0,0,842,841,1,0,0,0,842,843,1,0,0,0,843,844,
        1,0,0,0,844,845,5,73,0,0,845,101,1,0,0,0,846,851,3,104,52,0,847,
        849,5,99,0,0,848,847,1,0,0,0,848,849,1,0,0,0,849,850,1,0,0,0,850,
        852,3,62,31,0,851,848,1,0,0,0,851,852,1,0,0,0,852,103,1,0,0,0,853,
        864,3,116,58,0,854,856,5,99,0,0,855,854,1,0,0,0,855,856,1,0,0,0,
        856,857,1,0,0,0,857,859,5,10,0,0,858,860,5,99,0,0,859,858,1,0,0,
        0,859,860,1,0,0,0,860,861,1,0,0,0,861,863,3,172,86,0,862,855,1,0,
        0,0,863,866,1,0,0,0,864,862,1,0,0,0,864,865,1,0,0,0,865,105,1,0,
        0,0,866,864,1,0,0,0,867,869,3,174,87,0,868,870,5,99,0,0,869,868,
        1,0,0,0,869,870,1,0,0,0,870,871,1,0,0,0,871,873,5,1,0,0,872,874,
        5,99,0,0,873,872,1,0,0,0,873,874,1,0,0,0,874,876,1,0,0,0,875,867,
        1,0,0,0,875,876,1,0,0,0,876,877,1,0,0,0,877,878,3,108,54,0,878,107,
        1,0,0,0,879,886,3,114,57,0,880,882,5,99,0,0,881,880,1,0,0,0,881,
        882,1,0,0,0,882,883,1,0,0,0,883,885,3,110,55,0,884,881,1,0,0,0,885,
        888,1,0,0,0,886,884,1,0,0,0,886,887,1,0,0,0,887,901,1,0,0,0,888,
        886,1,0,0,0,889,891,5,12,0,0,890,892,5,99,0,0,891,890,1,0,0,0,891,
        892,1,0,0,0,892,893,1,0,0,0,893,895,3,108,54,0,894,896,5,99,0,0,
        895,894,1,0,0,0,895,896,1,0,0,0,896,897,1,0,0,0,897,898,5,13,0,0,
        898,901,1,0,0,0,899,901,3,134,67,0,900,879,1,0,0,0,900,889,1,0,0,
        0,900,899,1,0,0,0,901,109,1,0,0,0,902,904,3,120,60,0,903,905,5,99,
        0,0,904,903,1,0,0,0,904,905,1,0,0,0,905,906,1,0,0,0,906,907,3,114,
        57,0,907,111,1,0,0,0,908,911,3,168,84,0,909,911,3,154,77,0,910,908,
        1,0,0,0,910,909,1,0,0,0,911,113,1,0,0,0,912,914,5,12,0,0,913,915,
        5,99,0,0,914,913,1,0,0,0,914,915,1,0,0,0,915,917,1,0,0,0,916,918,
        3,174,87,0,917,916,1,0,0,0,917,918,1,0,0,0,918,920,1,0,0,0,919,921,
        5,99,0,0,920,919,1,0,0,0,920,921,1,0,0,0,921,923,1,0,0,0,922,924,
        3,62,31,0,923,922,1,0,0,0,923,924,1,0,0,0,924,926,1,0,0,0,925,927,
        5,99,0,0,926,925,1,0,0,0,926,927,1,0,0,0,927,929,1,0,0,0,928,930,
        3,112,56,0,929,928,1,0,0,0,929,930,1,0,0,0,930,932,1,0,0,0,931,933,
        5,99,0,0,932,931,1,0,0,0,932,933,1,0,0,0,933,934,1,0,0,0,934,935,
        5,13,0,0,935,115,1,0,0,0,936,949,3,156,78,0,937,949,3,154,77,0,938,
        949,3,152,76,0,939,949,3,148,74,0,940,949,3,144,72,0,941,949,3,140,
        70,0,942,949,3,138,69,0,943,949,3,142,71,0,944,949,3,136,68,0,945,
        949,3,134,67,0,946,949,3,174,87,0,947,949,3,130,65,0,948,936,1,0,
        0,0,948,937,1,0,0,0,948,938,1,0,0,0,948,939,1,0,0,0,948,940,1,0,
        0,0,948,941,1,0,0,0,948,942,1,0,0,0,948,943,1,0,0,0,948,944,1,0,
        0,0,948,945,1,0,0,0,948,946,1,0,0,0,948,947,1,0,0,0,949,117,1,0,
        0,0,950,951,3,174,87,0,951,952,5,1,0,0,952,119,1,0,0,0,953,955,5,
        6,0,0,954,956,5,99,0,0,955,954,1,0,0,0,955,956,1,0,0,0,956,957,1,
        0,0,0,957,959,5,18,0,0,958,960,5,99,0,0,959,958,1,0,0,0,959,960,
        1,0,0,0,960,962,1,0,0,0,961,963,3,122,61,0,962,961,1,0,0,0,962,963,
        1,0,0,0,963,965,1,0,0,0,964,966,5,99,0,0,965,964,1,0,0,0,965,966,
        1,0,0,0,966,967,1,0,0,0,967,969,5,18,0,0,968,970,5,99,0,0,969,968,
        1,0,0,0,969,970,1,0,0,0,970,972,1,0,0,0,971,973,5,5,0,0,972,971,
        1,0,0,0,972,973,1,0,0,0,973,992,1,0,0,0,974,976,5,18,0,0,975,977,
        5,99,0,0,976,975,1,0,0,0,976,977,1,0,0,0,977,979,1,0,0,0,978,980,
        3,122,61,0,979,978,1,0,0,0,979,980,1,0,0,0,980,982,1,0,0,0,981,983,
        5,99,0,0,982,981,1,0,0,0,982,983,1,0,0,0,983,984,1,0,0,0,984,986,
        5,18,0,0,985,987,5,99,0,0,986,985,1,0,0,0,986,987,1,0,0,0,987,989,
        1,0,0,0,988,990,5,5,0,0,989,988,1,0,0,0,989,990,1,0,0,0,990,992,
        1,0,0,0,991,953,1,0,0,0,991,974,1,0,0,0,992,121,1,0,0,0,993,995,
        5,16,0,0,994,996,5,99,0,0,995,994,1,0,0,0,995,996,1,0,0,0,996,998,
        1,0,0,0,997,999,3,174,87,0,998,997,1,0,0,0,998,999,1,0,0,0,999,1001,
        1,0,0,0,1000,1002,5,99,0,0,1001,1000,1,0,0,0,1001,1002,1,0,0,0,1002,
        1004,1,0,0,0,1003,1005,3,126,63,0,1004,1003,1,0,0,0,1004,1005,1,
        0,0,0,1005,1007,1,0,0,0,1006,1008,5,99,0,0,1007,1006,1,0,0,0,1007,
        1008,1,0,0,0,1008,1010,1,0,0,0,1009,1011,3,124,62,0,1010,1009,1,
        0,0,0,1010,1011,1,0,0,0,1011,1013,1,0,0,0,1012,1014,5,99,0,0,1013,
        1012,1,0,0,0,1013,1014,1,0,0,0,1014,1016,1,0,0,0,1015,1017,3,112,
        56,0,1016,1015,1,0,0,0,1016,1017,1,0,0,0,1017,1019,1,0,0,0,1018,
        1020,5,99,0,0,1019,1018,1,0,0,0,1019,1020,1,0,0,0,1020,1021,1,0,
        0,0,1021,1022,5,17,0,0,1022,123,1,0,0,0,1023,1025,5,23,0,0,1024,
        1026,5,99,0,0,1025,1024,1,0,0,0,1025,1026,1,0,0,0,1026,1028,1,0,
        0,0,1027,1029,5,92,0,0,1028,1027,1,0,0,0,1028,1029,1,0,0,0,1029,
        1040,1,0,0,0,1030,1032,5,99,0,0,1031,1030,1,0,0,0,1031,1032,1,0,
        0,0,1032,1033,1,0,0,0,1033,1035,5,8,0,0,1034,1036,5,99,0,0,1035,
        1034,1,0,0,0,1035,1036,1,0,0,0,1036,1038,1,0,0,0,1037,1039,5,92,
        0,0,1038,1037,1,0,0,0,1038,1039,1,0,0,0,1039,1041,1,0,0,0,1040,1031,
        1,0,0,0,1040,1041,1,0,0,0,1041,125,1,0,0,0,1042,1044,5,25,0,0,1043,
        1045,5,99,0,0,1044,1043,1,0,0,0,1044,1045,1,0,0,0,1045,1046,1,0,
        0,0,1046,1063,3,172,86,0,1047,1049,5,99,0,0,1048,1047,1,0,0,0,1048,
        1049,1,0,0,0,1049,1050,1,0,0,0,1050,1052,5,26,0,0,1051,1053,5,99,
        0,0,1052,1051,1,0,0,0,1052,1053,1,0,0,0,1053,1055,1,0,0,0,1054,1056,
        5,25,0,0,1055,1054,1,0,0,0,1055,1056,1,0,0,0,1056,1058,1,0,0,0,1057,
        1059,5,99,0,0,1058,1057,1,0,0,0,1058,1059,1,0,0,0,1059,1060,1,0,
        0,0,1060,1062,3,172,86,0,1061,1048,1,0,0,0,1062,1065,1,0,0,0,1063,
        1061,1,0,0,0,1063,1064,1,0,0,0,1064,127,1,0,0,0,1065,1063,1,0,0,
        0,1066,1068,5,58,0,0,1067,1069,5,99,0,0,1068,1067,1,0,0,0,1068,1069,
        1,0,0,0,1069,1071,1,0,0,0,1070,1072,5,36,0,0,1071,1070,1,0,0,0,1071,
        1072,1,0,0,0,1072,1074,1,0,0,0,1073,1075,5,99,0,0,1074,1073,1,0,
        0,0,1074,1075,1,0,0,0,1075,1076,1,0,0,0,1076,1077,3,6,3,0,1077,129,
        1,0,0,0,1078,1080,5,45,0,0,1079,1081,5,99,0,0,1080,1079,1,0,0,0,
        1080,1081,1,0,0,0,1081,1082,1,0,0,0,1082,1084,5,14,0,0,1083,1085,
        5,99,0,0,1084,1083,1,0,0,0,1084,1085,1,0,0,0,1085,1088,1,0,0,0,1086,
        1089,3,4,2,0,1087,1089,3,66,33,0,1088,1086,1,0,0,0,1088,1087,1,0,
        0,0,1089,1091,1,0,0,0,1090,1092,5,99,0,0,1091,1090,1,0,0,0,1091,
        1092,1,0,0,0,1092,1093,1,0,0,0,1093,1094,5,15,0,0,1094,131,1,0,0,
        0,1095,1106,3,174,87,0,1096,1098,5,99,0,0,1097,1096,1,0,0,0,1097,
        1098,1,0,0,0,1098,1099,1,0,0,0,1099,1101,5,10,0,0,1100,1102,5,99,
        0,0,1101,1100,1,0,0,0,1101,1102,1,0,0,0,1102,1103,1,0,0,0,1103,1105,
        3,174,87,0,1104,1097,1,0,0,0,1105,1108,1,0,0,0,1106,1104,1,0,0,0,
        1106,1107,1,0,0,0,1107,133,1,0,0,0,1108,1106,1,0,0,0,1109,1111,3,
        132,66,0,1110,1112,5,99,0,0,1111,1110,1,0,0,0,1111,1112,1,0,0,0,
        1112,1113,1,0,0,0,1113,1115,5,12,0,0,1114,1116,5,99,0,0,1115,1114,
        1,0,0,0,1115,1116,1,0,0,0,1116,1121,1,0,0,0,1117,1119,5,63,0,0,1118,
        1120,5,99,0,0,1119,1118,1,0,0,0,1119,1120,1,0,0,0,1120,1122,1,0,
        0,0,1121,1117,1,0,0,0,1121,1122,1,0,0,0,1122,1123,1,0,0,0,1123,1125,
        3,108,54,0,1124,1126,5,99,0,0,1125,1124,1,0,0,0,1125,1126,1,0,0,
        0,1126,1127,1,0,0,0,1127,1128,5,13,0,0,1128,1152,1,0,0,0,1129,1131,
        3,132,66,0,1130,1132,5,99,0,0,1131,1130,1,0,0,0,1131,1132,1,0,0,
        0,1132,1133,1,0,0,0,1133,1135,5,12,0,0,1134,1136,5,99,0,0,1135,1134,
        1,0,0,0,1135,1136,1,0,0,0,1136,1141,1,0,0,0,1137,1139,5,63,0,0,1138,
        1140,5,99,0,0,1139,1138,1,0,0,0,1139,1140,1,0,0,0,1140,1142,1,0,
        0,0,1141,1137,1,0,0,0,1141,1142,1,0,0,0,1142,1144,1,0,0,0,1143,1145,
        3,150,75,0,1144,1143,1,0,0,0,1144,1145,1,0,0,0,1145,1147,1,0,0,0,
        1146,1148,5,99,0,0,1147,1146,1,0,0,0,1147,1148,1,0,0,0,1148,1149,
        1,0,0,0,1149,1150,5,13,0,0,1150,1152,1,0,0,0,1151,1109,1,0,0,0,1151,
        1129,1,0,0,0,1152,135,1,0,0,0,1153,1155,5,12,0,0,1154,1156,5,99,
        0,0,1155,1154,1,0,0,0,1155,1156,1,0,0,0,1156,1157,1,0,0,0,1157,1159,
        3,72,36,0,1158,1160,5,99,0,0,1159,1158,1,0,0,0,1159,1160,1,0,0,0,
        1160,1161,1,0,0,0,1161,1162,5,13,0,0,1162,137,1,0,0,0,1163,1165,
        7,6,0,0,1164,1166,5,99,0,0,1165,1164,1,0,0,0,1165,1166,1,0,0,0,1166,
        1167,1,0,0,0,1167,1169,5,12,0,0,1168,1170,5,99,0,0,1169,1168,1,0,
        0,0,1169,1170,1,0,0,0,1170,1171,1,0,0,0,1171,1173,3,146,73,0,1172,
        1174,5,99,0,0,1173,1172,1,0,0,0,1173,1174,1,0,0,0,1174,1175,1,0,
        0,0,1175,1176,5,13,0,0,1176,139,1,0,0,0,1177,1179,5,16,0,0,1178,
        1180,5,99,0,0,1179,1178,1,0,0,0,1179,1180,1,0,0,0,1180,1189,1,0,
        0,0,1181,1183,3,118,59,0,1182,1184,5,99,0,0,1183,1182,1,0,0,0,1183,
        1184,1,0,0,0,1184,1185,1,0,0,0,1185,1187,5,1,0,0,1186,1188,5,99,
        0,0,1187,1186,1,0,0,0,1187,1188,1,0,0,0,1188,1190,1,0,0,0,1189,1181,
        1,0,0,0,1189,1190,1,0,0,0,1190,1191,1,0,0,0,1191,1196,3,142,71,0,
        1192,1194,5,99,0,0,1193,1192,1,0,0,0,1193,1194,1,0,0,0,1194,1195,
        1,0,0,0,1195,1197,3,68,34,0,1196,1193,1,0,0,0,1196,1197,1,0,0,0,
        1197,1199,1,0,0,0,1198,1200,5,99,0,0,1199,1198,1,0,0,0,1199,1200,
        1,0,0,0,1200,1201,1,0,0,0,1201,1203,5,26,0,0,1202,1204,5,99,0,0,
        1203,1202,1,0,0,0,1203,1204,1,0,0,0,1204,1205,1,0,0,0,1205,1207,
        3,72,36,0,1206,1208,5,99,0,0,1207,1206,1,0,0,0,1207,1208,1,0,0,0,
        1208,1209,1,0,0,0,1209,1210,5,17,0,0,1210,141,1,0,0,0,1211,1216,
        3,114,57,0,1212,1214,5,99,0,0,1213,1212,1,0,0,0,1213,1214,1,0,0,
        0,1214,1215,1,0,0,0,1215,1217,3,110,55,0,1216,1213,1,0,0,0,1217,
        1218,1,0,0,0,1218,1216,1,0,0,0,1218,1219,1,0,0,0,1219,143,1,0,0,
        0,1220,1222,5,16,0,0,1221,1223,5,99,0,0,1222,1221,1,0,0,0,1222,1223,
        1,0,0,0,1223,1224,1,0,0,0,1224,1233,3,146,73,0,1225,1227,5,99,0,
        0,1226,1225,1,0,0,0,1226,1227,1,0,0,0,1227,1228,1,0,0,0,1228,1230,
        5,26,0,0,1229,1231,5,99,0,0,1230,1229,1,0,0,0,1230,1231,1,0,0,0,
        1231,1232,1,0,0,0,1232,1234,3,72,36,0,1233,1226,1,0,0,0,1233,1234,
        1,0,0,0,1234,1236,1,0,0,0,1235,1237,5,99,0,0,1236,1235,1,0,0,0,1236,
        1237,1,0,0,0,1237,1238,1,0,0,0,1238,1239,5,17,0,0,1239,145,1,0,0,
        0,1240,1242,3,174,87,0,1241,1243,5,99,0,0,1242,1241,1,0,0,0,1242,
        1243,1,0,0,0,1243,1244,1,0,0,0,1244,1246,5,65,0,0,1245,1247,5,99,
        0,0,1246,1245,1,0,0,0,1246,1247,1,0,0,0,1247,1248,1,0,0,0,1248,1253,
        3,72,36,0,1249,1251,5,99,0,0,1250,1249,1,0,0,0,1250,1251,1,0,0,0,
        1251,1252,1,0,0,0,1252,1254,3,68,34,0,1253,1250,1,0,0,0,1253,1254,
        1,0,0,0,1254,147,1,0,0,0,1255,1257,5,32,0,0,1256,1258,5,99,0,0,1257,
        1256,1,0,0,0,1257,1258,1,0,0,0,1258,1259,1,0,0,0,1259,1261,5,12,
        0,0,1260,1262,5,99,0,0,1261,1260,1,0,0,0,1261,1262,1,0,0,0,1262,
        1263,1,0,0,0,1263,1265,5,23,0,0,1264,1266,5,99,0,0,1265,1264,1,0,
        0,0,1265,1266,1,0,0,0,1266,1267,1,0,0,0,1267,1268,5,13,0,0,1268,
        149,1,0,0,0,1269,1280,3,72,36,0,1270,1272,5,99,0,0,1271,1270,1,0,
        0,0,1271,1272,1,0,0,0,1272,1273,1,0,0,0,1273,1275,5,11,0,0,1274,
        1276,5,99,0,0,1275,1274,1,0,0,0,1275,1276,1,0,0,0,1276,1277,1,0,
        0,0,1277,1279,3,72,36,0,1278,1271,1,0,0,0,1279,1282,1,0,0,0,1280,
        1278,1,0,0,0,1280,1281,1,0,0,0,1281,151,1,0,0,0,1282,1280,1,0,0,
        0,1283,1285,5,79,0,0,1284,1286,5,99,0,0,1285,1284,1,0,0,0,1285,1286,
        1,0,0,0,1286,1288,1,0,0,0,1287,1289,3,72,36,0,1288,1287,1,0,0,0,
        1288,1289,1,0,0,0,1289,1307,1,0,0,0,1290,1292,5,99,0,0,1291,1290,
        1,0,0,0,1291,1292,1,0,0,0,1292,1293,1,0,0,0,1293,1295,5,80,0,0,1294,
        1296,5,99,0,0,1295,1294,1,0,0,0,1295,1296,1,0,0,0,1296,1297,1,0,
        0,0,1297,1299,3,72,36,0,1298,1300,5,99,0,0,1299,1298,1,0,0,0,1299,
        1300,1,0,0,0,1300,1301,1,0,0,0,1301,1303,5,81,0,0,1302,1304,5,99,
        0,0,1303,1302,1,0,0,0,1303,1304,1,0,0,0,1304,1305,1,0,0,0,1305,1306,
        3,72,36,0,1306,1308,1,0,0,0,1307,1291,1,0,0,0,1308,1309,1,0,0,0,
        1309,1307,1,0,0,0,1309,1310,1,0,0,0,1310,1319,1,0,0,0,1311,1313,
        5,99,0,0,1312,1311,1,0,0,0,1312,1313,1,0,0,0,1313,1314,1,0,0,0,1314,
        1316,5,82,0,0,1315,1317,5,99,0,0,1316,1315,1,0,0,0,1316,1317,1,0,
        0,0,1317,1318,1,0,0,0,1318,1320,3,72,36,0,1319,1312,1,0,0,0,1319,
        1320,1,0,0,0,1320,1322,1,0,0,0,1321,1323,5,99,0,0,1322,1321,1,0,
        0,0,1322,1323,1,0,0,0,1323,1324,1,0,0,0,1324,1325,5,83,0,0,1325,
        153,1,0,0,0,1326,1329,5,27,0,0,1327,1330,3,174,87,0,1328,1330,3,
        160,80,0,1329,1327,1,0,0,0,1329,1328,1,0,0,0,1330,155,1,0,0,0,1331,
        1339,3,158,79,0,1332,1339,3,160,80,0,1333,1339,5,73,0,0,1334,1339,
        3,162,81,0,1335,1339,3,164,82,0,1336,1339,3,166,83,0,1337,1339,3,
        168,84,0,1338,1331,1,0,0,0,1338,1332,1,0,0,0,1338,1333,1,0,0,0,1338,
        1334,1,0,0,0,1338,1335,1,0,0,0,1338,1336,1,0,0,0,1338,1337,1,0,0,
        0,1339,157,1,0,0,0,1340,1341,7,7,0,0,1341,159,1,0,0,0,1342,1343,
        5,93,0,0,1343,161,1,0,0,0,1344,1345,5,91,0,0,1345,163,1,0,0,0,1346,
        1347,5,90,0,0,1347,165,1,0,0,0,1348,1350,5,16,0,0,1349,1351,5,99,
        0,0,1350,1349,1,0,0,0,1350,1351,1,0,0,0,1351,1353,1,0,0,0,1352,1354,
        3,150,75,0,1353,1352,1,0,0,0,1353,1354,1,0,0,0,1354,1356,1,0,0,0,
        1355,1357,5,99,0,0,1356,1355,1,0,0,0,1356,1357,1,0,0,0,1357,1358,
        1,0,0,0,1358,1359,5,17,0,0,1359,167,1,0,0,0,1360,1362,5,14,0,0,1361,
        1363,5,99,0,0,1362,1361,1,0,0,0,1362,1363,1,0,0,0,1363,1378,1,0,
        0,0,1364,1375,3,170,85,0,1365,1367,5,99,0,0,1366,1365,1,0,0,0,1366,
        1367,1,0,0,0,1367,1368,1,0,0,0,1368,1370,5,11,0,0,1369,1371,5,99,
        0,0,1370,1369,1,0,0,0,1370,1371,1,0,0,0,1371,1372,1,0,0,0,1372,1374,
        3,170,85,0,1373,1366,1,0,0,0,1374,1377,1,0,0,0,1375,1373,1,0,0,0,
        1375,1376,1,0,0,0,1376,1379,1,0,0,0,1377,1375,1,0,0,0,1378,1364,
        1,0,0,0,1378,1379,1,0,0,0,1379,1381,1,0,0,0,1380,1382,5,99,0,0,1381,
        1380,1,0,0,0,1381,1382,1,0,0,0,1382,1383,1,0,0,0,1383,1384,5,15,
        0,0,1384,169,1,0,0,0,1385,1387,3,172,86,0,1386,1388,5,99,0,0,1387,
        1386,1,0,0,0,1387,1388,1,0,0,0,1388,1389,1,0,0,0,1389,1391,5,25,
        0,0,1390,1392,5,99,0,0,1391,1390,1,0,0,0,1391,1392,1,0,0,0,1392,
        1393,1,0,0,0,1393,1394,3,72,36,0,1394,171,1,0,0,0,1395,1398,3,174,
        87,0,1396,1398,3,176,88,0,1397,1395,1,0,0,0,1397,1396,1,0,0,0,1398,
        173,1,0,0,0,1399,1400,7,8,0,0,1400,175,1,0,0,0,1401,1402,7,9,0,0,
        1402,177,1,0,0,0,290,179,183,186,189,195,201,206,210,214,217,220,
        224,228,230,234,240,244,247,251,257,262,265,268,272,275,278,281,
        284,287,291,294,298,303,308,312,315,319,322,326,330,334,338,343,
        348,352,358,362,365,368,370,374,378,383,387,392,398,402,408,412,
        416,423,430,434,438,444,448,452,457,462,467,471,475,479,483,486,
        490,493,496,502,506,511,515,518,522,526,528,534,538,543,548,552,
        558,562,566,571,576,580,586,590,596,600,604,609,613,619,622,626,
        632,636,641,646,650,655,660,664,669,674,678,683,688,692,699,703,
        709,716,720,725,730,734,739,744,748,753,757,760,766,771,775,779,
        783,788,791,794,798,801,804,807,810,814,820,825,829,832,836,839,
        842,848,851,855,859,864,869,873,875,881,886,891,895,900,904,910,
        914,917,920,923,926,929,932,948,955,959,962,965,969,972,976,979,
        982,986,989,991,995,998,1001,1004,1007,1010,1013,1016,1019,1025,
        1028,1031,1035,1038,1040,1044,1048,1052,1055,1058,1063,1068,1071,
        1074,1080,1084,1088,1091,1097,1101,1106,1111,1115,1119,1121,1125,
        1131,1135,1139,1141,1144,1147,1151,1155,1159,1165,1169,1173,1179,
        1183,1187,1189,1193,1196,1199,1203,1207,1213,1218,1222,1226,1230,
        1233,1236,1242,1246,1250,1253,1257,1261,1265,1271,1275,1280,1285,
        1288,1291,1295,1299,1303,1309,1312,1316,1319,1322,1329,1338,1350,
        1353,1356,1362,1366,1370,1375,1378,1381,1387,1391,1397
    ]

class CypherParser ( Parser ):

    grammarFileName = "CypherParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'='", "'+='", "'<='", "'>='", "'>'", 
                     "'<'", "'<>'", "'..'", "';'", "'.'", "','", "'('", 
                     "')'", "'{'", "'}'", "'['", "']'", "'-'", "'+'", "'/'", 
                     "'%'", "'^'", "'*'", "'`'", "':'", "'|'", "'$'", "'CALL'", 
                     "'YIELD'", "'FILTER'", "'EXTRACT'", "'COUNT'", "'ANY'", 
                     "'NONE'", "'SINGLE'", "'ALL'", "'ASC'", "'ASCENDING'", 
                     "'BY'", "'CREATE'", "'DELETE'", "'DESC'", "'DESCENDING'", 
                     "'DETACH'", "'EXISTS'", "'LIMIT'", "'MATCH'", "'MERGE'", 
                     "'ON'", "'OPTIONAL'", "'ORDER'", "'REMOVE'", "'RETURN'", 
                     "'SET'", "'SKIP'", "'WHERE'", "'WITH'", "'UNION'", 
                     "'UNWIND'", "'AND'", "'AS'", "'CONTAINS'", "'DISTINCT'", 
                     "'ENDS'", "'IN'", "'IS'", "'NOT'", "'OR'", "'STARTS'", 
                     "'XOR'", "'FALSE'", "'TRUE'", "'NULL'", "'CONSTRAINT'", 
                     "'DO'", "'FOR'", "'REQUIRE'", "'UNIQUE'", "'CASE'", 
                     "'WHEN'", "'THEN'", "'ELSE'", "'END'", "'MANDATORY'", 
                     "'SCALAR'", "'OF'", "'ADD'", "'DROP'" ]

    symbolicNames = [ "<INVALID>", "ASSIGN", "ADD_ASSIGN", "LE", "GE", "GT", 
                      "LT", "NOT_EQUAL", "RANGE", "SEMI", "DOT", "COMMA", 
                      "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", 
                      "RBRACK", "SUB", "PLUS", "DIV", "MOD", "CARET", "MULT", 
                      "ESC", "COLON", "STICK", "DOLLAR", "CALL", "YIELD", 
                      "FILTER", "EXTRACT", "COUNT", "ANY", "NONE", "SINGLE", 
                      "ALL", "ASC", "ASCENDING", "BY", "CREATE", "DELETE", 
                      "DESC", "DESCENDING", "DETACH", "EXISTS", "LIMIT", 
                      "MATCH", "MERGE", "ON", "OPTIONAL", "ORDER", "REMOVE", 
                      "RETURN", "SET", "SKIP_W", "WHERE", "WITH", "UNION", 
                      "UNWIND", "AND", "AS", "CONTAINS", "DISTINCT", "ENDS", 
                      "IN", "IS", "NOT", "OR", "STARTS", "XOR", "FALSE", 
                      "TRUE", "NULL_W", "CONSTRAINT", "DO", "FOR", "REQUIRE", 
                      "UNIQUE", "CASE", "WHEN", "THEN", "ELSE", "END", "MANDATORY", 
                      "SCALAR", "OF", "ADD", "DROP", "ESC_LITERAL", "CHAR_LITERAL", 
                      "STRING_LITERAL", "Integer", "DIGIT", "FLOAT", "ID", 
                      "IdentifierStart", "IdentifierPart", "Letter", "SP", 
                      "WHITESPACE", "Comment" ]

    RULE_script = 0
    RULE_query = 1
    RULE_regularQuery = 2
    RULE_singleQuery = 3
    RULE_standaloneCall = 4
    RULE_returnSt = 5
    RULE_withSt = 6
    RULE_skipSt = 7
    RULE_limitSt = 8
    RULE_projectionBody = 9
    RULE_projectionItems = 10
    RULE_projectionItem = 11
    RULE_orderItem = 12
    RULE_orderSt = 13
    RULE_singlePartQ = 14
    RULE_multiPartQ = 15
    RULE_matchSt = 16
    RULE_unwindSt = 17
    RULE_readingStatement = 18
    RULE_updatingStatement = 19
    RULE_deleteSt = 20
    RULE_removeSt = 21
    RULE_removeItem = 22
    RULE_queryCallSt = 23
    RULE_parenExpressionChain = 24
    RULE_yieldItems = 25
    RULE_yieldItem = 26
    RULE_mergeSt = 27
    RULE_mergeAction = 28
    RULE_setSt = 29
    RULE_setItem = 30
    RULE_nodeLabels = 31
    RULE_createSt = 32
    RULE_patternWhere = 33
    RULE_where = 34
    RULE_pattern = 35
    RULE_expression = 36
    RULE_xorExpression = 37
    RULE_andExpression = 38
    RULE_notExpression = 39
    RULE_comparisonExpression = 40
    RULE_comparisonSigns = 41
    RULE_addSubExpression = 42
    RULE_multDivExpression = 43
    RULE_powerExpression = 44
    RULE_unaryAddSubExpression = 45
    RULE_atomicExpression = 46
    RULE_listExpression = 47
    RULE_stringExpression = 48
    RULE_stringExpPrefix = 49
    RULE_nullExpression = 50
    RULE_propertyOrLabelExpression = 51
    RULE_propertyExpression = 52
    RULE_patternPart = 53
    RULE_patternElem = 54
    RULE_patternElemChain = 55
    RULE_properties = 56
    RULE_nodePattern = 57
    RULE_atom = 58
    RULE_lhs = 59
    RULE_relationshipPattern = 60
    RULE_relationDetail = 61
    RULE_rangeLit = 62
    RULE_relationshipTypes = 63
    RULE_unionSt = 64
    RULE_subqueryExist = 65
    RULE_invocationName = 66
    RULE_functionInvocation = 67
    RULE_parenthesizedExpression = 68
    RULE_filterWith = 69
    RULE_patternComprehension = 70
    RULE_relationshipsChainPattern = 71
    RULE_listComprehension = 72
    RULE_filterExpression = 73
    RULE_countAll = 74
    RULE_expressionChain = 75
    RULE_caseExpression = 76
    RULE_parameter = 77
    RULE_literal = 78
    RULE_boolLit = 79
    RULE_numLit = 80
    RULE_stringLit = 81
    RULE_charLit = 82
    RULE_listLit = 83
    RULE_mapLit = 84
    RULE_mapPair = 85
    RULE_name = 86
    RULE_symbol = 87
    RULE_reservedWord = 88

    ruleNames =  [ "script", "query", "regularQuery", "singleQuery", "standaloneCall", 
                   "returnSt", "withSt", "skipSt", "limitSt", "projectionBody", 
                   "projectionItems", "projectionItem", "orderItem", "orderSt", 
                   "singlePartQ", "multiPartQ", "matchSt", "unwindSt", "readingStatement", 
                   "updatingStatement", "deleteSt", "removeSt", "removeItem", 
                   "queryCallSt", "parenExpressionChain", "yieldItems", 
                   "yieldItem", "mergeSt", "mergeAction", "setSt", "setItem", 
                   "nodeLabels", "createSt", "patternWhere", "where", "pattern", 
                   "expression", "xorExpression", "andExpression", "notExpression", 
                   "comparisonExpression", "comparisonSigns", "addSubExpression", 
                   "multDivExpression", "powerExpression", "unaryAddSubExpression", 
                   "atomicExpression", "listExpression", "stringExpression", 
                   "stringExpPrefix", "nullExpression", "propertyOrLabelExpression", 
                   "propertyExpression", "patternPart", "patternElem", "patternElemChain", 
                   "properties", "nodePattern", "atom", "lhs", "relationshipPattern", 
                   "relationDetail", "rangeLit", "relationshipTypes", "unionSt", 
                   "subqueryExist", "invocationName", "functionInvocation", 
                   "parenthesizedExpression", "filterWith", "patternComprehension", 
                   "relationshipsChainPattern", "listComprehension", "filterExpression", 
                   "countAll", "expressionChain", "caseExpression", "parameter", 
                   "literal", "boolLit", "numLit", "stringLit", "charLit", 
                   "listLit", "mapLit", "mapPair", "name", "symbol", "reservedWord" ]

    EOF = Token.EOF
    ASSIGN=1
    ADD_ASSIGN=2
    LE=3
    GE=4
    GT=5
    LT=6
    NOT_EQUAL=7
    RANGE=8
    SEMI=9
    DOT=10
    COMMA=11
    LPAREN=12
    RPAREN=13
    LBRACE=14
    RBRACE=15
    LBRACK=16
    RBRACK=17
    SUB=18
    PLUS=19
    DIV=20
    MOD=21
    CARET=22
    MULT=23
    ESC=24
    COLON=25
    STICK=26
    DOLLAR=27
    CALL=28
    YIELD=29
    FILTER=30
    EXTRACT=31
    COUNT=32
    ANY=33
    NONE=34
    SINGLE=35
    ALL=36
    ASC=37
    ASCENDING=38
    BY=39
    CREATE=40
    DELETE=41
    DESC=42
    DESCENDING=43
    DETACH=44
    EXISTS=45
    LIMIT=46
    MATCH=47
    MERGE=48
    ON=49
    OPTIONAL=50
    ORDER=51
    REMOVE=52
    RETURN=53
    SET=54
    SKIP_W=55
    WHERE=56
    WITH=57
    UNION=58
    UNWIND=59
    AND=60
    AS=61
    CONTAINS=62
    DISTINCT=63
    ENDS=64
    IN=65
    IS=66
    NOT=67
    OR=68
    STARTS=69
    XOR=70
    FALSE=71
    TRUE=72
    NULL_W=73
    CONSTRAINT=74
    DO=75
    FOR=76
    REQUIRE=77
    UNIQUE=78
    CASE=79
    WHEN=80
    THEN=81
    ELSE=82
    END=83
    MANDATORY=84
    SCALAR=85
    OF=86
    ADD=87
    DROP=88
    ESC_LITERAL=89
    CHAR_LITERAL=90
    STRING_LITERAL=91
    Integer=92
    DIGIT=93
    FLOAT=94
    ID=95
    IdentifierStart=96
    IdentifierPart=97
    Letter=98
    SP=99
    WHITESPACE=100
    Comment=101

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




    class ScriptContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_script

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

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

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




    def script(self):

        localctx = CypherParser.ScriptContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_script)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 179
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 178
                self.match(CypherParser.SP)


            self.state = 181
            self.query()
            self.state = 183
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.state = 182
                self.match(CypherParser.SP)


            self.state = 186
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 185
                self.match(CypherParser.SEMI)


            self.state = 189
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 188
                self.match(CypherParser.SP)


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


    class QueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def regularQuery(self):
            return self.getTypedRuleContext(CypherParser.RegularQueryContext,0)


        def standaloneCall(self):
            return self.getTypedRuleContext(CypherParser.StandaloneCallContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_query

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

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

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




    def query(self):

        localctx = CypherParser.QueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_query)
        try:
            self.state = 195
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 193
                self.regularQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 194
                self.standaloneCall()
                pass


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


    class RegularQueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def singleQuery(self):
            return self.getTypedRuleContext(CypherParser.SingleQueryContext,0)


        def unionSt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.UnionStContext)
            else:
                return self.getTypedRuleContext(CypherParser.UnionStContext,i)


        def getRuleIndex(self):
            return CypherParser.RULE_regularQuery

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

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

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




    def regularQuery(self):

        localctx = CypherParser.RegularQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_regularQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 197
            self.singleQuery()
            self.state = 201
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==58:
                self.state = 198
                self.unionSt()
                self.state = 203
                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 SingleQueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def singlePartQ(self):
            return self.getTypedRuleContext(CypherParser.SinglePartQContext,0)


        def multiPartQ(self):
            return self.getTypedRuleContext(CypherParser.MultiPartQContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_singleQuery

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

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

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




    def singleQuery(self):

        localctx = CypherParser.SingleQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_singleQuery)
        try:
            self.state = 206
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 204
                self.singlePartQ()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 205
                self.multiPartQ()
                pass


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


    class StandaloneCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CALL(self):
            return self.getToken(CypherParser.CALL, 0)

        def invocationName(self):
            return self.getTypedRuleContext(CypherParser.InvocationNameContext,0)


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

        def parenExpressionChain(self):
            return self.getTypedRuleContext(CypherParser.ParenExpressionChainContext,0)


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

        def MULT(self):
            return self.getToken(CypherParser.MULT, 0)

        def yieldItems(self):
            return self.getTypedRuleContext(CypherParser.YieldItemsContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_standaloneCall

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

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

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




    def standaloneCall(self):

        localctx = CypherParser.StandaloneCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_standaloneCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 208
            self.match(CypherParser.CALL)
            self.state = 210
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 209
                self.match(CypherParser.SP)


            self.state = 212
            self.invocationName()
            self.state = 214
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 213
                self.match(CypherParser.SP)


            self.state = 217
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==12:
                self.state = 216
                self.parenExpressionChain()


            self.state = 230
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.state = 220
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 219
                    self.match(CypherParser.SP)


                self.state = 222
                self.match(CypherParser.YIELD)
                self.state = 224
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 223
                    self.match(CypherParser.SP)


                self.state = 228
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [23]:
                    self.state = 226
                    self.match(CypherParser.MULT)
                    pass
                elif token in [30, 31, 32, 33, 34, 35, 89, 92, 93, 95]:
                    self.state = 227
                    self.yieldItems()
                    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 ReturnStContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def projectionBody(self):
            return self.getTypedRuleContext(CypherParser.ProjectionBodyContext,0)


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_returnSt

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

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

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




    def returnSt(self):

        localctx = CypherParser.ReturnStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_returnSt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.match(CypherParser.RETURN)
            self.state = 234
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.state = 233
                self.match(CypherParser.SP)


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


    class WithStContext(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(CypherParser.WITH, 0)

        def projectionBody(self):
            return self.getTypedRuleContext(CypherParser.ProjectionBodyContext,0)


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

        def where(self):
            return self.getTypedRuleContext(CypherParser.WhereContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_withSt

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

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

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




    def withSt(self):

        localctx = CypherParser.WithStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_withSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            self.match(CypherParser.WITH)
            self.state = 240
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.state = 239
                self.match(CypherParser.SP)


            self.state = 242
            self.projectionBody()
            self.state = 247
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.state = 244
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 243
                    self.match(CypherParser.SP)


                self.state = 246
                self.where()


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


    class SkipStContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SKIP_W(self):
            return self.getToken(CypherParser.SKIP_W, 0)

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


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_skipSt

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

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

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




    def skipSt(self):

        localctx = CypherParser.SkipStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_skipSt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 249
            self.match(CypherParser.SKIP_W)
            self.state = 251
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
            if la_ == 1:
                self.state = 250
                self.match(CypherParser.SP)


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


    class LimitStContext(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(CypherParser.LIMIT, 0)

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


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_limitSt

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

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

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




    def limitSt(self):

        localctx = CypherParser.LimitStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_limitSt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 255
            self.match(CypherParser.LIMIT)
            self.state = 257
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.state = 256
                self.match(CypherParser.SP)


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


    class ProjectionBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def projectionItems(self):
            return self.getTypedRuleContext(CypherParser.ProjectionItemsContext,0)


        def DISTINCT(self):
            return self.getToken(CypherParser.DISTINCT, 0)

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

        def orderSt(self):
            return self.getTypedRuleContext(CypherParser.OrderStContext,0)


        def skipSt(self):
            return self.getTypedRuleContext(CypherParser.SkipStContext,0)


        def limitSt(self):
            return self.getTypedRuleContext(CypherParser.LimitStContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_projectionBody

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

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

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




    def projectionBody(self):

        localctx = CypherParser.ProjectionBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_projectionBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 265
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.state = 262
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 261
                    self.match(CypherParser.SP)


                self.state = 264
                self.match(CypherParser.DISTINCT)


            self.state = 268
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.state = 267
                self.match(CypherParser.SP)


            self.state = 270
            self.projectionItems()
            self.state = 275
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.state = 272
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 271
                    self.match(CypherParser.SP)


                self.state = 274
                self.orderSt()


            self.state = 281
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.state = 278
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 277
                    self.match(CypherParser.SP)


                self.state = 280
                self.skipSt()


            self.state = 287
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                self.state = 284
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 283
                    self.match(CypherParser.SP)


                self.state = 286
                self.limitSt()


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


    class ProjectionItemsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MULT(self):
            return self.getToken(CypherParser.MULT, 0)

        def projectionItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.ProjectionItemContext)
            else:
                return self.getTypedRuleContext(CypherParser.ProjectionItemContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_projectionItems

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

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

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




    def projectionItems(self):

        localctx = CypherParser.ProjectionItemsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_projectionItems)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 291
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [23]:
                self.state = 289
                self.match(CypherParser.MULT)
                pass
            elif token in [12, 14, 16, 18, 19, 27, 30, 31, 32, 33, 34, 35, 36, 45, 67, 71, 72, 73, 79, 89, 90, 91, 92, 93, 95, 99]:
                self.state = 290
                self.projectionItem()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 303
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,32,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 294
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 293
                        self.match(CypherParser.SP)


                    self.state = 296
                    self.match(CypherParser.COMMA)
                    self.state = 298
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                    if la_ == 1:
                        self.state = 297
                        self.match(CypherParser.SP)


                    self.state = 300
                    self.projectionItem() 
                self.state = 305
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,32,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 ProjectionItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_projectionItem

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

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

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




    def projectionItem(self):

        localctx = CypherParser.ProjectionItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_projectionItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 306
            self.expression()
            self.state = 315
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.state = 308
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 307
                    self.match(CypherParser.SP)


                self.state = 310
                self.match(CypherParser.AS)
                self.state = 312
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 311
                    self.match(CypherParser.SP)


                self.state = 314
                self.symbol()


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


    class OrderItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def ASCENDING(self):
            return self.getToken(CypherParser.ASCENDING, 0)

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

        def DESCENDING(self):
            return self.getToken(CypherParser.DESCENDING, 0)

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

        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_orderItem

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

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

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




    def orderItem(self):

        localctx = CypherParser.OrderItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_orderItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 317
            self.expression()
            self.state = 322
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
            if la_ == 1:
                self.state = 319
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 318
                    self.match(CypherParser.SP)


                self.state = 321
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 13606456393728) != 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 OrderStContext(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(CypherParser.ORDER, 0)

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

        def orderItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OrderItemContext)
            else:
                return self.getTypedRuleContext(CypherParser.OrderItemContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_orderSt

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

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

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




    def orderSt(self):

        localctx = CypherParser.OrderStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_orderSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 324
            self.match(CypherParser.ORDER)
            self.state = 326
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 325
                self.match(CypherParser.SP)


            self.state = 328
            self.match(CypherParser.BY)
            self.state = 330
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.state = 329
                self.match(CypherParser.SP)


            self.state = 332
            self.orderItem()
            self.state = 343
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,42,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 334
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 333
                        self.match(CypherParser.SP)


                    self.state = 336
                    self.match(CypherParser.COMMA)
                    self.state = 338
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
                    if la_ == 1:
                        self.state = 337
                        self.match(CypherParser.SP)


                    self.state = 340
                    self.orderItem() 
                self.state = 345
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,42,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 SinglePartQContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def returnSt(self):
            return self.getTypedRuleContext(CypherParser.ReturnStContext,0)


        def readingStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.ReadingStatementContext)
            else:
                return self.getTypedRuleContext(CypherParser.ReadingStatementContext,i)


        def updatingStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.UpdatingStatementContext)
            else:
                return self.getTypedRuleContext(CypherParser.UpdatingStatementContext,i)


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

        def getRuleIndex(self):
            return CypherParser.RULE_singlePartQ

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

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

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




    def singlePartQ(self):

        localctx = CypherParser.SinglePartQContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_singlePartQ)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 352
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 577727389967056896) != 0):
                self.state = 346
                self.readingStatement()
                self.state = 348
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 347
                    self.match(CypherParser.SP)


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

            self.state = 370
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [53]:
                self.state = 355
                self.returnSt()
                pass
            elif token in [40, 41, 44, 48, 52, 54]:
                self.state = 360 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 356
                    self.updatingStatement()
                    self.state = 358
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
                    if la_ == 1:
                        self.state = 357
                        self.match(CypherParser.SP)


                    self.state = 362 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 22820363834490880) != 0)):
                        break

                self.state = 368
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
                if la_ == 1:
                    self.state = 365
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 364
                        self.match(CypherParser.SP)


                    self.state = 367
                    self.returnSt()


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

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

        def withSt(self):
            return self.getTypedRuleContext(CypherParser.WithStContext,0)


        def singlePartQ(self):
            return self.getTypedRuleContext(CypherParser.SinglePartQContext,0)


        def readingStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.ReadingStatementContext)
            else:
                return self.getTypedRuleContext(CypherParser.ReadingStatementContext,i)


        def updatingStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.UpdatingStatementContext)
            else:
                return self.getTypedRuleContext(CypherParser.UpdatingStatementContext,i)


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

        def getRuleIndex(self):
            return CypherParser.RULE_multiPartQ

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

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

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




    def multiPartQ(self):

        localctx = CypherParser.MultiPartQContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_multiPartQ)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 577727389967056896) != 0):
                self.state = 372
                self.readingStatement()
                self.state = 374
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 373
                    self.match(CypherParser.SP)


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

            self.state = 387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 22820363834490880) != 0):
                self.state = 381
                self.updatingStatement()
                self.state = 383
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 382
                    self.match(CypherParser.SP)


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

            self.state = 390
            self.withSt()
            self.state = 392
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 391
                self.match(CypherParser.SP)


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


    class MatchStContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MATCH(self):
            return self.getToken(CypherParser.MATCH, 0)

        def patternWhere(self):
            return self.getTypedRuleContext(CypherParser.PatternWhereContext,0)


        def OPTIONAL(self):
            return self.getToken(CypherParser.OPTIONAL, 0)

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

        def getRuleIndex(self):
            return CypherParser.RULE_matchSt

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

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

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




    def matchSt(self):

        localctx = CypherParser.MatchStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_matchSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 398
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==50:
                self.state = 396
                self.match(CypherParser.OPTIONAL)
                self.state = 397
                self.match(CypherParser.SP)


            self.state = 400
            self.match(CypherParser.MATCH)
            self.state = 402
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 401
                self.match(CypherParser.SP)


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


    class UnwindStContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNWIND(self):
            return self.getToken(CypherParser.UNWIND, 0)

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


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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_unwindSt

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

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

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




    def unwindSt(self):

        localctx = CypherParser.UnwindStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_unwindSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 406
            self.match(CypherParser.UNWIND)
            self.state = 408
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.state = 407
                self.match(CypherParser.SP)


            self.state = 410
            self.expression()
            self.state = 412
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 411
                self.match(CypherParser.SP)


            self.state = 414
            self.match(CypherParser.AS)
            self.state = 416
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 415
                self.match(CypherParser.SP)


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


    class ReadingStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def matchSt(self):
            return self.getTypedRuleContext(CypherParser.MatchStContext,0)


        def unwindSt(self):
            return self.getTypedRuleContext(CypherParser.UnwindStContext,0)


        def queryCallSt(self):
            return self.getTypedRuleContext(CypherParser.QueryCallStContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_readingStatement

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

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

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




    def readingStatement(self):

        localctx = CypherParser.ReadingStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_readingStatement)
        try:
            self.state = 423
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [47, 50]:
                self.enterOuterAlt(localctx, 1)
                self.state = 420
                self.matchSt()
                pass
            elif token in [59]:
                self.enterOuterAlt(localctx, 2)
                self.state = 421
                self.unwindSt()
                pass
            elif token in [28]:
                self.enterOuterAlt(localctx, 3)
                self.state = 422
                self.queryCallSt()
                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 UpdatingStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def createSt(self):
            return self.getTypedRuleContext(CypherParser.CreateStContext,0)


        def mergeSt(self):
            return self.getTypedRuleContext(CypherParser.MergeStContext,0)


        def deleteSt(self):
            return self.getTypedRuleContext(CypherParser.DeleteStContext,0)


        def setSt(self):
            return self.getTypedRuleContext(CypherParser.SetStContext,0)


        def removeSt(self):
            return self.getTypedRuleContext(CypherParser.RemoveStContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_updatingStatement

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

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

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




    def updatingStatement(self):

        localctx = CypherParser.UpdatingStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_updatingStatement)
        try:
            self.state = 430
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [40]:
                self.enterOuterAlt(localctx, 1)
                self.state = 425
                self.createSt()
                pass
            elif token in [48]:
                self.enterOuterAlt(localctx, 2)
                self.state = 426
                self.mergeSt()
                pass
            elif token in [41, 44]:
                self.enterOuterAlt(localctx, 3)
                self.state = 427
                self.deleteSt()
                pass
            elif token in [54]:
                self.enterOuterAlt(localctx, 4)
                self.state = 428
                self.setSt()
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 5)
                self.state = 429
                self.removeSt()
                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 DeleteStContext(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(CypherParser.DELETE, 0)

        def expressionChain(self):
            return self.getTypedRuleContext(CypherParser.ExpressionChainContext,0)


        def DETACH(self):
            return self.getToken(CypherParser.DETACH, 0)

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

        def getRuleIndex(self):
            return CypherParser.RULE_deleteSt

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

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

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




    def deleteSt(self):

        localctx = CypherParser.DeleteStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_deleteSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 434
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==44:
                self.state = 432
                self.match(CypherParser.DETACH)
                self.state = 433
                self.match(CypherParser.SP)


            self.state = 436
            self.match(CypherParser.DELETE)
            self.state = 438
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
            if la_ == 1:
                self.state = 437
                self.match(CypherParser.SP)


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


    class RemoveStContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REMOVE(self):
            return self.getToken(CypherParser.REMOVE, 0)

        def removeItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.RemoveItemContext)
            else:
                return self.getTypedRuleContext(CypherParser.RemoveItemContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_removeSt

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

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

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




    def removeSt(self):

        localctx = CypherParser.RemoveStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_removeSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 442
            self.match(CypherParser.REMOVE)
            self.state = 444
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 443
                self.match(CypherParser.SP)


            self.state = 446
            self.removeItem()
            self.state = 457
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,67,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 448
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 447
                        self.match(CypherParser.SP)


                    self.state = 450
                    self.match(CypherParser.COMMA)
                    self.state = 452
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 451
                        self.match(CypherParser.SP)


                    self.state = 454
                    self.removeItem() 
                self.state = 459
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,67,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 RemoveItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


        def nodeLabels(self):
            return self.getTypedRuleContext(CypherParser.NodeLabelsContext,0)


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def propertyExpression(self):
            return self.getTypedRuleContext(CypherParser.PropertyExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_removeItem

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

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

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




    def removeItem(self):

        localctx = CypherParser.RemoveItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_removeItem)
        self._la = 0 # Token type
        try:
            self.state = 467
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 460
                self.symbol()
                self.state = 462
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 461
                    self.match(CypherParser.SP)


                self.state = 464
                self.nodeLabels()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 466
                self.propertyExpression()
                pass


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


    class QueryCallStContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CALL(self):
            return self.getToken(CypherParser.CALL, 0)

        def invocationName(self):
            return self.getTypedRuleContext(CypherParser.InvocationNameContext,0)


        def parenExpressionChain(self):
            return self.getTypedRuleContext(CypherParser.ParenExpressionChainContext,0)


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

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

        def yieldItems(self):
            return self.getTypedRuleContext(CypherParser.YieldItemsContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_queryCallSt

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

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

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




    def queryCallSt(self):

        localctx = CypherParser.QueryCallStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_queryCallSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 469
            self.match(CypherParser.CALL)
            self.state = 471
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 470
                self.match(CypherParser.SP)


            self.state = 473
            self.invocationName()
            self.state = 475
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 474
                self.match(CypherParser.SP)


            self.state = 477
            self.parenExpressionChain()
            self.state = 486
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.state = 479
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 478
                    self.match(CypherParser.SP)


                self.state = 481
                self.match(CypherParser.YIELD)
                self.state = 483
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 482
                    self.match(CypherParser.SP)


                self.state = 485
                self.yieldItems()


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


    class ParenExpressionChainContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(CypherParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(CypherParser.RPAREN, 0)

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

        def expressionChain(self):
            return self.getTypedRuleContext(CypherParser.ExpressionChainContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_parenExpressionChain

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

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

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




    def parenExpressionChain(self):

        localctx = CypherParser.ParenExpressionChainContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_parenExpressionChain)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 488
            self.match(CypherParser.LPAREN)
            self.state = 490
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 489
                self.match(CypherParser.SP)


            self.state = 493
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 492
                self.expressionChain()


            self.state = 496
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 495
                self.match(CypherParser.SP)


            self.state = 498
            self.match(CypherParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class YieldItemsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def yieldItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.YieldItemContext)
            else:
                return self.getTypedRuleContext(CypherParser.YieldItemContext,i)


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

        def where(self):
            return self.getTypedRuleContext(CypherParser.WhereContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_yieldItems

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

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

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




    def yieldItems(self):

        localctx = CypherParser.YieldItemsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_yieldItems)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 500
            self.yieldItem()
            self.state = 511
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,80,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 502
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 501
                        self.match(CypherParser.SP)


                    self.state = 504
                    self.match(CypherParser.COMMA)
                    self.state = 506
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 505
                        self.match(CypherParser.SP)


                    self.state = 508
                    self.yieldItem() 
                self.state = 513
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,80,self._ctx)

            self.state = 518
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.state = 515
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 514
                    self.match(CypherParser.SP)


                self.state = 517
                self.where()


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


    class YieldItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def symbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.SymbolContext)
            else:
                return self.getTypedRuleContext(CypherParser.SymbolContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_yieldItem

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

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

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




    def yieldItem(self):

        localctx = CypherParser.YieldItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_yieldItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 528
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.state = 520
                self.symbol()
                self.state = 522
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 521
                    self.match(CypherParser.SP)


                self.state = 524
                self.match(CypherParser.AS)
                self.state = 526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 525
                    self.match(CypherParser.SP)




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


    class MergeStContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MERGE(self):
            return self.getToken(CypherParser.MERGE, 0)

        def patternPart(self):
            return self.getTypedRuleContext(CypherParser.PatternPartContext,0)


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

        def mergeAction(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.MergeActionContext)
            else:
                return self.getTypedRuleContext(CypherParser.MergeActionContext,i)


        def getRuleIndex(self):
            return CypherParser.RULE_mergeSt

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

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

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




    def mergeSt(self):

        localctx = CypherParser.MergeStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_mergeSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 532
            self.match(CypherParser.MERGE)
            self.state = 534
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 533
                self.match(CypherParser.SP)


            self.state = 536
            self.patternPart()
            self.state = 543
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,88,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 538
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 537
                        self.match(CypherParser.SP)


                    self.state = 540
                    self.mergeAction() 
                self.state = 545
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,88,self._ctx)

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


    class MergeActionContext(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(CypherParser.ON, 0)

        def setSt(self):
            return self.getTypedRuleContext(CypherParser.SetStContext,0)


        def MATCH(self):
            return self.getToken(CypherParser.MATCH, 0)

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_mergeAction

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

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

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




    def mergeAction(self):

        localctx = CypherParser.MergeActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_mergeAction)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            self.match(CypherParser.ON)
            self.state = 548
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 547
                self.match(CypherParser.SP)


            self.state = 550
            _la = self._input.LA(1)
            if not(_la==40 or _la==47):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 552
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 551
                self.match(CypherParser.SP)


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


    class SetStContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def setItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.SetItemContext)
            else:
                return self.getTypedRuleContext(CypherParser.SetItemContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_setSt

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

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

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




    def setSt(self):

        localctx = CypherParser.SetStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_setSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 556
            self.match(CypherParser.SET)
            self.state = 558
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 557
                self.match(CypherParser.SP)


            self.state = 560
            self.setItem()
            self.state = 571
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,94,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 562
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 561
                        self.match(CypherParser.SP)


                    self.state = 564
                    self.match(CypherParser.COMMA)
                    self.state = 566
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 565
                        self.match(CypherParser.SP)


                    self.state = 568
                    self.setItem() 
                self.state = 573
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,94,self._ctx)

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


    class SetItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def propertyExpression(self):
            return self.getTypedRuleContext(CypherParser.PropertyExpressionContext,0)


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

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


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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


        def ADD_ASSIGN(self):
            return self.getToken(CypherParser.ADD_ASSIGN, 0)

        def nodeLabels(self):
            return self.getTypedRuleContext(CypherParser.NodeLabelsContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_setItem

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

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

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




    def setItem(self):

        localctx = CypherParser.SetItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_setItem)
        self._la = 0 # Token type
        try:
            self.state = 600
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 574
                self.propertyExpression()
                self.state = 576
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 575
                    self.match(CypherParser.SP)


                self.state = 578
                self.match(CypherParser.ASSIGN)
                self.state = 580
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
                if la_ == 1:
                    self.state = 579
                    self.match(CypherParser.SP)


                self.state = 582
                self.expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 584
                self.symbol()
                self.state = 586
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 585
                    self.match(CypherParser.SP)


                self.state = 588
                _la = self._input.LA(1)
                if not(_la==1 or _la==2):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 590
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
                if la_ == 1:
                    self.state = 589
                    self.match(CypherParser.SP)


                self.state = 592
                self.expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 594
                self.symbol()
                self.state = 596
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 595
                    self.match(CypherParser.SP)


                self.state = 598
                self.nodeLabels()
                pass


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


    class NodeLabelsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def getRuleIndex(self):
            return CypherParser.RULE_nodeLabels

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

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

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




    def nodeLabels(self):

        localctx = CypherParser.NodeLabelsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_nodeLabels)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 607 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 602
                self.match(CypherParser.COLON)
                self.state = 604
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 603
                    self.match(CypherParser.SP)


                self.state = 606
                self.name()
                self.state = 609 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==25):
                    break

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


    class CreateStContext(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(CypherParser.CREATE, 0)

        def pattern(self):
            return self.getTypedRuleContext(CypherParser.PatternContext,0)


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_createSt

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

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

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




    def createSt(self):

        localctx = CypherParser.CreateStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_createSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 611
            self.match(CypherParser.CREATE)
            self.state = 613
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 612
                self.match(CypherParser.SP)


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


    class PatternWhereContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pattern(self):
            return self.getTypedRuleContext(CypherParser.PatternContext,0)


        def where(self):
            return self.getTypedRuleContext(CypherParser.WhereContext,0)


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_patternWhere

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

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

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




    def patternWhere(self):

        localctx = CypherParser.PatternWhereContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_patternWhere)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 617
            self.pattern()
            self.state = 622
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.state = 619
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 618
                    self.match(CypherParser.SP)


                self.state = 621
                self.where()


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


    class WhereContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_where

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

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

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




    def where(self):

        localctx = CypherParser.WhereContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_where)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 624
            self.match(CypherParser.WHERE)
            self.state = 626
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.state = 625
                self.match(CypherParser.SP)


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


    class PatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def patternPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.PatternPartContext)
            else:
                return self.getTypedRuleContext(CypherParser.PatternPartContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_pattern

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

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

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




    def pattern(self):

        localctx = CypherParser.PatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 630
            self.patternPart()
            self.state = 641
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,109,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 632
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 631
                        self.match(CypherParser.SP)


                    self.state = 634
                    self.match(CypherParser.COMMA)
                    self.state = 636
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 635
                        self.match(CypherParser.SP)


                    self.state = 638
                    self.patternPart() 
                self.state = 643
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,109,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 ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def xorExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.XorExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.XorExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_expression

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

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

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




    def expression(self):

        localctx = CypherParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 644
            self.xorExpression()
            self.state = 655
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,112,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 646
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 645
                        self.match(CypherParser.SP)


                    self.state = 648
                    self.match(CypherParser.OR)
                    self.state = 650
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
                    if la_ == 1:
                        self.state = 649
                        self.match(CypherParser.SP)


                    self.state = 652
                    self.xorExpression() 
                self.state = 657
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,112,self._ctx)

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


    class XorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def andExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.AndExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.AndExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_xorExpression

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

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

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




    def xorExpression(self):

        localctx = CypherParser.XorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_xorExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 658
            self.andExpression()
            self.state = 669
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,115,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 660
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 659
                        self.match(CypherParser.SP)


                    self.state = 662
                    self.match(CypherParser.XOR)
                    self.state = 664
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
                    if la_ == 1:
                        self.state = 663
                        self.match(CypherParser.SP)


                    self.state = 666
                    self.andExpression() 
                self.state = 671
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,115,self._ctx)

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


    class AndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def notExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.NotExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.NotExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_andExpression

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

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

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




    def andExpression(self):

        localctx = CypherParser.AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_andExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 672
            self.notExpression()
            self.state = 683
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,118,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 674
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 673
                        self.match(CypherParser.SP)


                    self.state = 676
                    self.match(CypherParser.AND)
                    self.state = 678
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                    if la_ == 1:
                        self.state = 677
                        self.match(CypherParser.SP)


                    self.state = 680
                    self.notExpression() 
                self.state = 685
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,118,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 NotExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def comparisonExpression(self):
            return self.getTypedRuleContext(CypherParser.ComparisonExpressionContext,0)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_notExpression

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

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

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




    def notExpression(self):

        localctx = CypherParser.NotExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_notExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 692
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==67:
                self.state = 686
                self.match(CypherParser.NOT)
                self.state = 688
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
                if la_ == 1:
                    self.state = 687
                    self.match(CypherParser.SP)


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

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


    class ComparisonExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def addSubExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.AddSubExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.AddSubExpressionContext,i)


        def comparisonSigns(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.ComparisonSignsContext)
            else:
                return self.getTypedRuleContext(CypherParser.ComparisonSignsContext,i)


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

        def getRuleIndex(self):
            return CypherParser.RULE_comparisonExpression

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

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

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




    def comparisonExpression(self):

        localctx = CypherParser.ComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_comparisonExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 697
            self.addSubExpression()
            self.state = 709
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,123,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 699
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 698
                        self.match(CypherParser.SP)


                    self.state = 701
                    self.comparisonSigns()
                    self.state = 703
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
                    if la_ == 1:
                        self.state = 702
                        self.match(CypherParser.SP)


                    self.state = 705
                    self.addSubExpression() 
                self.state = 711
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,123,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 ComparisonSignsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LE(self):
            return self.getToken(CypherParser.LE, 0)

        def GE(self):
            return self.getToken(CypherParser.GE, 0)

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

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

        def NOT_EQUAL(self):
            return self.getToken(CypherParser.NOT_EQUAL, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_comparisonSigns

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

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

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




    def comparisonSigns(self):

        localctx = CypherParser.ComparisonSignsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_comparisonSigns)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 712
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 250) != 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 AddSubExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def multDivExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.MultDivExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.MultDivExpressionContext,i)


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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_addSubExpression

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

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

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




    def addSubExpression(self):

        localctx = CypherParser.AddSubExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_addSubExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 714
            self.multDivExpression()
            self.state = 725
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,126,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 716
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 715
                        self.match(CypherParser.SP)


                    self.state = 718
                    _la = self._input.LA(1)
                    if not(_la==18 or _la==19):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 720
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
                    if la_ == 1:
                        self.state = 719
                        self.match(CypherParser.SP)


                    self.state = 722
                    self.multDivExpression() 
                self.state = 727
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,126,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 MultDivExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def powerExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.PowerExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.PowerExpressionContext,i)


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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_multDivExpression

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

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

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




    def multDivExpression(self):

        localctx = CypherParser.MultDivExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_multDivExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self.powerExpression()
            self.state = 739
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,129,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 730
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 729
                        self.match(CypherParser.SP)


                    self.state = 732
                    _la = self._input.LA(1)
                    if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 11534336) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 734
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
                    if la_ == 1:
                        self.state = 733
                        self.match(CypherParser.SP)


                    self.state = 736
                    self.powerExpression() 
                self.state = 741
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,129,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 PowerExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unaryAddSubExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.UnaryAddSubExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.UnaryAddSubExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_powerExpression

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

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

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




    def powerExpression(self):

        localctx = CypherParser.PowerExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_powerExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 742
            self.unaryAddSubExpression()
            self.state = 753
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,132,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 744
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 743
                        self.match(CypherParser.SP)


                    self.state = 746
                    self.match(CypherParser.CARET)
                    self.state = 748
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
                    if la_ == 1:
                        self.state = 747
                        self.match(CypherParser.SP)


                    self.state = 750
                    self.unaryAddSubExpression() 
                self.state = 755
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,132,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 UnaryAddSubExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atomicExpression(self):
            return self.getTypedRuleContext(CypherParser.AtomicExpressionContext,0)


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_unaryAddSubExpression

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

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

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




    def unaryAddSubExpression(self):

        localctx = CypherParser.UnaryAddSubExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_unaryAddSubExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==18 or _la==19:
                self.state = 756
                _la = self._input.LA(1)
                if not(_la==18 or _la==19):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 760
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 759
                self.match(CypherParser.SP)


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


    class AtomicExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def propertyOrLabelExpression(self):
            return self.getTypedRuleContext(CypherParser.PropertyOrLabelExpressionContext,0)


        def stringExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.StringExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.StringExpressionContext,i)


        def listExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.ListExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.ListExpressionContext,i)


        def nullExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.NullExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.NullExpressionContext,i)


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

        def getRuleIndex(self):
            return CypherParser.RULE_atomicExpression

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

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

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




    def atomicExpression(self):

        localctx = CypherParser.AtomicExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_atomicExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 764
            self.propertyOrLabelExpression()
            self.state = 775
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,137,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 766
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
                    if la_ == 1:
                        self.state = 765
                        self.match(CypherParser.SP)


                    self.state = 771
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                    if la_ == 1:
                        self.state = 768
                        self.stringExpression()
                        pass

                    elif la_ == 2:
                        self.state = 769
                        self.listExpression()
                        pass

                    elif la_ == 3:
                        self.state = 770
                        self.nullExpression()
                        pass

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

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

        def IN(self):
            return self.getToken(CypherParser.IN, 0)

        def propertyOrLabelExpression(self):
            return self.getTypedRuleContext(CypherParser.PropertyOrLabelExpressionContext,0)


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

        def LBRACK(self):
            return self.getToken(CypherParser.LBRACK, 0)

        def RBRACK(self):
            return self.getToken(CypherParser.RBRACK, 0)

        def RANGE(self):
            return self.getToken(CypherParser.RANGE, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.ExpressionContext,i)


        def getRuleIndex(self):
            return CypherParser.RULE_listExpression

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

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

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




    def listExpression(self):

        localctx = CypherParser.ListExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_listExpression)
        self._la = 0 # Token type
        try:
            self.state = 810
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [65, 99]:
                self.enterOuterAlt(localctx, 1)
                self.state = 779
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 778
                    self.match(CypherParser.SP)


                self.state = 781
                self.match(CypherParser.IN)
                self.state = 783
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 782
                    self.match(CypherParser.SP)


                self.state = 785
                self.propertyOrLabelExpression()
                pass
            elif token in [16]:
                self.enterOuterAlt(localctx, 2)
                self.state = 786
                self.match(CypherParser.LBRACK)
                self.state = 788
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
                if la_ == 1:
                    self.state = 787
                    self.match(CypherParser.SP)


                self.state = 804
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
                if la_ == 1:
                    self.state = 791
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                    if la_ == 1:
                        self.state = 790
                        self.expression()


                    self.state = 794
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 793
                        self.match(CypherParser.SP)


                    self.state = 796
                    self.match(CypherParser.RANGE)
                    self.state = 798
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,143,self._ctx)
                    if la_ == 1:
                        self.state = 797
                        self.match(CypherParser.SP)


                    self.state = 801
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
                    if la_ == 1:
                        self.state = 800
                        self.expression()


                    pass

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


                self.state = 807
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 806
                    self.match(CypherParser.SP)


                self.state = 809
                self.match(CypherParser.RBRACK)
                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 StringExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def stringExpPrefix(self):
            return self.getTypedRuleContext(CypherParser.StringExpPrefixContext,0)


        def propertyOrLabelExpression(self):
            return self.getTypedRuleContext(CypherParser.PropertyOrLabelExpressionContext,0)


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_stringExpression

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

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

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




    def stringExpression(self):

        localctx = CypherParser.StringExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_stringExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 812
            self.stringExpPrefix()
            self.state = 814
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 813
                self.match(CypherParser.SP)


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


    class StringExpPrefixContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def STARTS(self):
            return self.getToken(CypherParser.STARTS, 0)

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

        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def ENDS(self):
            return self.getToken(CypherParser.ENDS, 0)

        def CONTAINS(self):
            return self.getToken(CypherParser.CONTAINS, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_stringExpPrefix

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

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

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




    def stringExpPrefix(self):

        localctx = CypherParser.StringExpPrefixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_stringExpPrefix)
        self._la = 0 # Token type
        try:
            self.state = 829
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [69]:
                self.enterOuterAlt(localctx, 1)
                self.state = 818
                self.match(CypherParser.STARTS)
                self.state = 820
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 819
                    self.match(CypherParser.SP)


                self.state = 822
                self.match(CypherParser.WITH)
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 2)
                self.state = 823
                self.match(CypherParser.ENDS)
                self.state = 825
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 824
                    self.match(CypherParser.SP)


                self.state = 827
                self.match(CypherParser.WITH)
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 3)
                self.state = 828
                self.match(CypherParser.CONTAINS)
                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 NullExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IS(self):
            return self.getToken(CypherParser.IS, 0)

        def NULL_W(self):
            return self.getToken(CypherParser.NULL_W, 0)

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_nullExpression

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

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

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




    def nullExpression(self):

        localctx = CypherParser.NullExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_nullExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 832
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 831
                self.match(CypherParser.SP)


            self.state = 834
            self.match(CypherParser.IS)
            self.state = 836
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
            if la_ == 1:
                self.state = 835
                self.match(CypherParser.SP)


            self.state = 839
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==67:
                self.state = 838
                self.match(CypherParser.NOT)


            self.state = 842
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 841
                self.match(CypherParser.SP)


            self.state = 844
            self.match(CypherParser.NULL_W)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertyOrLabelExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def propertyExpression(self):
            return self.getTypedRuleContext(CypherParser.PropertyExpressionContext,0)


        def nodeLabels(self):
            return self.getTypedRuleContext(CypherParser.NodeLabelsContext,0)


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_propertyOrLabelExpression

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

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

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




    def propertyOrLabelExpression(self):

        localctx = CypherParser.PropertyOrLabelExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_propertyOrLabelExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 846
            self.propertyExpression()
            self.state = 851
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,157,self._ctx)
            if la_ == 1:
                self.state = 848
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 847
                    self.match(CypherParser.SP)


                self.state = 850
                self.nodeLabels()


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


    class PropertyExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atom(self):
            return self.getTypedRuleContext(CypherParser.AtomContext,0)


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

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


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

        def getRuleIndex(self):
            return CypherParser.RULE_propertyExpression

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

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

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




    def propertyExpression(self):

        localctx = CypherParser.PropertyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_propertyExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 853
            self.atom()
            self.state = 864
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,160,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 855
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 854
                        self.match(CypherParser.SP)


                    self.state = 857
                    self.match(CypherParser.DOT)
                    self.state = 859
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 858
                        self.match(CypherParser.SP)


                    self.state = 861
                    self.name() 
                self.state = 866
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,160,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 PatternPartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def patternElem(self):
            return self.getTypedRuleContext(CypherParser.PatternElemContext,0)


        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_patternPart

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

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

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




    def patternPart(self):

        localctx = CypherParser.PatternPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_patternPart)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 875
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,163,self._ctx)
            if la_ == 1:
                self.state = 867
                self.symbol()
                self.state = 869
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 868
                    self.match(CypherParser.SP)


                self.state = 871
                self.match(CypherParser.ASSIGN)
                self.state = 873
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 872
                    self.match(CypherParser.SP)




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


    class PatternElemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nodePattern(self):
            return self.getTypedRuleContext(CypherParser.NodePatternContext,0)


        def patternElemChain(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.PatternElemChainContext)
            else:
                return self.getTypedRuleContext(CypherParser.PatternElemChainContext,i)


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

        def LPAREN(self):
            return self.getToken(CypherParser.LPAREN, 0)

        def patternElem(self):
            return self.getTypedRuleContext(CypherParser.PatternElemContext,0)


        def RPAREN(self):
            return self.getToken(CypherParser.RPAREN, 0)

        def functionInvocation(self):
            return self.getTypedRuleContext(CypherParser.FunctionInvocationContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_patternElem

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

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

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




    def patternElem(self):

        localctx = CypherParser.PatternElemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_patternElem)
        self._la = 0 # Token type
        try:
            self.state = 900
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 879
                self.nodePattern()
                self.state = 886
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,165,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 881
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==99:
                            self.state = 880
                            self.match(CypherParser.SP)


                        self.state = 883
                        self.patternElemChain() 
                    self.state = 888
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,165,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 889
                self.match(CypherParser.LPAREN)
                self.state = 891
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 890
                    self.match(CypherParser.SP)


                self.state = 893
                self.patternElem()
                self.state = 895
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 894
                    self.match(CypherParser.SP)


                self.state = 897
                self.match(CypherParser.RPAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 899
                self.functionInvocation()
                pass


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


    class PatternElemChainContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def relationshipPattern(self):
            return self.getTypedRuleContext(CypherParser.RelationshipPatternContext,0)


        def nodePattern(self):
            return self.getTypedRuleContext(CypherParser.NodePatternContext,0)


        def SP(self):
            return self.getToken(CypherParser.SP, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_patternElemChain

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

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

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




    def patternElemChain(self):

        localctx = CypherParser.PatternElemChainContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_patternElemChain)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 902
            self.relationshipPattern()
            self.state = 904
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 903
                self.match(CypherParser.SP)


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


    class PropertiesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def mapLit(self):
            return self.getTypedRuleContext(CypherParser.MapLitContext,0)


        def parameter(self):
            return self.getTypedRuleContext(CypherParser.ParameterContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_properties

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

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

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




    def properties(self):

        localctx = CypherParser.PropertiesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_properties)
        try:
            self.state = 910
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [14]:
                self.enterOuterAlt(localctx, 1)
                self.state = 908
                self.mapLit()
                pass
            elif token in [27]:
                self.enterOuterAlt(localctx, 2)
                self.state = 909
                self.parameter()
                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 NodePatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(CypherParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(CypherParser.RPAREN, 0)

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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


        def nodeLabels(self):
            return self.getTypedRuleContext(CypherParser.NodeLabelsContext,0)


        def properties(self):
            return self.getTypedRuleContext(CypherParser.PropertiesContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_nodePattern

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

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

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




    def nodePattern(self):

        localctx = CypherParser.NodePatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_nodePattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 912
            self.match(CypherParser.LPAREN)
            self.state = 914
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
            if la_ == 1:
                self.state = 913
                self.match(CypherParser.SP)


            self.state = 917
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 67645734912) != 0) or ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & 89) != 0):
                self.state = 916
                self.symbol()


            self.state = 920
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
            if la_ == 1:
                self.state = 919
                self.match(CypherParser.SP)


            self.state = 923
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==25:
                self.state = 922
                self.nodeLabels()


            self.state = 926
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
            if la_ == 1:
                self.state = 925
                self.match(CypherParser.SP)


            self.state = 929
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==14 or _la==27:
                self.state = 928
                self.properties()


            self.state = 932
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 931
                self.match(CypherParser.SP)


            self.state = 934
            self.match(CypherParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtomContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def literal(self):
            return self.getTypedRuleContext(CypherParser.LiteralContext,0)


        def parameter(self):
            return self.getTypedRuleContext(CypherParser.ParameterContext,0)


        def caseExpression(self):
            return self.getTypedRuleContext(CypherParser.CaseExpressionContext,0)


        def countAll(self):
            return self.getTypedRuleContext(CypherParser.CountAllContext,0)


        def listComprehension(self):
            return self.getTypedRuleContext(CypherParser.ListComprehensionContext,0)


        def patternComprehension(self):
            return self.getTypedRuleContext(CypherParser.PatternComprehensionContext,0)


        def filterWith(self):
            return self.getTypedRuleContext(CypherParser.FilterWithContext,0)


        def relationshipsChainPattern(self):
            return self.getTypedRuleContext(CypherParser.RelationshipsChainPatternContext,0)


        def parenthesizedExpression(self):
            return self.getTypedRuleContext(CypherParser.ParenthesizedExpressionContext,0)


        def functionInvocation(self):
            return self.getTypedRuleContext(CypherParser.FunctionInvocationContext,0)


        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


        def subqueryExist(self):
            return self.getTypedRuleContext(CypherParser.SubqueryExistContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_atom

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

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

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




    def atom(self):

        localctx = CypherParser.AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_atom)
        try:
            self.state = 948
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 936
                self.literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 937
                self.parameter()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 938
                self.caseExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 939
                self.countAll()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 940
                self.listComprehension()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 941
                self.patternComprehension()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 942
                self.filterWith()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 943
                self.relationshipsChainPattern()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 944
                self.parenthesizedExpression()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 945
                self.functionInvocation()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 946
                self.symbol()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 947
                self.subqueryExist()
                pass


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


    class LhsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_lhs

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

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

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




    def lhs(self):

        localctx = CypherParser.LhsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_lhs)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 950
            self.symbol()
            self.state = 951
            self.match(CypherParser.ASSIGN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationshipPatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def relationDetail(self):
            return self.getTypedRuleContext(CypherParser.RelationDetailContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_relationshipPattern

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

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

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




    def relationshipPattern(self):

        localctx = CypherParser.RelationshipPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_relationshipPattern)
        self._la = 0 # Token type
        try:
            self.state = 991
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [6]:
                self.enterOuterAlt(localctx, 1)
                self.state = 953
                self.match(CypherParser.LT)
                self.state = 955
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 954
                    self.match(CypherParser.SP)


                self.state = 957
                self.match(CypherParser.SUB)
                self.state = 959
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
                if la_ == 1:
                    self.state = 958
                    self.match(CypherParser.SP)


                self.state = 962
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 961
                    self.relationDetail()


                self.state = 965
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 964
                    self.match(CypherParser.SP)


                self.state = 967
                self.match(CypherParser.SUB)
                self.state = 969
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
                if la_ == 1:
                    self.state = 968
                    self.match(CypherParser.SP)


                self.state = 972
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 971
                    self.match(CypherParser.GT)


                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 2)
                self.state = 974
                self.match(CypherParser.SUB)
                self.state = 976
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
                if la_ == 1:
                    self.state = 975
                    self.match(CypherParser.SP)


                self.state = 979
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 978
                    self.relationDetail()


                self.state = 982
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 981
                    self.match(CypherParser.SP)


                self.state = 984
                self.match(CypherParser.SUB)
                self.state = 986
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,188,self._ctx)
                if la_ == 1:
                    self.state = 985
                    self.match(CypherParser.SP)


                self.state = 989
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 988
                    self.match(CypherParser.GT)


                pass
            else:
                raise NoViableAltException(self)

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


    class RelationDetailContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACK(self):
            return self.getToken(CypherParser.LBRACK, 0)

        def RBRACK(self):
            return self.getToken(CypherParser.RBRACK, 0)

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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


        def relationshipTypes(self):
            return self.getTypedRuleContext(CypherParser.RelationshipTypesContext,0)


        def rangeLit(self):
            return self.getTypedRuleContext(CypherParser.RangeLitContext,0)


        def properties(self):
            return self.getTypedRuleContext(CypherParser.PropertiesContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_relationDetail

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

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

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




    def relationDetail(self):

        localctx = CypherParser.RelationDetailContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_relationDetail)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 993
            self.match(CypherParser.LBRACK)
            self.state = 995
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
            if la_ == 1:
                self.state = 994
                self.match(CypherParser.SP)


            self.state = 998
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 67645734912) != 0) or ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & 89) != 0):
                self.state = 997
                self.symbol()


            self.state = 1001
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
            if la_ == 1:
                self.state = 1000
                self.match(CypherParser.SP)


            self.state = 1004
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==25:
                self.state = 1003
                self.relationshipTypes()


            self.state = 1007
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
            if la_ == 1:
                self.state = 1006
                self.match(CypherParser.SP)


            self.state = 1010
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==23:
                self.state = 1009
                self.rangeLit()


            self.state = 1013
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
            if la_ == 1:
                self.state = 1012
                self.match(CypherParser.SP)


            self.state = 1016
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==14 or _la==27:
                self.state = 1015
                self.properties()


            self.state = 1019
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1018
                self.match(CypherParser.SP)


            self.state = 1021
            self.match(CypherParser.RBRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RangeLitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MULT(self):
            return self.getToken(CypherParser.MULT, 0)

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

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

        def RANGE(self):
            return self.getToken(CypherParser.RANGE, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_rangeLit

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

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

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




    def rangeLit(self):

        localctx = CypherParser.RangeLitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_rangeLit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1023
            self.match(CypherParser.MULT)
            self.state = 1025
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
            if la_ == 1:
                self.state = 1024
                self.match(CypherParser.SP)


            self.state = 1028
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==92:
                self.state = 1027
                self.match(CypherParser.Integer)


            self.state = 1040
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
            if la_ == 1:
                self.state = 1031
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1030
                    self.match(CypherParser.SP)


                self.state = 1033
                self.match(CypherParser.RANGE)
                self.state = 1035
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
                if la_ == 1:
                    self.state = 1034
                    self.match(CypherParser.SP)


                self.state = 1038
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==92:
                    self.state = 1037
                    self.match(CypherParser.Integer)




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


    class RelationshipTypesContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_relationshipTypes

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

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

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




    def relationshipTypes(self):

        localctx = CypherParser.RelationshipTypesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_relationshipTypes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1042
            self.match(CypherParser.COLON)
            self.state = 1044
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1043
                self.match(CypherParser.SP)


            self.state = 1046
            self.name()
            self.state = 1063
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,211,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1048
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1047
                        self.match(CypherParser.SP)


                    self.state = 1050
                    self.match(CypherParser.STICK)
                    self.state = 1052
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
                    if la_ == 1:
                        self.state = 1051
                        self.match(CypherParser.SP)


                    self.state = 1055
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==25:
                        self.state = 1054
                        self.match(CypherParser.COLON)


                    self.state = 1058
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1057
                        self.match(CypherParser.SP)


                    self.state = 1060
                    self.name() 
                self.state = 1065
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,211,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 UnionStContext(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(CypherParser.UNION, 0)

        def singleQuery(self):
            return self.getTypedRuleContext(CypherParser.SingleQueryContext,0)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_unionSt

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

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

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




    def unionSt(self):

        localctx = CypherParser.UnionStContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_unionSt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1066
            self.match(CypherParser.UNION)
            self.state = 1068
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
            if la_ == 1:
                self.state = 1067
                self.match(CypherParser.SP)


            self.state = 1071
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==36:
                self.state = 1070
                self.match(CypherParser.ALL)


            self.state = 1074
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1073
                self.match(CypherParser.SP)


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


    class SubqueryExistContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LBRACE(self):
            return self.getToken(CypherParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(CypherParser.RBRACE, 0)

        def regularQuery(self):
            return self.getTypedRuleContext(CypherParser.RegularQueryContext,0)


        def patternWhere(self):
            return self.getTypedRuleContext(CypherParser.PatternWhereContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_subqueryExist

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

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

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




    def subqueryExist(self):

        localctx = CypherParser.SubqueryExistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_subqueryExist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1078
            self.match(CypherParser.EXISTS)
            self.state = 1080
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1079
                self.match(CypherParser.SP)


            self.state = 1082
            self.match(CypherParser.LBRACE)
            self.state = 1084
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1083
                self.match(CypherParser.SP)


            self.state = 1088
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [28, 40, 41, 44, 47, 48, 50, 52, 53, 54, 57, 59]:
                self.state = 1086
                self.regularQuery()
                pass
            elif token in [12, 30, 31, 32, 33, 34, 35, 89, 92, 93, 95]:
                self.state = 1087
                self.patternWhere()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1091
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1090
                self.match(CypherParser.SP)


            self.state = 1093
            self.match(CypherParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InvocationNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def symbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.SymbolContext)
            else:
                return self.getTypedRuleContext(CypherParser.SymbolContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_invocationName

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

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

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




    def invocationName(self):

        localctx = CypherParser.InvocationNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_invocationName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1095
            self.symbol()
            self.state = 1106
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,221,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1097
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1096
                        self.match(CypherParser.SP)


                    self.state = 1099
                    self.match(CypherParser.DOT)
                    self.state = 1101
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1100
                        self.match(CypherParser.SP)


                    self.state = 1103
                    self.symbol() 
                self.state = 1108
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,221,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 FunctionInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def invocationName(self):
            return self.getTypedRuleContext(CypherParser.InvocationNameContext,0)


        def LPAREN(self):
            return self.getToken(CypherParser.LPAREN, 0)

        def patternElem(self):
            return self.getTypedRuleContext(CypherParser.PatternElemContext,0)


        def RPAREN(self):
            return self.getToken(CypherParser.RPAREN, 0)

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

        def DISTINCT(self):
            return self.getToken(CypherParser.DISTINCT, 0)

        def expressionChain(self):
            return self.getTypedRuleContext(CypherParser.ExpressionChainContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_functionInvocation

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

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

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




    def functionInvocation(self):

        localctx = CypherParser.FunctionInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_functionInvocation)
        self._la = 0 # Token type
        try:
            self.state = 1151
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1109
                self.invocationName()
                self.state = 1111
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1110
                    self.match(CypherParser.SP)


                self.state = 1113
                self.match(CypherParser.LPAREN)
                self.state = 1115
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1114
                    self.match(CypherParser.SP)


                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63:
                    self.state = 1117
                    self.match(CypherParser.DISTINCT)
                    self.state = 1119
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1118
                        self.match(CypherParser.SP)




                self.state = 1123
                self.patternElem()
                self.state = 1125
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1124
                    self.match(CypherParser.SP)


                self.state = 1127
                self.match(CypherParser.RPAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1129
                self.invocationName()
                self.state = 1131
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1130
                    self.match(CypherParser.SP)


                self.state = 1133
                self.match(CypherParser.LPAREN)
                self.state = 1135
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,228,self._ctx)
                if la_ == 1:
                    self.state = 1134
                    self.match(CypherParser.SP)


                self.state = 1141
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63:
                    self.state = 1137
                    self.match(CypherParser.DISTINCT)
                    self.state = 1139
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
                    if la_ == 1:
                        self.state = 1138
                        self.match(CypherParser.SP)




                self.state = 1144
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,231,self._ctx)
                if la_ == 1:
                    self.state = 1143
                    self.expressionChain()


                self.state = 1147
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1146
                    self.match(CypherParser.SP)


                self.state = 1149
                self.match(CypherParser.RPAREN)
                pass


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


    class ParenthesizedExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(CypherParser.LPAREN, 0)

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


        def RPAREN(self):
            return self.getToken(CypherParser.RPAREN, 0)

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

        def getRuleIndex(self):
            return CypherParser.RULE_parenthesizedExpression

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

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

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




    def parenthesizedExpression(self):

        localctx = CypherParser.ParenthesizedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_parenthesizedExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1153
            self.match(CypherParser.LPAREN)
            self.state = 1155
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
            if la_ == 1:
                self.state = 1154
                self.match(CypherParser.SP)


            self.state = 1157
            self.expression()
            self.state = 1159
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1158
                self.match(CypherParser.SP)


            self.state = 1161
            self.match(CypherParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FilterWithContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(CypherParser.LPAREN, 0)

        def filterExpression(self):
            return self.getTypedRuleContext(CypherParser.FilterExpressionContext,0)


        def RPAREN(self):
            return self.getToken(CypherParser.RPAREN, 0)

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

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_filterWith

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

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

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




    def filterWith(self):

        localctx = CypherParser.FilterWithContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_filterWith)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1163
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 128849018880) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1165
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1164
                self.match(CypherParser.SP)


            self.state = 1167
            self.match(CypherParser.LPAREN)
            self.state = 1169
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1168
                self.match(CypherParser.SP)


            self.state = 1171
            self.filterExpression()
            self.state = 1173
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1172
                self.match(CypherParser.SP)


            self.state = 1175
            self.match(CypherParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PatternComprehensionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACK(self):
            return self.getToken(CypherParser.LBRACK, 0)

        def relationshipsChainPattern(self):
            return self.getTypedRuleContext(CypherParser.RelationshipsChainPatternContext,0)


        def STICK(self):
            return self.getToken(CypherParser.STICK, 0)

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


        def RBRACK(self):
            return self.getToken(CypherParser.RBRACK, 0)

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

        def lhs(self):
            return self.getTypedRuleContext(CypherParser.LhsContext,0)


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

        def where(self):
            return self.getTypedRuleContext(CypherParser.WhereContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_patternComprehension

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

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

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




    def patternComprehension(self):

        localctx = CypherParser.PatternComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_patternComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1177
            self.match(CypherParser.LBRACK)
            self.state = 1179
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1178
                self.match(CypherParser.SP)


            self.state = 1189
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 67645734912) != 0) or ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & 89) != 0):
                self.state = 1181
                self.lhs()
                self.state = 1183
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1182
                    self.match(CypherParser.SP)


                self.state = 1185
                self.match(CypherParser.ASSIGN)
                self.state = 1187
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1186
                    self.match(CypherParser.SP)




            self.state = 1191
            self.relationshipsChainPattern()
            self.state = 1196
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,244,self._ctx)
            if la_ == 1:
                self.state = 1193
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1192
                    self.match(CypherParser.SP)


                self.state = 1195
                self.where()


            self.state = 1199
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1198
                self.match(CypherParser.SP)


            self.state = 1201
            self.match(CypherParser.STICK)
            self.state = 1203
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,246,self._ctx)
            if la_ == 1:
                self.state = 1202
                self.match(CypherParser.SP)


            self.state = 1205
            self.expression()
            self.state = 1207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1206
                self.match(CypherParser.SP)


            self.state = 1209
            self.match(CypherParser.RBRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationshipsChainPatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nodePattern(self):
            return self.getTypedRuleContext(CypherParser.NodePatternContext,0)


        def patternElemChain(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.PatternElemChainContext)
            else:
                return self.getTypedRuleContext(CypherParser.PatternElemChainContext,i)


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

        def getRuleIndex(self):
            return CypherParser.RULE_relationshipsChainPattern

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

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

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




    def relationshipsChainPattern(self):

        localctx = CypherParser.RelationshipsChainPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_relationshipsChainPattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1211
            self.nodePattern()
            self.state = 1216 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1213
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1212
                        self.match(CypherParser.SP)


                    self.state = 1215
                    self.patternElemChain()

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

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


    class ListComprehensionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACK(self):
            return self.getToken(CypherParser.LBRACK, 0)

        def filterExpression(self):
            return self.getTypedRuleContext(CypherParser.FilterExpressionContext,0)


        def RBRACK(self):
            return self.getToken(CypherParser.RBRACK, 0)

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

        def STICK(self):
            return self.getToken(CypherParser.STICK, 0)

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


        def getRuleIndex(self):
            return CypherParser.RULE_listComprehension

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

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

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




    def listComprehension(self):

        localctx = CypherParser.ListComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_listComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1220
            self.match(CypherParser.LBRACK)
            self.state = 1222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1221
                self.match(CypherParser.SP)


            self.state = 1224
            self.filterExpression()
            self.state = 1233
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,253,self._ctx)
            if la_ == 1:
                self.state = 1226
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1225
                    self.match(CypherParser.SP)


                self.state = 1228
                self.match(CypherParser.STICK)
                self.state = 1230
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
                if la_ == 1:
                    self.state = 1229
                    self.match(CypherParser.SP)


                self.state = 1232
                self.expression()


            self.state = 1236
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1235
                self.match(CypherParser.SP)


            self.state = 1238
            self.match(CypherParser.RBRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FilterExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


        def IN(self):
            return self.getToken(CypherParser.IN, 0)

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


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

        def where(self):
            return self.getTypedRuleContext(CypherParser.WhereContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_filterExpression

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

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

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




    def filterExpression(self):

        localctx = CypherParser.FilterExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_filterExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1240
            self.symbol()
            self.state = 1242
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1241
                self.match(CypherParser.SP)


            self.state = 1244
            self.match(CypherParser.IN)
            self.state = 1246
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
            if la_ == 1:
                self.state = 1245
                self.match(CypherParser.SP)


            self.state = 1248
            self.expression()
            self.state = 1253
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
            if la_ == 1:
                self.state = 1250
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1249
                    self.match(CypherParser.SP)


                self.state = 1252
                self.where()


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


    class CountAllContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def COUNT(self):
            return self.getToken(CypherParser.COUNT, 0)

        def LPAREN(self):
            return self.getToken(CypherParser.LPAREN, 0)

        def MULT(self):
            return self.getToken(CypherParser.MULT, 0)

        def RPAREN(self):
            return self.getToken(CypherParser.RPAREN, 0)

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

        def getRuleIndex(self):
            return CypherParser.RULE_countAll

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

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

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




    def countAll(self):

        localctx = CypherParser.CountAllContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_countAll)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1255
            self.match(CypherParser.COUNT)
            self.state = 1257
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1256
                self.match(CypherParser.SP)


            self.state = 1259
            self.match(CypherParser.LPAREN)
            self.state = 1261
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1260
                self.match(CypherParser.SP)


            self.state = 1263
            self.match(CypherParser.MULT)
            self.state = 1265
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1264
                self.match(CypherParser.SP)


            self.state = 1267
            self.match(CypherParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionChainContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.ExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_expressionChain

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

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

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




    def expressionChain(self):

        localctx = CypherParser.ExpressionChainContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_expressionChain)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1269
            self.expression()
            self.state = 1280
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,264,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1271
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1270
                        self.match(CypherParser.SP)


                    self.state = 1273
                    self.match(CypherParser.COMMA)
                    self.state = 1275
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,263,self._ctx)
                    if la_ == 1:
                        self.state = 1274
                        self.match(CypherParser.SP)


                    self.state = 1277
                    self.expression() 
                self.state = 1282
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,264,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 CaseExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CASE(self):
            return self.getToken(CypherParser.CASE, 0)

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

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.ExpressionContext,i)


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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_caseExpression

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

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

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




    def caseExpression(self):

        localctx = CypherParser.CaseExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_caseExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1283
            self.match(CypherParser.CASE)
            self.state = 1285
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,265,self._ctx)
            if la_ == 1:
                self.state = 1284
                self.match(CypherParser.SP)


            self.state = 1288
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,266,self._ctx)
            if la_ == 1:
                self.state = 1287
                self.expression()


            self.state = 1307 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1291
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1290
                        self.match(CypherParser.SP)


                    self.state = 1293
                    self.match(CypherParser.WHEN)
                    self.state = 1295
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,268,self._ctx)
                    if la_ == 1:
                        self.state = 1294
                        self.match(CypherParser.SP)


                    self.state = 1297
                    self.expression()
                    self.state = 1299
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==99:
                        self.state = 1298
                        self.match(CypherParser.SP)


                    self.state = 1301
                    self.match(CypherParser.THEN)
                    self.state = 1303
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,270,self._ctx)
                    if la_ == 1:
                        self.state = 1302
                        self.match(CypherParser.SP)


                    self.state = 1305
                    self.expression()

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

            self.state = 1319
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
            if la_ == 1:
                self.state = 1312
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==99:
                    self.state = 1311
                    self.match(CypherParser.SP)


                self.state = 1314
                self.match(CypherParser.ELSE)
                self.state = 1316
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,273,self._ctx)
                if la_ == 1:
                    self.state = 1315
                    self.match(CypherParser.SP)


                self.state = 1318
                self.expression()


            self.state = 1322
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1321
                self.match(CypherParser.SP)


            self.state = 1324
            self.match(CypherParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DOLLAR(self):
            return self.getToken(CypherParser.DOLLAR, 0)

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


        def numLit(self):
            return self.getTypedRuleContext(CypherParser.NumLitContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_parameter

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

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

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




    def parameter(self):

        localctx = CypherParser.ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_parameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1326
            self.match(CypherParser.DOLLAR)
            self.state = 1329
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,276,self._ctx)
            if la_ == 1:
                self.state = 1327
                self.symbol()
                pass

            elif la_ == 2:
                self.state = 1328
                self.numLit()
                pass


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


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def boolLit(self):
            return self.getTypedRuleContext(CypherParser.BoolLitContext,0)


        def numLit(self):
            return self.getTypedRuleContext(CypherParser.NumLitContext,0)


        def NULL_W(self):
            return self.getToken(CypherParser.NULL_W, 0)

        def stringLit(self):
            return self.getTypedRuleContext(CypherParser.StringLitContext,0)


        def charLit(self):
            return self.getTypedRuleContext(CypherParser.CharLitContext,0)


        def listLit(self):
            return self.getTypedRuleContext(CypherParser.ListLitContext,0)


        def mapLit(self):
            return self.getTypedRuleContext(CypherParser.MapLitContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_literal

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

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

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




    def literal(self):

        localctx = CypherParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_literal)
        try:
            self.state = 1338
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [71, 72]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1331
                self.boolLit()
                pass
            elif token in [93]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1332
                self.numLit()
                pass
            elif token in [73]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1333
                self.match(CypherParser.NULL_W)
                pass
            elif token in [91]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1334
                self.stringLit()
                pass
            elif token in [90]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1335
                self.charLit()
                pass
            elif token in [16]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1336
                self.listLit()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1337
                self.mapLit()
                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 BoolLitContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_boolLit

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

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

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




    def boolLit(self):

        localctx = CypherParser.BoolLitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_boolLit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1340
            _la = self._input.LA(1)
            if not(_la==71 or _la==72):
                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 NumLitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DIGIT(self):
            return self.getToken(CypherParser.DIGIT, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_numLit

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

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

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




    def numLit(self):

        localctx = CypherParser.NumLitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_numLit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1342
            self.match(CypherParser.DIGIT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringLitContext(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(CypherParser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_stringLit

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

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

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




    def stringLit(self):

        localctx = CypherParser.StringLitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_stringLit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1344
            self.match(CypherParser.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 CharLitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHAR_LITERAL(self):
            return self.getToken(CypherParser.CHAR_LITERAL, 0)

        def getRuleIndex(self):
            return CypherParser.RULE_charLit

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

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

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




    def charLit(self):

        localctx = CypherParser.CharLitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_charLit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1346
            self.match(CypherParser.CHAR_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListLitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACK(self):
            return self.getToken(CypherParser.LBRACK, 0)

        def RBRACK(self):
            return self.getToken(CypherParser.RBRACK, 0)

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

        def expressionChain(self):
            return self.getTypedRuleContext(CypherParser.ExpressionChainContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_listLit

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

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

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




    def listLit(self):

        localctx = CypherParser.ListLitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_listLit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1348
            self.match(CypherParser.LBRACK)
            self.state = 1350
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,278,self._ctx)
            if la_ == 1:
                self.state = 1349
                self.match(CypherParser.SP)


            self.state = 1353
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,279,self._ctx)
            if la_ == 1:
                self.state = 1352
                self.expressionChain()


            self.state = 1356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1355
                self.match(CypherParser.SP)


            self.state = 1358
            self.match(CypherParser.RBRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MapLitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACE(self):
            return self.getToken(CypherParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(CypherParser.RBRACE, 0)

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

        def mapPair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.MapPairContext)
            else:
                return self.getTypedRuleContext(CypherParser.MapPairContext,i)


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

        def getRuleIndex(self):
            return CypherParser.RULE_mapLit

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

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

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




    def mapLit(self):

        localctx = CypherParser.MapLitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_mapLit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1360
            self.match(CypherParser.LBRACE)
            self.state = 1362
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,281,self._ctx)
            if la_ == 1:
                self.state = 1361
                self.match(CypherParser.SP)


            self.state = 1378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -1073741824) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 3019898879) != 0):
                self.state = 1364
                self.mapPair()
                self.state = 1375
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,284,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1366
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==99:
                            self.state = 1365
                            self.match(CypherParser.SP)


                        self.state = 1368
                        self.match(CypherParser.COMMA)
                        self.state = 1370
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==99:
                            self.state = 1369
                            self.match(CypherParser.SP)


                        self.state = 1372
                        self.mapPair() 
                    self.state = 1377
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,284,self._ctx)



            self.state = 1381
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1380
                self.match(CypherParser.SP)


            self.state = 1383
            self.match(CypherParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MapPairContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


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

        def getRuleIndex(self):
            return CypherParser.RULE_mapPair

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

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

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




    def mapPair(self):

        localctx = CypherParser.MapPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_mapPair)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1385
            self.name()
            self.state = 1387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==99:
                self.state = 1386
                self.match(CypherParser.SP)


            self.state = 1389
            self.match(CypherParser.COLON)
            self.state = 1391
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,288,self._ctx)
            if la_ == 1:
                self.state = 1390
                self.match(CypherParser.SP)


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


    class NameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def symbol(self):
            return self.getTypedRuleContext(CypherParser.SymbolContext,0)


        def reservedWord(self):
            return self.getTypedRuleContext(CypherParser.ReservedWordContext,0)


        def getRuleIndex(self):
            return CypherParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitName" ):
                return visitor.visitName(self)
            else:
                return visitor.visitChildren(self)




    def name(self):

        localctx = CypherParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_name)
        try:
            self.state = 1397
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [30, 31, 32, 33, 34, 35, 89, 92, 93, 95]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1395
                self.symbol()
                pass
            elif token in [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1396
                self.reservedWord()
                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 SymbolContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ESC_LITERAL(self):
            return self.getToken(CypherParser.ESC_LITERAL, 0)

        def Integer(self):
            return self.getToken(CypherParser.Integer, 0)

        def DIGIT(self):
            return self.getToken(CypherParser.DIGIT, 0)

        def ID(self):
            return self.getToken(CypherParser.ID, 0)

        def COUNT(self):
            return self.getToken(CypherParser.COUNT, 0)

        def FILTER(self):
            return self.getToken(CypherParser.FILTER, 0)

        def EXTRACT(self):
            return self.getToken(CypherParser.EXTRACT, 0)

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_symbol

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

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

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




    def symbol(self):

        localctx = CypherParser.SymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_symbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1399
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 67645734912) != 0) or ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & 89) != 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 ReservedWordContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def ASCENDING(self):
            return self.getToken(CypherParser.ASCENDING, 0)

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

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

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

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

        def DESCENDING(self):
            return self.getToken(CypherParser.DESCENDING, 0)

        def DETACH(self):
            return self.getToken(CypherParser.DETACH, 0)

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

        def LIMIT(self):
            return self.getToken(CypherParser.LIMIT, 0)

        def MATCH(self):
            return self.getToken(CypherParser.MATCH, 0)

        def MERGE(self):
            return self.getToken(CypherParser.MERGE, 0)

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

        def OPTIONAL(self):
            return self.getToken(CypherParser.OPTIONAL, 0)

        def ORDER(self):
            return self.getToken(CypherParser.ORDER, 0)

        def REMOVE(self):
            return self.getToken(CypherParser.REMOVE, 0)

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

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

        def SKIP_W(self):
            return self.getToken(CypherParser.SKIP_W, 0)

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

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

        def UNION(self):
            return self.getToken(CypherParser.UNION, 0)

        def UNWIND(self):
            return self.getToken(CypherParser.UNWIND, 0)

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

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

        def CONTAINS(self):
            return self.getToken(CypherParser.CONTAINS, 0)

        def DISTINCT(self):
            return self.getToken(CypherParser.DISTINCT, 0)

        def ENDS(self):
            return self.getToken(CypherParser.ENDS, 0)

        def IN(self):
            return self.getToken(CypherParser.IN, 0)

        def IS(self):
            return self.getToken(CypherParser.IS, 0)

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

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

        def STARTS(self):
            return self.getToken(CypherParser.STARTS, 0)

        def XOR(self):
            return self.getToken(CypherParser.XOR, 0)

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

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

        def NULL_W(self):
            return self.getToken(CypherParser.NULL_W, 0)

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

        def DO(self):
            return self.getToken(CypherParser.DO, 0)

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

        def REQUIRE(self):
            return self.getToken(CypherParser.REQUIRE, 0)

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

        def CASE(self):
            return self.getToken(CypherParser.CASE, 0)

        def WHEN(self):
            return self.getToken(CypherParser.WHEN, 0)

        def THEN(self):
            return self.getToken(CypherParser.THEN, 0)

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

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

        def MANDATORY(self):
            return self.getToken(CypherParser.MANDATORY, 0)

        def SCALAR(self):
            return self.getToken(CypherParser.SCALAR, 0)

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_reservedWord

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

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

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




    def reservedWord(self):

        localctx = CypherParser.ReservedWordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_reservedWord)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1401
            _la = self._input.LA(1)
            if not(((((_la - 36)) & ~0x3f) == 0 and ((1 << (_la - 36)) & 9007199254740991) != 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





