# Generated from src/gsql2rsql/parser/grammar/Cypher.g4 by ANTLR 4.13.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

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

class CypherParser ( Parser ):

    grammarFileName = "Cypher.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "';'", "','", "'='", "'+='", "'*'", "'('", 
                     "')'", "'['", "']'", "':'", "'|'", "'..'", "'<>'", 
                     "'<'", "'>'", "'<='", "'>='", "'+'", "'-'", "'/'", 
                     "'%'", "'^'", "'.'", "'{'", "'}'", "'$'", "'\\u27E8'", 
                     "'\\u3008'", "'\\uFE64'", "'\\uFF1C'", "'\\u27E9'", 
                     "'\\u3009'", "'\\uFE65'", "'\\uFF1E'", "'\\u00AD'", 
                     "'\\u2010'", "'\\u2011'", "'\\u2012'", "'\\u2013'", 
                     "'\\u2014'", "'\\u2015'", "'\\u2212'", "'\\uFE58'", 
                     "'\\uFE63'", "'\\uFF0D'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'0'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "UNION", "ALL", "OPTIONAL", 
                      "MATCH", "UNWIND", "AS", "MERGE", "ON", "CREATE", 
                      "SET", "DETACH", "DELETE", "REMOVE", "CALL", "YIELD", 
                      "WITH", "RETURN", "DISTINCT", "ORDER", "BY", "L_SKIP", 
                      "LIMIT", "ASCENDING", "ASC", "DESCENDING", "DESC", 
                      "WHERE", "OR", "XOR", "AND", "NOT", "STARTS", "ENDS", 
                      "CONTAINS", "IN", "IS", "NULL", "COUNT", "CASE", "ELSE", 
                      "END", "WHEN", "THEN", "ANY", "NONE", "SINGLE", "REDUCE", 
                      "EXISTS", "TRUE", "FALSE", "HexInteger", "DecimalInteger", 
                      "OctalInteger", "HexLetter", "HexDigit", "Digit", 
                      "NonZeroDigit", "NonZeroOctDigit", "OctDigit", "ZeroDigit", 
                      "ExponentDecimalReal", "RegularDecimalReal", "StringLiteral", 
                      "EscapedChar", "CONSTRAINT", "DO", "FOR", "REQUIRE", 
                      "UNIQUE", "MANDATORY", "SCALAR", "OF", "ADD", "DROP", 
                      "FILTER", "EXTRACT", "UnescapedSymbolicName", "IdentifierStart", 
                      "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE", 
                      "Comment" ]

    RULE_oC_Cypher = 0
    RULE_oC_Statement = 1
    RULE_oC_Query = 2
    RULE_oC_RegularQuery = 3
    RULE_oC_Union = 4
    RULE_oC_SingleQuery = 5
    RULE_oC_SinglePartQuery = 6
    RULE_oC_MultiPartQuery = 7
    RULE_oC_UpdatingClause = 8
    RULE_oC_ReadingClause = 9
    RULE_oC_Match = 10
    RULE_oC_Unwind = 11
    RULE_oC_Merge = 12
    RULE_oC_MergeAction = 13
    RULE_oC_Create = 14
    RULE_oC_Set = 15
    RULE_oC_SetItem = 16
    RULE_oC_Delete = 17
    RULE_oC_Remove = 18
    RULE_oC_RemoveItem = 19
    RULE_oC_InQueryCall = 20
    RULE_oC_StandaloneCall = 21
    RULE_oC_YieldItems = 22
    RULE_oC_YieldItem = 23
    RULE_oC_With = 24
    RULE_oC_Return = 25
    RULE_oC_ProjectionBody = 26
    RULE_oC_ProjectionItems = 27
    RULE_oC_ProjectionItem = 28
    RULE_oC_Order = 29
    RULE_oC_Skip = 30
    RULE_oC_Limit = 31
    RULE_oC_SortItem = 32
    RULE_oC_Where = 33
    RULE_oC_Pattern = 34
    RULE_oC_PatternPart = 35
    RULE_oC_AnonymousPatternPart = 36
    RULE_oC_PatternElement = 37
    RULE_oC_RelationshipsPattern = 38
    RULE_oC_NodePattern = 39
    RULE_oC_PatternElementChain = 40
    RULE_oC_RelationshipPattern = 41
    RULE_oC_RelationshipDetail = 42
    RULE_oC_Properties = 43
    RULE_oC_RelationshipTypes = 44
    RULE_oC_NodeLabels = 45
    RULE_oC_NodeLabel = 46
    RULE_oC_RangeLiteral = 47
    RULE_oC_LabelName = 48
    RULE_oC_RelTypeName = 49
    RULE_oC_PropertyExpression = 50
    RULE_oC_Expression = 51
    RULE_oC_OrExpression = 52
    RULE_oC_XorExpression = 53
    RULE_oC_AndExpression = 54
    RULE_oC_NotExpression = 55
    RULE_oC_ComparisonExpression = 56
    RULE_oC_PartialComparisonExpression = 57
    RULE_oC_StringListNullPredicateExpression = 58
    RULE_oC_StringPredicateExpression = 59
    RULE_oC_ListPredicateExpression = 60
    RULE_oC_NullPredicateExpression = 61
    RULE_oC_AddOrSubtractExpression = 62
    RULE_oC_MultiplyDivideModuloExpression = 63
    RULE_oC_PowerOfExpression = 64
    RULE_oC_UnaryAddOrSubtractExpression = 65
    RULE_oC_NonArithmeticOperatorExpression = 66
    RULE_oC_ListOperatorExpression = 67
    RULE_oC_PropertyLookup = 68
    RULE_oC_Atom = 69
    RULE_oC_CaseExpression = 70
    RULE_oC_CaseAlternative = 71
    RULE_oC_ListComprehension = 72
    RULE_oC_PatternComprehension = 73
    RULE_oC_Quantifier = 74
    RULE_oC_Reduce = 75
    RULE_oC_FilterExpression = 76
    RULE_oC_PatternPredicate = 77
    RULE_oC_ParenthesizedExpression = 78
    RULE_oC_IdInColl = 79
    RULE_oC_FunctionInvocation = 80
    RULE_oC_FunctionName = 81
    RULE_oC_ExistentialSubquery = 82
    RULE_oC_ExplicitProcedureInvocation = 83
    RULE_oC_ImplicitProcedureInvocation = 84
    RULE_oC_ProcedureResultField = 85
    RULE_oC_ProcedureName = 86
    RULE_oC_Namespace = 87
    RULE_oC_Variable = 88
    RULE_oC_Literal = 89
    RULE_oC_BooleanLiteral = 90
    RULE_oC_NumberLiteral = 91
    RULE_oC_IntegerLiteral = 92
    RULE_oC_DoubleLiteral = 93
    RULE_oC_ListLiteral = 94
    RULE_oC_MapLiteral = 95
    RULE_oC_PropertyKeyName = 96
    RULE_oC_Parameter = 97
    RULE_oC_SchemaName = 98
    RULE_oC_ReservedWord = 99
    RULE_oC_SymbolicName = 100
    RULE_oC_LeftArrowHead = 101
    RULE_oC_RightArrowHead = 102
    RULE_oC_Dash = 103

    ruleNames =  [ "oC_Cypher", "oC_Statement", "oC_Query", "oC_RegularQuery", 
                   "oC_Union", "oC_SingleQuery", "oC_SinglePartQuery", "oC_MultiPartQuery", 
                   "oC_UpdatingClause", "oC_ReadingClause", "oC_Match", 
                   "oC_Unwind", "oC_Merge", "oC_MergeAction", "oC_Create", 
                   "oC_Set", "oC_SetItem", "oC_Delete", "oC_Remove", "oC_RemoveItem", 
                   "oC_InQueryCall", "oC_StandaloneCall", "oC_YieldItems", 
                   "oC_YieldItem", "oC_With", "oC_Return", "oC_ProjectionBody", 
                   "oC_ProjectionItems", "oC_ProjectionItem", "oC_Order", 
                   "oC_Skip", "oC_Limit", "oC_SortItem", "oC_Where", "oC_Pattern", 
                   "oC_PatternPart", "oC_AnonymousPatternPart", "oC_PatternElement", 
                   "oC_RelationshipsPattern", "oC_NodePattern", "oC_PatternElementChain", 
                   "oC_RelationshipPattern", "oC_RelationshipDetail", "oC_Properties", 
                   "oC_RelationshipTypes", "oC_NodeLabels", "oC_NodeLabel", 
                   "oC_RangeLiteral", "oC_LabelName", "oC_RelTypeName", 
                   "oC_PropertyExpression", "oC_Expression", "oC_OrExpression", 
                   "oC_XorExpression", "oC_AndExpression", "oC_NotExpression", 
                   "oC_ComparisonExpression", "oC_PartialComparisonExpression", 
                   "oC_StringListNullPredicateExpression", "oC_StringPredicateExpression", 
                   "oC_ListPredicateExpression", "oC_NullPredicateExpression", 
                   "oC_AddOrSubtractExpression", "oC_MultiplyDivideModuloExpression", 
                   "oC_PowerOfExpression", "oC_UnaryAddOrSubtractExpression", 
                   "oC_NonArithmeticOperatorExpression", "oC_ListOperatorExpression", 
                   "oC_PropertyLookup", "oC_Atom", "oC_CaseExpression", 
                   "oC_CaseAlternative", "oC_ListComprehension", "oC_PatternComprehension", 
                   "oC_Quantifier", "oC_Reduce", "oC_FilterExpression", 
                   "oC_PatternPredicate", "oC_ParenthesizedExpression", 
                   "oC_IdInColl", "oC_FunctionInvocation", "oC_FunctionName", 
                   "oC_ExistentialSubquery", "oC_ExplicitProcedureInvocation", 
                   "oC_ImplicitProcedureInvocation", "oC_ProcedureResultField", 
                   "oC_ProcedureName", "oC_Namespace", "oC_Variable", "oC_Literal", 
                   "oC_BooleanLiteral", "oC_NumberLiteral", "oC_IntegerLiteral", 
                   "oC_DoubleLiteral", "oC_ListLiteral", "oC_MapLiteral", 
                   "oC_PropertyKeyName", "oC_Parameter", "oC_SchemaName", 
                   "oC_ReservedWord", "oC_SymbolicName", "oC_LeftArrowHead", 
                   "oC_RightArrowHead", "oC_Dash" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    UNION=46
    ALL=47
    OPTIONAL=48
    MATCH=49
    UNWIND=50
    AS=51
    MERGE=52
    ON=53
    CREATE=54
    SET=55
    DETACH=56
    DELETE=57
    REMOVE=58
    CALL=59
    YIELD=60
    WITH=61
    RETURN=62
    DISTINCT=63
    ORDER=64
    BY=65
    L_SKIP=66
    LIMIT=67
    ASCENDING=68
    ASC=69
    DESCENDING=70
    DESC=71
    WHERE=72
    OR=73
    XOR=74
    AND=75
    NOT=76
    STARTS=77
    ENDS=78
    CONTAINS=79
    IN=80
    IS=81
    NULL=82
    COUNT=83
    CASE=84
    ELSE=85
    END=86
    WHEN=87
    THEN=88
    ANY=89
    NONE=90
    SINGLE=91
    REDUCE=92
    EXISTS=93
    TRUE=94
    FALSE=95
    HexInteger=96
    DecimalInteger=97
    OctalInteger=98
    HexLetter=99
    HexDigit=100
    Digit=101
    NonZeroDigit=102
    NonZeroOctDigit=103
    OctDigit=104
    ZeroDigit=105
    ExponentDecimalReal=106
    RegularDecimalReal=107
    StringLiteral=108
    EscapedChar=109
    CONSTRAINT=110
    DO=111
    FOR=112
    REQUIRE=113
    UNIQUE=114
    MANDATORY=115
    SCALAR=116
    OF=117
    ADD=118
    DROP=119
    FILTER=120
    EXTRACT=121
    UnescapedSymbolicName=122
    IdentifierStart=123
    IdentifierPart=124
    EscapedSymbolicName=125
    SP=126
    WHITESPACE=127
    Comment=128

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




    class OC_CypherContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Statement(self):
            return self.getTypedRuleContext(CypherParser.OC_StatementContext,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 getRuleIndex(self):
            return CypherParser.RULE_oC_Cypher

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

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

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




    def oC_Cypher(self):

        localctx = CypherParser.OC_CypherContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_oC_Cypher)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 209
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 208
                self.match(CypherParser.SP)


            self.state = 211
            self.oC_Statement()
            self.state = 216
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 213
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 212
                    self.match(CypherParser.SP)


                self.state = 215
                self.match(CypherParser.T__0)


            self.state = 219
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 218
                self.match(CypherParser.SP)


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

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

        def oC_Query(self):
            return self.getTypedRuleContext(CypherParser.OC_QueryContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Statement

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

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

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




    def oC_Statement(self):

        localctx = CypherParser.OC_StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_oC_Statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 223
            self.oC_Query()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_QueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_RegularQuery(self):
            return self.getTypedRuleContext(CypherParser.OC_RegularQueryContext,0)


        def oC_StandaloneCall(self):
            return self.getTypedRuleContext(CypherParser.OC_StandaloneCallContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Query

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

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

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




    def oC_Query(self):

        localctx = CypherParser.OC_QueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_oC_Query)
        try:
            self.state = 227
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 225
                self.oC_RegularQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 226
                self.oC_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 OC_RegularQueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SingleQuery(self):
            return self.getTypedRuleContext(CypherParser.OC_SingleQueryContext,0)


        def oC_Union(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_UnionContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_UnionContext,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_oC_RegularQuery

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

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

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




    def oC_RegularQuery(self):

        localctx = CypherParser.OC_RegularQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_oC_RegularQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 229
            self.oC_SingleQuery()
            self.state = 236
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 231
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 230
                        self.match(CypherParser.SP)


                    self.state = 233
                    self.oC_Union() 
                self.state = 238
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,6,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 OC_UnionContext(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 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 oC_SingleQuery(self):
            return self.getTypedRuleContext(CypherParser.OC_SingleQueryContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Union

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

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

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




    def oC_Union(self):

        localctx = CypherParser.OC_UnionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_oC_Union)
        self._la = 0 # Token type
        try:
            self.state = 251
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 239
                self.match(CypherParser.UNION)
                self.state = 240
                self.match(CypherParser.SP)
                self.state = 241
                self.match(CypherParser.ALL)
                self.state = 243
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 242
                    self.match(CypherParser.SP)


                self.state = 245
                self.oC_SingleQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 246
                self.match(CypherParser.UNION)
                self.state = 248
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 247
                    self.match(CypherParser.SP)


                self.state = 250
                self.oC_SingleQuery()
                pass


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


    class OC_SingleQueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SinglePartQuery(self):
            return self.getTypedRuleContext(CypherParser.OC_SinglePartQueryContext,0)


        def oC_MultiPartQuery(self):
            return self.getTypedRuleContext(CypherParser.OC_MultiPartQueryContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_SingleQuery

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

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

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




    def oC_SingleQuery(self):

        localctx = CypherParser.OC_SingleQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_oC_SingleQuery)
        try:
            self.state = 255
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 253
                self.oC_SinglePartQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 254
                self.oC_MultiPartQuery()
                pass


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


    class OC_SinglePartQueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Return(self):
            return self.getTypedRuleContext(CypherParser.OC_ReturnContext,0)


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


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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_SinglePartQuery

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

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

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




    def oC_SinglePartQuery(self):

        localctx = CypherParser.OC_SinglePartQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_oC_SinglePartQuery)
        self._la = 0 # Token type
        try:
            self.state = 292
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 263
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 578431077140398080) != 0):
                    self.state = 257
                    self.oC_ReadingClause()
                    self.state = 259
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 258
                        self.match(CypherParser.SP)


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

                self.state = 266
                self.oC_Return()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 273
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 578431077140398080) != 0):
                    self.state = 267
                    self.oC_ReadingClause()
                    self.state = 269
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 268
                        self.match(CypherParser.SP)


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

                self.state = 276
                self.oC_UpdatingClause()
                self.state = 283
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,16,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 278
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 277
                            self.match(CypherParser.SP)


                        self.state = 280
                        self.oC_UpdatingClause() 
                    self.state = 285
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,16,self._ctx)

                self.state = 290
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                if la_ == 1:
                    self.state = 287
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 286
                        self.match(CypherParser.SP)


                    self.state = 289
                    self.oC_Return()


                pass


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


    class OC_MultiPartQueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SinglePartQuery(self):
            return self.getTypedRuleContext(CypherParser.OC_SinglePartQueryContext,0)


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


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


        def oC_UpdatingClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_UpdatingClauseContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_UpdatingClauseContext,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_oC_MultiPartQuery

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

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

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




    def oC_MultiPartQuery(self):

        localctx = CypherParser.OC_MultiPartQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_oC_MultiPartQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 316 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 300
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while (((_la) & ~0x3f) == 0 and ((1 << _la) & 578431077140398080) != 0):
                        self.state = 294
                        self.oC_ReadingClause()
                        self.state = 296
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 295
                            self.match(CypherParser.SP)


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

                    self.state = 309
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while (((_la) & ~0x3f) == 0 and ((1 << _la) & 562949953421312000) != 0):
                        self.state = 303
                        self.oC_UpdatingClause()
                        self.state = 305
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 304
                            self.match(CypherParser.SP)


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

                    self.state = 312
                    self.oC_With()
                    self.state = 314
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 313
                        self.match(CypherParser.SP)



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

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


    class OC_UpdatingClauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Create(self):
            return self.getTypedRuleContext(CypherParser.OC_CreateContext,0)


        def oC_Merge(self):
            return self.getTypedRuleContext(CypherParser.OC_MergeContext,0)


        def oC_Delete(self):
            return self.getTypedRuleContext(CypherParser.OC_DeleteContext,0)


        def oC_Set(self):
            return self.getTypedRuleContext(CypherParser.OC_SetContext,0)


        def oC_Remove(self):
            return self.getTypedRuleContext(CypherParser.OC_RemoveContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_UpdatingClause

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

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

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




    def oC_UpdatingClause(self):

        localctx = CypherParser.OC_UpdatingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_oC_UpdatingClause)
        try:
            self.state = 327
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [54]:
                self.enterOuterAlt(localctx, 1)
                self.state = 322
                self.oC_Create()
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 2)
                self.state = 323
                self.oC_Merge()
                pass
            elif token in [56, 57]:
                self.enterOuterAlt(localctx, 3)
                self.state = 324
                self.oC_Delete()
                pass
            elif token in [55]:
                self.enterOuterAlt(localctx, 4)
                self.state = 325
                self.oC_Set()
                pass
            elif token in [58]:
                self.enterOuterAlt(localctx, 5)
                self.state = 326
                self.oC_Remove()
                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 OC_ReadingClauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Match(self):
            return self.getTypedRuleContext(CypherParser.OC_MatchContext,0)


        def oC_Unwind(self):
            return self.getTypedRuleContext(CypherParser.OC_UnwindContext,0)


        def oC_InQueryCall(self):
            return self.getTypedRuleContext(CypherParser.OC_InQueryCallContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ReadingClause

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

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

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




    def oC_ReadingClause(self):

        localctx = CypherParser.OC_ReadingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_oC_ReadingClause)
        try:
            self.state = 332
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [48, 49]:
                self.enterOuterAlt(localctx, 1)
                self.state = 329
                self.oC_Match()
                pass
            elif token in [50]:
                self.enterOuterAlt(localctx, 2)
                self.state = 330
                self.oC_Unwind()
                pass
            elif token in [59]:
                self.enterOuterAlt(localctx, 3)
                self.state = 331
                self.oC_InQueryCall()
                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 OC_MatchContext(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 oC_Pattern(self):
            return self.getTypedRuleContext(CypherParser.OC_PatternContext,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 oC_Where(self):
            return self.getTypedRuleContext(CypherParser.OC_WhereContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Match

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

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

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




    def oC_Match(self):

        localctx = CypherParser.OC_MatchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_oC_Match)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 336
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==48:
                self.state = 334
                self.match(CypherParser.OPTIONAL)
                self.state = 335
                self.match(CypherParser.SP)


            self.state = 338
            self.match(CypherParser.MATCH)
            self.state = 340
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 339
                self.match(CypherParser.SP)


            self.state = 342
            self.oC_Pattern()
            self.state = 347
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.state = 344
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 343
                    self.match(CypherParser.SP)


                self.state = 346
                self.oC_Where()


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


    class OC_UnwindContext(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 oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_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 AS(self):
            return self.getToken(CypherParser.AS, 0)

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Unwind

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

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

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




    def oC_Unwind(self):

        localctx = CypherParser.OC_UnwindContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_oC_Unwind)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 349
            self.match(CypherParser.UNWIND)
            self.state = 351
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 350
                self.match(CypherParser.SP)


            self.state = 353
            self.oC_Expression()
            self.state = 354
            self.match(CypherParser.SP)
            self.state = 355
            self.match(CypherParser.AS)
            self.state = 356
            self.match(CypherParser.SP)
            self.state = 357
            self.oC_Variable()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_MergeContext(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 oC_PatternPart(self):
            return self.getTypedRuleContext(CypherParser.OC_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 oC_MergeAction(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_MergeActionContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_MergeActionContext,i)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Merge

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

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

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




    def oC_Merge(self):

        localctx = CypherParser.OC_MergeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_oC_Merge)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 359
            self.match(CypherParser.MERGE)
            self.state = 361
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 360
                self.match(CypherParser.SP)


            self.state = 363
            self.oC_PatternPart()
            self.state = 368
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 364
                    self.match(CypherParser.SP)
                    self.state = 365
                    self.oC_MergeAction() 
                self.state = 370
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,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 OC_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 SP(self, i:int=None):
            if i is None:
                return self.getTokens(CypherParser.SP)
            else:
                return self.getToken(CypherParser.SP, i)

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

        def oC_Set(self):
            return self.getTypedRuleContext(CypherParser.OC_SetContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_MergeAction

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

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

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




    def oC_MergeAction(self):

        localctx = CypherParser.OC_MergeActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_oC_MergeAction)
        try:
            self.state = 381
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 371
                self.match(CypherParser.ON)
                self.state = 372
                self.match(CypherParser.SP)
                self.state = 373
                self.match(CypherParser.MATCH)
                self.state = 374
                self.match(CypherParser.SP)
                self.state = 375
                self.oC_Set()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 376
                self.match(CypherParser.ON)
                self.state = 377
                self.match(CypherParser.SP)
                self.state = 378
                self.match(CypherParser.CREATE)
                self.state = 379
                self.match(CypherParser.SP)
                self.state = 380
                self.oC_Set()
                pass


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


    class OC_CreateContext(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 oC_Pattern(self):
            return self.getTypedRuleContext(CypherParser.OC_PatternContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_Create

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

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

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




    def oC_Create(self):

        localctx = CypherParser.OC_CreateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_oC_Create)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 383
            self.match(CypherParser.CREATE)
            self.state = 385
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 384
                self.match(CypherParser.SP)


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


    class OC_SetContext(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 oC_SetItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_SetItemContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_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 getRuleIndex(self):
            return CypherParser.RULE_oC_Set

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

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

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




    def oC_Set(self):

        localctx = CypherParser.OC_SetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_oC_Set)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 389
            self.match(CypherParser.SET)
            self.state = 391
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 390
                self.match(CypherParser.SP)


            self.state = 393
            self.oC_SetItem()
            self.state = 404
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 395
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 394
                        self.match(CypherParser.SP)


                    self.state = 397
                    self.match(CypherParser.T__1)
                    self.state = 399
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 398
                        self.match(CypherParser.SP)


                    self.state = 401
                    self.oC_SetItem() 
                self.state = 406
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,40,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 OC_SetItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_PropertyExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_PropertyExpressionContext,0)


        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_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 oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def oC_NodeLabels(self):
            return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_SetItem

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

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

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




    def oC_SetItem(self):

        localctx = CypherParser.OC_SetItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_oC_SetItem)
        self._la = 0 # Token type
        try:
            self.state = 443
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 407
                self.oC_PropertyExpression()
                self.state = 409
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 408
                    self.match(CypherParser.SP)


                self.state = 411
                self.match(CypherParser.T__2)
                self.state = 413
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 412
                    self.match(CypherParser.SP)


                self.state = 415
                self.oC_Expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 417
                self.oC_Variable()
                self.state = 419
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 418
                    self.match(CypherParser.SP)


                self.state = 421
                self.match(CypherParser.T__2)
                self.state = 423
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 422
                    self.match(CypherParser.SP)


                self.state = 425
                self.oC_Expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 427
                self.oC_Variable()
                self.state = 429
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 428
                    self.match(CypherParser.SP)


                self.state = 431
                self.match(CypherParser.T__3)
                self.state = 433
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 432
                    self.match(CypherParser.SP)


                self.state = 435
                self.oC_Expression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 437
                self.oC_Variable()
                self.state = 439
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 438
                    self.match(CypherParser.SP)


                self.state = 441
                self.oC_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 OC_DeleteContext(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 oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_ExpressionContext,i)


        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_oC_Delete

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

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

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




    def oC_Delete(self):

        localctx = CypherParser.OC_DeleteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_oC_Delete)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==56:
                self.state = 445
                self.match(CypherParser.DETACH)
                self.state = 446
                self.match(CypherParser.SP)


            self.state = 449
            self.match(CypherParser.DELETE)
            self.state = 451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 450
                self.match(CypherParser.SP)


            self.state = 453
            self.oC_Expression()
            self.state = 464
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,53,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 455
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 454
                        self.match(CypherParser.SP)


                    self.state = 457
                    self.match(CypherParser.T__1)
                    self.state = 459
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 458
                        self.match(CypherParser.SP)


                    self.state = 461
                    self.oC_Expression() 
                self.state = 466
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,53,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 OC_RemoveContext(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 SP(self, i:int=None):
            if i is None:
                return self.getTokens(CypherParser.SP)
            else:
                return self.getToken(CypherParser.SP, i)

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Remove

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

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

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




    def oC_Remove(self):

        localctx = CypherParser.OC_RemoveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_oC_Remove)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 467
            self.match(CypherParser.REMOVE)
            self.state = 468
            self.match(CypherParser.SP)
            self.state = 469
            self.oC_RemoveItem()
            self.state = 480
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,56,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 471
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 470
                        self.match(CypherParser.SP)


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


                    self.state = 477
                    self.oC_RemoveItem() 
                self.state = 482
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,56,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 OC_RemoveItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def oC_NodeLabels(self):
            return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext,0)


        def oC_PropertyExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_PropertyExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_RemoveItem

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

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

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




    def oC_RemoveItem(self):

        localctx = CypherParser.OC_RemoveItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_oC_RemoveItem)
        try:
            self.state = 487
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 483
                self.oC_Variable()
                self.state = 484
                self.oC_NodeLabels()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 486
                self.oC_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 OC_InQueryCallContext(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 SP(self, i:int=None):
            if i is None:
                return self.getTokens(CypherParser.SP)
            else:
                return self.getToken(CypherParser.SP, i)

        def oC_ExplicitProcedureInvocation(self):
            return self.getTypedRuleContext(CypherParser.OC_ExplicitProcedureInvocationContext,0)


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

        def oC_YieldItems(self):
            return self.getTypedRuleContext(CypherParser.OC_YieldItemsContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_InQueryCall

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

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

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




    def oC_InQueryCall(self):

        localctx = CypherParser.OC_InQueryCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_oC_InQueryCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 489
            self.match(CypherParser.CALL)
            self.state = 490
            self.match(CypherParser.SP)
            self.state = 491
            self.oC_ExplicitProcedureInvocation()
            self.state = 498
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                self.state = 493
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 492
                    self.match(CypherParser.SP)


                self.state = 495
                self.match(CypherParser.YIELD)
                self.state = 496
                self.match(CypherParser.SP)
                self.state = 497
                self.oC_YieldItems()


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


    class OC_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 SP(self, i:int=None):
            if i is None:
                return self.getTokens(CypherParser.SP)
            else:
                return self.getToken(CypherParser.SP, i)

        def oC_ExplicitProcedureInvocation(self):
            return self.getTypedRuleContext(CypherParser.OC_ExplicitProcedureInvocationContext,0)


        def oC_ImplicitProcedureInvocation(self):
            return self.getTypedRuleContext(CypherParser.OC_ImplicitProcedureInvocationContext,0)


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

        def oC_YieldItems(self):
            return self.getTypedRuleContext(CypherParser.OC_YieldItemsContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_StandaloneCall

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

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

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




    def oC_StandaloneCall(self):

        localctx = CypherParser.OC_StandaloneCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_oC_StandaloneCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 500
            self.match(CypherParser.CALL)
            self.state = 501
            self.match(CypherParser.SP)
            self.state = 504
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
            if la_ == 1:
                self.state = 502
                self.oC_ExplicitProcedureInvocation()
                pass

            elif la_ == 2:
                self.state = 503
                self.oC_ImplicitProcedureInvocation()
                pass


            self.state = 515
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
            if la_ == 1:
                self.state = 507
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 506
                    self.match(CypherParser.SP)


                self.state = 509
                self.match(CypherParser.YIELD)
                self.state = 510
                self.match(CypherParser.SP)
                self.state = 513
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [5]:
                    self.state = 511
                    self.match(CypherParser.T__4)
                    pass
                elif token in [83, 89, 90, 91, 99, 120, 121, 122, 125]:
                    self.state = 512
                    self.oC_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 OC_YieldItemsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def oC_Where(self):
            return self.getTypedRuleContext(CypherParser.OC_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_oC_YieldItems

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

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

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




    def oC_YieldItems(self):

        localctx = CypherParser.OC_YieldItemsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_oC_YieldItems)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 517
            self.oC_YieldItem()
            self.state = 528
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,66,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 519
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 518
                        self.match(CypherParser.SP)


                    self.state = 521
                    self.match(CypherParser.T__1)
                    self.state = 523
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 522
                        self.match(CypherParser.SP)


                    self.state = 525
                    self.oC_YieldItem() 
                self.state = 530
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,self._ctx)

            self.state = 535
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
            if la_ == 1:
                self.state = 532
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 531
                    self.match(CypherParser.SP)


                self.state = 534
                self.oC_Where()


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


    class OC_YieldItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def oC_ProcedureResultField(self):
            return self.getTypedRuleContext(CypherParser.OC_ProcedureResultFieldContext,0)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_YieldItem

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

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

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




    def oC_YieldItem(self):

        localctx = CypherParser.OC_YieldItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_oC_YieldItem)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 542
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.state = 537
                self.oC_ProcedureResultField()
                self.state = 538
                self.match(CypherParser.SP)
                self.state = 539
                self.match(CypherParser.AS)
                self.state = 540
                self.match(CypherParser.SP)


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


    class OC_WithContext(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 oC_ProjectionBody(self):
            return self.getTypedRuleContext(CypherParser.OC_ProjectionBodyContext,0)


        def oC_Where(self):
            return self.getTypedRuleContext(CypherParser.OC_WhereContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_With

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

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

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




    def oC_With(self):

        localctx = CypherParser.OC_WithContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_oC_With)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            self.match(CypherParser.WITH)
            self.state = 547
            self.oC_ProjectionBody()
            self.state = 552
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 549
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 548
                    self.match(CypherParser.SP)


                self.state = 551
                self.oC_Where()


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


    class OC_ReturnContext(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 oC_ProjectionBody(self):
            return self.getTypedRuleContext(CypherParser.OC_ProjectionBodyContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Return

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

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

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




    def oC_Return(self):

        localctx = CypherParser.OC_ReturnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_oC_Return)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 554
            self.match(CypherParser.RETURN)
            self.state = 555
            self.oC_ProjectionBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ProjectionBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def oC_ProjectionItems(self):
            return self.getTypedRuleContext(CypherParser.OC_ProjectionItemsContext,0)


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

        def oC_Order(self):
            return self.getTypedRuleContext(CypherParser.OC_OrderContext,0)


        def oC_Skip(self):
            return self.getTypedRuleContext(CypherParser.OC_SkipContext,0)


        def oC_Limit(self):
            return self.getTypedRuleContext(CypherParser.OC_LimitContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ProjectionBody

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

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

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




    def oC_ProjectionBody(self):

        localctx = CypherParser.OC_ProjectionBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_oC_ProjectionBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 561
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.state = 558
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 557
                    self.match(CypherParser.SP)


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


            self.state = 563
            self.match(CypherParser.SP)
            self.state = 564
            self.oC_ProjectionItems()
            self.state = 567
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.state = 565
                self.match(CypherParser.SP)
                self.state = 566
                self.oC_Order()


            self.state = 571
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 569
                self.match(CypherParser.SP)
                self.state = 570
                self.oC_Skip()


            self.state = 575
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 573
                self.match(CypherParser.SP)
                self.state = 574
                self.oC_Limit()


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


    class OC_ProjectionItemsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_ProjectionItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_ProjectionItemContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_ProjectionItemContext,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_oC_ProjectionItems

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

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

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




    def oC_ProjectionItems(self):

        localctx = CypherParser.OC_ProjectionItemsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_oC_ProjectionItems)
        self._la = 0 # Token type
        try:
            self.state = 605
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 577
                self.match(CypherParser.T__4)
                self.state = 588
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,79,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 579
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 578
                            self.match(CypherParser.SP)


                        self.state = 581
                        self.match(CypherParser.T__1)
                        self.state = 583
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 582
                            self.match(CypherParser.SP)


                        self.state = 585
                        self.oC_ProjectionItem() 
                    self.state = 590
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,79,self._ctx)

                pass
            elif token in [6, 8, 18, 19, 24, 26, 47, 76, 82, 83, 84, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 106, 107, 108, 120, 121, 122, 125]:
                self.enterOuterAlt(localctx, 2)
                self.state = 591
                self.oC_ProjectionItem()
                self.state = 602
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,82,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 593
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 592
                            self.match(CypherParser.SP)


                        self.state = 595
                        self.match(CypherParser.T__1)
                        self.state = 597
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 596
                            self.match(CypherParser.SP)


                        self.state = 599
                        self.oC_ProjectionItem() 
                    self.state = 604
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,82,self._ctx)

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

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

        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_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 AS(self):
            return self.getToken(CypherParser.AS, 0)

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ProjectionItem

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

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

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




    def oC_ProjectionItem(self):

        localctx = CypherParser.OC_ProjectionItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_oC_ProjectionItem)
        try:
            self.state = 614
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 607
                self.oC_Expression()
                self.state = 608
                self.match(CypherParser.SP)
                self.state = 609
                self.match(CypherParser.AS)
                self.state = 610
                self.match(CypherParser.SP)
                self.state = 611
                self.oC_Variable()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 613
                self.oC_Expression()
                pass


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


    class OC_OrderContext(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 SP(self, i:int=None):
            if i is None:
                return self.getTokens(CypherParser.SP)
            else:
                return self.getToken(CypherParser.SP, i)

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Order

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

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

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




    def oC_Order(self):

        localctx = CypherParser.OC_OrderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_oC_Order)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 616
            self.match(CypherParser.ORDER)
            self.state = 617
            self.match(CypherParser.SP)
            self.state = 618
            self.match(CypherParser.BY)
            self.state = 619
            self.match(CypherParser.SP)
            self.state = 620
            self.oC_SortItem()
            self.state = 628
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 621
                self.match(CypherParser.T__1)
                self.state = 623
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 622
                    self.match(CypherParser.SP)


                self.state = 625
                self.oC_SortItem()
                self.state = 630
                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 OC_SkipContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Skip

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

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

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




    def oC_Skip(self):

        localctx = CypherParser.OC_SkipContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_oC_Skip)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 631
            self.match(CypherParser.L_SKIP)
            self.state = 632
            self.match(CypherParser.SP)
            self.state = 633
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_LimitContext(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 SP(self):
            return self.getToken(CypherParser.SP, 0)

        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Limit

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

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

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




    def oC_Limit(self):

        localctx = CypherParser.OC_LimitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_oC_Limit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 635
            self.match(CypherParser.LIMIT)
            self.state = 636
            self.match(CypherParser.SP)
            self.state = 637
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SortItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_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_oC_SortItem

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

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

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




    def oC_SortItem(self):

        localctx = CypherParser.OC_SortItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_oC_SortItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 639
            self.oC_Expression()
            self.state = 644
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
            if la_ == 1:
                self.state = 641
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 640
                    self.match(CypherParser.SP)


                self.state = 643
                _la = self._input.LA(1)
                if not(((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 15) != 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 OC_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 SP(self):
            return self.getToken(CypherParser.SP, 0)

        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Where

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

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

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




    def oC_Where(self):

        localctx = CypherParser.OC_WhereContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_oC_Where)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 646
            self.match(CypherParser.WHERE)
            self.state = 647
            self.match(CypherParser.SP)
            self.state = 648
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_PatternPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_PatternPartContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_PatternPartContext,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_oC_Pattern

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

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

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




    def oC_Pattern(self):

        localctx = CypherParser.OC_PatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_oC_Pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 650
            self.oC_PatternPart()
            self.state = 661
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,91,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 652
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 651
                        self.match(CypherParser.SP)


                    self.state = 654
                    self.match(CypherParser.T__1)
                    self.state = 656
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 655
                        self.match(CypherParser.SP)


                    self.state = 658
                    self.oC_PatternPart() 
                self.state = 663
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,91,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 OC_PatternPartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def oC_AnonymousPatternPart(self):
            return self.getTypedRuleContext(CypherParser.OC_AnonymousPatternPartContext,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_oC_PatternPart

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

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

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




    def oC_PatternPart(self):

        localctx = CypherParser.OC_PatternPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_oC_PatternPart)
        self._la = 0 # Token type
        try:
            self.state = 675
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [83, 89, 90, 91, 99, 120, 121, 122, 125]:
                self.enterOuterAlt(localctx, 1)
                self.state = 664
                self.oC_Variable()
                self.state = 666
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 665
                    self.match(CypherParser.SP)


                self.state = 668
                self.match(CypherParser.T__2)
                self.state = 670
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 669
                    self.match(CypherParser.SP)


                self.state = 672
                self.oC_AnonymousPatternPart()
                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 2)
                self.state = 674
                self.oC_AnonymousPatternPart()
                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 OC_AnonymousPatternPartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_PatternElement(self):
            return self.getTypedRuleContext(CypherParser.OC_PatternElementContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_AnonymousPatternPart

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

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

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




    def oC_AnonymousPatternPart(self):

        localctx = CypherParser.OC_AnonymousPatternPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_oC_AnonymousPatternPart)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 677
            self.oC_PatternElement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PatternElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_NodePattern(self):
            return self.getTypedRuleContext(CypherParser.OC_NodePatternContext,0)


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


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

        def oC_PatternElement(self):
            return self.getTypedRuleContext(CypherParser.OC_PatternElementContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_PatternElement

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

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

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




    def oC_PatternElement(self):

        localctx = CypherParser.OC_PatternElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_oC_PatternElement)
        self._la = 0 # Token type
        try:
            self.state = 693
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 679
                self.oC_NodePattern()
                self.state = 686
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,96,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 681
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 680
                            self.match(CypherParser.SP)


                        self.state = 683
                        self.oC_PatternElementChain() 
                    self.state = 688
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,96,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 689
                self.match(CypherParser.T__5)
                self.state = 690
                self.oC_PatternElement()
                self.state = 691
                self.match(CypherParser.T__6)
                pass


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


    class OC_RelationshipsPatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_NodePattern(self):
            return self.getTypedRuleContext(CypherParser.OC_NodePatternContext,0)


        def oC_PatternElementChain(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_PatternElementChainContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_PatternElementChainContext,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_oC_RelationshipsPattern

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

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

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




    def oC_RelationshipsPattern(self):

        localctx = CypherParser.OC_RelationshipsPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_oC_RelationshipsPattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 695
            self.oC_NodePattern()
            self.state = 700 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 697
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 696
                        self.match(CypherParser.SP)


                    self.state = 699
                    self.oC_PatternElementChain()

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

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

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

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def oC_NodeLabels(self):
            return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext,0)


        def oC_Properties(self):
            return self.getTypedRuleContext(CypherParser.OC_PropertiesContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_NodePattern

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

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

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




    def oC_NodePattern(self):

        localctx = CypherParser.OC_NodePatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_oC_NodePattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 704
            self.match(CypherParser.T__5)
            self.state = 706
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 705
                self.match(CypherParser.SP)


            self.state = 712
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & 5360119251393) != 0):
                self.state = 708
                self.oC_Variable()
                self.state = 710
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 709
                    self.match(CypherParser.SP)




            self.state = 718
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10:
                self.state = 714
                self.oC_NodeLabels()
                self.state = 716
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 715
                    self.match(CypherParser.SP)




            self.state = 724
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==24 or _la==26:
                self.state = 720
                self.oC_Properties()
                self.state = 722
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 721
                    self.match(CypherParser.SP)




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


    class OC_PatternElementChainContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_RelationshipPattern(self):
            return self.getTypedRuleContext(CypherParser.OC_RelationshipPatternContext,0)


        def oC_NodePattern(self):
            return self.getTypedRuleContext(CypherParser.OC_NodePatternContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_PatternElementChain

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

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

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




    def oC_PatternElementChain(self):

        localctx = CypherParser.OC_PatternElementChainContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_oC_PatternElementChain)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self.oC_RelationshipPattern()
            self.state = 730
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 729
                self.match(CypherParser.SP)


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


    class OC_RelationshipPatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_LeftArrowHead(self):
            return self.getTypedRuleContext(CypherParser.OC_LeftArrowHeadContext,0)


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


        def oC_RightArrowHead(self):
            return self.getTypedRuleContext(CypherParser.OC_RightArrowHeadContext,0)


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

        def oC_RelationshipDetail(self):
            return self.getTypedRuleContext(CypherParser.OC_RelationshipDetailContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_RelationshipPattern

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

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

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




    def oC_RelationshipPattern(self):

        localctx = CypherParser.OC_RelationshipPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_oC_RelationshipPattern)
        self._la = 0 # Token type
        try:
            self.state = 798
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 734
                self.oC_LeftArrowHead()
                self.state = 736
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 735
                    self.match(CypherParser.SP)


                self.state = 738
                self.oC_Dash()
                self.state = 740
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
                if la_ == 1:
                    self.state = 739
                    self.match(CypherParser.SP)


                self.state = 743
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 742
                    self.oC_RelationshipDetail()


                self.state = 746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 745
                    self.match(CypherParser.SP)


                self.state = 748
                self.oC_Dash()
                self.state = 750
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 749
                    self.match(CypherParser.SP)


                self.state = 752
                self.oC_RightArrowHead()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 754
                self.oC_LeftArrowHead()
                self.state = 756
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 755
                    self.match(CypherParser.SP)


                self.state = 758
                self.oC_Dash()
                self.state = 760
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
                if la_ == 1:
                    self.state = 759
                    self.match(CypherParser.SP)


                self.state = 763
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 762
                    self.oC_RelationshipDetail()


                self.state = 766
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 765
                    self.match(CypherParser.SP)


                self.state = 768
                self.oC_Dash()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 770
                self.oC_Dash()
                self.state = 772
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                if la_ == 1:
                    self.state = 771
                    self.match(CypherParser.SP)


                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 774
                    self.oC_RelationshipDetail()


                self.state = 778
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 777
                    self.match(CypherParser.SP)


                self.state = 780
                self.oC_Dash()
                self.state = 782
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 781
                    self.match(CypherParser.SP)


                self.state = 784
                self.oC_RightArrowHead()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 786
                self.oC_Dash()
                self.state = 788
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
                if la_ == 1:
                    self.state = 787
                    self.match(CypherParser.SP)


                self.state = 791
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 790
                    self.oC_RelationshipDetail()


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


                self.state = 796
                self.oC_Dash()
                pass


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


    class OC_RelationshipDetailContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def oC_RelationshipTypes(self):
            return self.getTypedRuleContext(CypherParser.OC_RelationshipTypesContext,0)


        def oC_RangeLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_RangeLiteralContext,0)


        def oC_Properties(self):
            return self.getTypedRuleContext(CypherParser.OC_PropertiesContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_RelationshipDetail

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

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

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




    def oC_RelationshipDetail(self):

        localctx = CypherParser.OC_RelationshipDetailContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_oC_RelationshipDetail)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 800
            self.match(CypherParser.T__7)
            self.state = 802
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 801
                self.match(CypherParser.SP)


            self.state = 808
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & 5360119251393) != 0):
                self.state = 804
                self.oC_Variable()
                self.state = 806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 805
                    self.match(CypherParser.SP)




            self.state = 814
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10:
                self.state = 810
                self.oC_RelationshipTypes()
                self.state = 812
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 811
                    self.match(CypherParser.SP)




            self.state = 817
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==5:
                self.state = 816
                self.oC_RangeLiteral()


            self.state = 823
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==24 or _la==26:
                self.state = 819
                self.oC_Properties()
                self.state = 821
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 820
                    self.match(CypherParser.SP)




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


    class OC_PropertiesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_MapLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_MapLiteralContext,0)


        def oC_Parameter(self):
            return self.getTypedRuleContext(CypherParser.OC_ParameterContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Properties

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

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

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




    def oC_Properties(self):

        localctx = CypherParser.OC_PropertiesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_oC_Properties)
        try:
            self.state = 829
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [24]:
                self.enterOuterAlt(localctx, 1)
                self.state = 827
                self.oC_MapLiteral()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 2)
                self.state = 828
                self.oC_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 OC_RelationshipTypesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_RelTypeName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_RelTypeNameContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_RelTypeNameContext,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_oC_RelationshipTypes

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

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

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




    def oC_RelationshipTypes(self):

        localctx = CypherParser.OC_RelationshipTypesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_oC_RelationshipTypes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 831
            self.match(CypherParser.T__9)
            self.state = 833
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 832
                self.match(CypherParser.SP)


            self.state = 835
            self.oC_RelTypeName()
            self.state = 849
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,138,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 837
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 836
                        self.match(CypherParser.SP)


                    self.state = 839
                    self.match(CypherParser.T__10)
                    self.state = 841
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==10:
                        self.state = 840
                        self.match(CypherParser.T__9)


                    self.state = 844
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 843
                        self.match(CypherParser.SP)


                    self.state = 846
                    self.oC_RelTypeName() 
                self.state = 851
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,138,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 OC_NodeLabelsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_NodeLabel(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_NodeLabelContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_NodeLabelContext,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_oC_NodeLabels

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

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

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




    def oC_NodeLabels(self):

        localctx = CypherParser.OC_NodeLabelsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_oC_NodeLabels)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 852
            self.oC_NodeLabel()
            self.state = 859
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,140,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 854
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 853
                        self.match(CypherParser.SP)


                    self.state = 856
                    self.oC_NodeLabel() 
                self.state = 861
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,140,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 OC_NodeLabelContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_LabelName(self):
            return self.getTypedRuleContext(CypherParser.OC_LabelNameContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_NodeLabel

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

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

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




    def oC_NodeLabel(self):

        localctx = CypherParser.OC_NodeLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_oC_NodeLabel)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 862
            self.match(CypherParser.T__9)
            self.state = 864
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 863
                self.match(CypherParser.SP)


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


    class OC_RangeLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_RangeLiteral

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

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

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




    def oC_RangeLiteral(self):

        localctx = CypherParser.OC_RangeLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_oC_RangeLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 868
            self.match(CypherParser.T__4)
            self.state = 870
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 869
                self.match(CypherParser.SP)


            self.state = 876
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & 7) != 0):
                self.state = 872
                self.oC_IntegerLiteral()
                self.state = 874
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 873
                    self.match(CypherParser.SP)




            self.state = 888
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==12:
                self.state = 878
                self.match(CypherParser.T__11)
                self.state = 880
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 879
                    self.match(CypherParser.SP)


                self.state = 886
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & 7) != 0):
                    self.state = 882
                    self.oC_IntegerLiteral()
                    self.state = 884
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 883
                        self.match(CypherParser.SP)






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


    class OC_LabelNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SchemaName(self):
            return self.getTypedRuleContext(CypherParser.OC_SchemaNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_LabelName

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

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

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




    def oC_LabelName(self):

        localctx = CypherParser.OC_LabelNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_oC_LabelName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 890
            self.oC_SchemaName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RelTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SchemaName(self):
            return self.getTypedRuleContext(CypherParser.OC_SchemaNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_RelTypeName

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

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

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




    def oC_RelTypeName(self):

        localctx = CypherParser.OC_RelTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_oC_RelTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 892
            self.oC_SchemaName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PropertyExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Atom(self):
            return self.getTypedRuleContext(CypherParser.OC_AtomContext,0)


        def oC_PropertyLookup(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_PropertyLookupContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_PropertyLookupContext,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_oC_PropertyExpression

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

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

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




    def oC_PropertyExpression(self):

        localctx = CypherParser.OC_PropertyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_oC_PropertyExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 894
            self.oC_Atom()
            self.state = 899 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 896
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 895
                        self.match(CypherParser.SP)


                    self.state = 898
                    self.oC_PropertyLookup()

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

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

        def oC_OrExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_OrExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Expression

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

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

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




    def oC_Expression(self):

        localctx = CypherParser.OC_ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_oC_Expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 903
            self.oC_OrExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_OrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_OrExpression

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

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

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




    def oC_OrExpression(self):

        localctx = CypherParser.OC_OrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_oC_OrExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 905
            self.oC_XorExpression()
            self.state = 912
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,151,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 906
                    self.match(CypherParser.SP)
                    self.state = 907
                    self.match(CypherParser.OR)
                    self.state = 908
                    self.match(CypherParser.SP)
                    self.state = 909
                    self.oC_XorExpression() 
                self.state = 914
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,151,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 OC_XorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_XorExpression

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

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

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




    def oC_XorExpression(self):

        localctx = CypherParser.OC_XorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_oC_XorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 915
            self.oC_AndExpression()
            self.state = 922
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,152,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 916
                    self.match(CypherParser.SP)
                    self.state = 917
                    self.match(CypherParser.XOR)
                    self.state = 918
                    self.match(CypherParser.SP)
                    self.state = 919
                    self.oC_AndExpression() 
                self.state = 924
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,152,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 OC_AndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_AndExpression

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

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

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




    def oC_AndExpression(self):

        localctx = CypherParser.OC_AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_oC_AndExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 925
            self.oC_NotExpression()
            self.state = 932
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,153,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 926
                    self.match(CypherParser.SP)
                    self.state = 927
                    self.match(CypherParser.AND)
                    self.state = 928
                    self.match(CypherParser.SP)
                    self.state = 929
                    self.oC_NotExpression() 
                self.state = 934
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,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 OC_NotExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_ComparisonExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_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_oC_NotExpression

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

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

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




    def oC_NotExpression(self):

        localctx = CypherParser.OC_NotExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_oC_NotExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 941
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==76:
                self.state = 935
                self.match(CypherParser.NOT)
                self.state = 937
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 936
                    self.match(CypherParser.SP)


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

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


    class OC_ComparisonExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_StringListNullPredicateExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_StringListNullPredicateExpressionContext,0)


        def oC_PartialComparisonExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_PartialComparisonExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_PartialComparisonExpressionContext,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_oC_ComparisonExpression

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

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

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




    def oC_ComparisonExpression(self):

        localctx = CypherParser.OC_ComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_oC_ComparisonExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 946
            self.oC_StringListNullPredicateExpression()
            self.state = 953
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,157,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 948
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 947
                        self.match(CypherParser.SP)


                    self.state = 950
                    self.oC_PartialComparisonExpression() 
                self.state = 955
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,157,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 OC_PartialComparisonExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_StringListNullPredicateExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_StringListNullPredicateExpressionContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_PartialComparisonExpression

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

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

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




    def oC_PartialComparisonExpression(self):

        localctx = CypherParser.OC_PartialComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_oC_PartialComparisonExpression)
        self._la = 0 # Token type
        try:
            self.state = 986
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3]:
                self.enterOuterAlt(localctx, 1)
                self.state = 956
                self.match(CypherParser.T__2)
                self.state = 958
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 957
                    self.match(CypherParser.SP)


                self.state = 960
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [13]:
                self.enterOuterAlt(localctx, 2)
                self.state = 961
                self.match(CypherParser.T__12)
                self.state = 963
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 962
                    self.match(CypherParser.SP)


                self.state = 965
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 3)
                self.state = 966
                self.match(CypherParser.T__13)
                self.state = 968
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 967
                    self.match(CypherParser.SP)


                self.state = 970
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 4)
                self.state = 971
                self.match(CypherParser.T__14)
                self.state = 973
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 972
                    self.match(CypherParser.SP)


                self.state = 975
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [16]:
                self.enterOuterAlt(localctx, 5)
                self.state = 976
                self.match(CypherParser.T__15)
                self.state = 978
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 977
                    self.match(CypherParser.SP)


                self.state = 980
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 6)
                self.state = 981
                self.match(CypherParser.T__16)
                self.state = 983
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 982
                    self.match(CypherParser.SP)


                self.state = 985
                self.oC_StringListNullPredicateExpression()
                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 OC_StringListNullPredicateExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_AddOrSubtractExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_AddOrSubtractExpressionContext,0)


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


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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_StringListNullPredicateExpression

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

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

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




    def oC_StringListNullPredicateExpression(self):

        localctx = CypherParser.OC_StringListNullPredicateExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_oC_StringListNullPredicateExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 988
            self.oC_AddOrSubtractExpression()
            self.state = 994
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,166,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 992
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
                    if la_ == 1:
                        self.state = 989
                        self.oC_StringPredicateExpression()
                        pass

                    elif la_ == 2:
                        self.state = 990
                        self.oC_ListPredicateExpression()
                        pass

                    elif la_ == 3:
                        self.state = 991
                        self.oC_NullPredicateExpression()
                        pass

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

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

        def oC_AddOrSubtractExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_AddOrSubtractExpressionContext,0)


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

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

        def WITH(self):
            return self.getToken(CypherParser.WITH, 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_oC_StringPredicateExpression

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

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

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




    def oC_StringPredicateExpression(self):

        localctx = CypherParser.OC_StringPredicateExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_oC_StringPredicateExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1007
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
            if la_ == 1:
                self.state = 997
                self.match(CypherParser.SP)
                self.state = 998
                self.match(CypherParser.STARTS)
                self.state = 999
                self.match(CypherParser.SP)
                self.state = 1000
                self.match(CypherParser.WITH)
                pass

            elif la_ == 2:
                self.state = 1001
                self.match(CypherParser.SP)
                self.state = 1002
                self.match(CypherParser.ENDS)
                self.state = 1003
                self.match(CypherParser.SP)
                self.state = 1004
                self.match(CypherParser.WITH)
                pass

            elif la_ == 3:
                self.state = 1005
                self.match(CypherParser.SP)
                self.state = 1006
                self.match(CypherParser.CONTAINS)
                pass


            self.state = 1010
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1009
                self.match(CypherParser.SP)


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


    class OC_ListPredicateExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def oC_AddOrSubtractExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_AddOrSubtractExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ListPredicateExpression

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

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

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




    def oC_ListPredicateExpression(self):

        localctx = CypherParser.OC_ListPredicateExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_oC_ListPredicateExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1014
            self.match(CypherParser.SP)
            self.state = 1015
            self.match(CypherParser.IN)
            self.state = 1017
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1016
                self.match(CypherParser.SP)


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


    class OC_NullPredicateExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_NullPredicateExpression

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

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

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




    def oC_NullPredicateExpression(self):

        localctx = CypherParser.OC_NullPredicateExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_oC_NullPredicateExpression)
        try:
            self.state = 1031
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,170,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1021
                self.match(CypherParser.SP)
                self.state = 1022
                self.match(CypherParser.IS)
                self.state = 1023
                self.match(CypherParser.SP)
                self.state = 1024
                self.match(CypherParser.NULL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1025
                self.match(CypherParser.SP)
                self.state = 1026
                self.match(CypherParser.IS)
                self.state = 1027
                self.match(CypherParser.SP)
                self.state = 1028
                self.match(CypherParser.NOT)
                self.state = 1029
                self.match(CypherParser.SP)
                self.state = 1030
                self.match(CypherParser.NULL)
                pass


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


    class OC_AddOrSubtractExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_MultiplyDivideModuloExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_MultiplyDivideModuloExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_MultiplyDivideModuloExpressionContext,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_oC_AddOrSubtractExpression

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

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

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




    def oC_AddOrSubtractExpression(self):

        localctx = CypherParser.OC_AddOrSubtractExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_oC_AddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1033
            self.oC_MultiplyDivideModuloExpression()
            self.state = 1052
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,176,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1050
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
                    if la_ == 1:
                        self.state = 1035
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1034
                            self.match(CypherParser.SP)


                        self.state = 1037
                        self.match(CypherParser.T__17)
                        self.state = 1039
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1038
                            self.match(CypherParser.SP)


                        self.state = 1041
                        self.oC_MultiplyDivideModuloExpression()
                        pass

                    elif la_ == 2:
                        self.state = 1043
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1042
                            self.match(CypherParser.SP)


                        self.state = 1045
                        self.match(CypherParser.T__18)
                        self.state = 1047
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1046
                            self.match(CypherParser.SP)


                        self.state = 1049
                        self.oC_MultiplyDivideModuloExpression()
                        pass

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

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

        def oC_PowerOfExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_PowerOfExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_PowerOfExpressionContext,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_oC_MultiplyDivideModuloExpression

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

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

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




    def oC_MultiplyDivideModuloExpression(self):

        localctx = CypherParser.OC_MultiplyDivideModuloExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_oC_MultiplyDivideModuloExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1055
            self.oC_PowerOfExpression()
            self.state = 1082
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,184,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1080
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
                    if la_ == 1:
                        self.state = 1057
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1056
                            self.match(CypherParser.SP)


                        self.state = 1059
                        self.match(CypherParser.T__4)
                        self.state = 1061
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1060
                            self.match(CypherParser.SP)


                        self.state = 1063
                        self.oC_PowerOfExpression()
                        pass

                    elif la_ == 2:
                        self.state = 1065
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1064
                            self.match(CypherParser.SP)


                        self.state = 1067
                        self.match(CypherParser.T__19)
                        self.state = 1069
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1068
                            self.match(CypherParser.SP)


                        self.state = 1071
                        self.oC_PowerOfExpression()
                        pass

                    elif la_ == 3:
                        self.state = 1073
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1072
                            self.match(CypherParser.SP)


                        self.state = 1075
                        self.match(CypherParser.T__20)
                        self.state = 1077
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1076
                            self.match(CypherParser.SP)


                        self.state = 1079
                        self.oC_PowerOfExpression()
                        pass

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

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

        def oC_UnaryAddOrSubtractExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_UnaryAddOrSubtractExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_UnaryAddOrSubtractExpressionContext,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_oC_PowerOfExpression

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

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

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




    def oC_PowerOfExpression(self):

        localctx = CypherParser.OC_PowerOfExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_oC_PowerOfExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1085
            self.oC_UnaryAddOrSubtractExpression()
            self.state = 1096
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,187,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1087
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1086
                        self.match(CypherParser.SP)


                    self.state = 1089
                    self.match(CypherParser.T__21)
                    self.state = 1091
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1090
                        self.match(CypherParser.SP)


                    self.state = 1093
                    self.oC_UnaryAddOrSubtractExpression() 
                self.state = 1098
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,187,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 OC_UnaryAddOrSubtractExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_NonArithmeticOperatorExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_NonArithmeticOperatorExpressionContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_UnaryAddOrSubtractExpression

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

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

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




    def oC_UnaryAddOrSubtractExpression(self):

        localctx = CypherParser.OC_UnaryAddOrSubtractExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_oC_UnaryAddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.state = 1105
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [6, 8, 24, 26, 47, 82, 83, 84, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 106, 107, 108, 120, 121, 122, 125]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1099
                self.oC_NonArithmeticOperatorExpression()
                pass
            elif token in [18, 19]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1100
                _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 = 1102
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1101
                    self.match(CypherParser.SP)


                self.state = 1104
                self.oC_NonArithmeticOperatorExpression()
                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 OC_NonArithmeticOperatorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Atom(self):
            return self.getTypedRuleContext(CypherParser.OC_AtomContext,0)


        def oC_NodeLabels(self):
            return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext,0)


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


        def oC_PropertyLookup(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_PropertyLookupContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_PropertyLookupContext,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_oC_NonArithmeticOperatorExpression

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

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

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




    def oC_NonArithmeticOperatorExpression(self):

        localctx = CypherParser.OC_NonArithmeticOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_oC_NonArithmeticOperatorExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1107
            self.oC_Atom()
            self.state = 1118
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,193,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1116
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,192,self._ctx)
                    if la_ == 1:
                        self.state = 1109
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1108
                            self.match(CypherParser.SP)


                        self.state = 1111
                        self.oC_ListOperatorExpression()
                        pass

                    elif la_ == 2:
                        self.state = 1113
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1112
                            self.match(CypherParser.SP)


                        self.state = 1115
                        self.oC_PropertyLookup()
                        pass

             
                self.state = 1120
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,193,self._ctx)

            self.state = 1125
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
            if la_ == 1:
                self.state = 1122
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1121
                    self.match(CypherParser.SP)


                self.state = 1124
                self.oC_NodeLabels()


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


    class OC_ListOperatorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ListOperatorExpression

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

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

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




    def oC_ListOperatorExpression(self):

        localctx = CypherParser.OC_ListOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_oC_ListOperatorExpression)
        self._la = 0 # Token type
        try:
            self.state = 1140
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1127
                self.match(CypherParser.T__7)
                self.state = 1128
                self.oC_Expression()
                self.state = 1129
                self.match(CypherParser.T__8)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1131
                self.match(CypherParser.T__7)
                self.state = 1133
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 140737573028160) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & 686102788694465) != 0):
                    self.state = 1132
                    self.oC_Expression()


                self.state = 1135
                self.match(CypherParser.T__11)
                self.state = 1137
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 140737573028160) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & 686102788694465) != 0):
                    self.state = 1136
                    self.oC_Expression()


                self.state = 1139
                self.match(CypherParser.T__8)
                pass


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


    class OC_PropertyLookupContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_PropertyKeyName(self):
            return self.getTypedRuleContext(CypherParser.OC_PropertyKeyNameContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_PropertyLookup

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

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

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




    def oC_PropertyLookup(self):

        localctx = CypherParser.OC_PropertyLookupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_oC_PropertyLookup)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1142
            self.match(CypherParser.T__22)
            self.state = 1144
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1143
                self.match(CypherParser.SP)


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


    class OC_AtomContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Literal(self):
            return self.getTypedRuleContext(CypherParser.OC_LiteralContext,0)


        def oC_Parameter(self):
            return self.getTypedRuleContext(CypherParser.OC_ParameterContext,0)


        def oC_CaseExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_CaseExpressionContext,0)


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

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

        def oC_ListComprehension(self):
            return self.getTypedRuleContext(CypherParser.OC_ListComprehensionContext,0)


        def oC_PatternComprehension(self):
            return self.getTypedRuleContext(CypherParser.OC_PatternComprehensionContext,0)


        def oC_Quantifier(self):
            return self.getTypedRuleContext(CypherParser.OC_QuantifierContext,0)


        def oC_Reduce(self):
            return self.getTypedRuleContext(CypherParser.OC_ReduceContext,0)


        def oC_PatternPredicate(self):
            return self.getTypedRuleContext(CypherParser.OC_PatternPredicateContext,0)


        def oC_ParenthesizedExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_ParenthesizedExpressionContext,0)


        def oC_FunctionInvocation(self):
            return self.getTypedRuleContext(CypherParser.OC_FunctionInvocationContext,0)


        def oC_ExistentialSubquery(self):
            return self.getTypedRuleContext(CypherParser.OC_ExistentialSubqueryContext,0)


        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Atom

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

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

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




    def oC_Atom(self):

        localctx = CypherParser.OC_AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_oC_Atom)
        self._la = 0 # Token type
        try:
            self.state = 1173
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1148
                self.oC_Literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1149
                self.oC_Parameter()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1150
                self.oC_CaseExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1151
                self.match(CypherParser.COUNT)
                self.state = 1153
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1152
                    self.match(CypherParser.SP)


                self.state = 1155
                self.match(CypherParser.T__5)
                self.state = 1157
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1156
                    self.match(CypherParser.SP)


                self.state = 1159
                self.match(CypherParser.T__4)
                self.state = 1161
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1160
                    self.match(CypherParser.SP)


                self.state = 1163
                self.match(CypherParser.T__6)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1164
                self.oC_ListComprehension()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1165
                self.oC_PatternComprehension()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1166
                self.oC_Quantifier()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1167
                self.oC_Reduce()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1168
                self.oC_PatternPredicate()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1169
                self.oC_ParenthesizedExpression()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1170
                self.oC_FunctionInvocation()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1171
                self.oC_ExistentialSubquery()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1172
                self.oC_Variable()
                pass


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


    class OC_CaseExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_CaseExpression

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

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

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




    def oC_CaseExpression(self):

        localctx = CypherParser.OC_CaseExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_oC_CaseExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1197
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
            if la_ == 1:
                self.state = 1175
                self.match(CypherParser.CASE)
                self.state = 1180 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1177
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1176
                            self.match(CypherParser.SP)


                        self.state = 1179
                        self.oC_CaseAlternative()

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

                pass

            elif la_ == 2:
                self.state = 1184
                self.match(CypherParser.CASE)
                self.state = 1186
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1185
                    self.match(CypherParser.SP)


                self.state = 1188
                self.oC_Expression()
                self.state = 1193 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1190
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==126:
                            self.state = 1189
                            self.match(CypherParser.SP)


                        self.state = 1192
                        self.oC_CaseAlternative()

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

                pass


            self.state = 1207
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
            if la_ == 1:
                self.state = 1200
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1199
                    self.match(CypherParser.SP)


                self.state = 1202
                self.match(CypherParser.ELSE)
                self.state = 1204
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1203
                    self.match(CypherParser.SP)


                self.state = 1206
                self.oC_Expression()


            self.state = 1210
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1209
                self.match(CypherParser.SP)


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

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

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

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


        def THEN(self):
            return self.getToken(CypherParser.THEN, 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_oC_CaseAlternative

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

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

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




    def oC_CaseAlternative(self):

        localctx = CypherParser.OC_CaseAlternativeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_oC_CaseAlternative)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1214
            self.match(CypherParser.WHEN)
            self.state = 1216
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1215
                self.match(CypherParser.SP)


            self.state = 1218
            self.oC_Expression()
            self.state = 1220
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1219
                self.match(CypherParser.SP)


            self.state = 1222
            self.match(CypherParser.THEN)
            self.state = 1224
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1223
                self.match(CypherParser.SP)


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


    class OC_ListComprehensionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_FilterExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_FilterExpressionContext,0)


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

        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ListComprehension

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

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

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




    def oC_ListComprehension(self):

        localctx = CypherParser.OC_ListComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_oC_ListComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1228
            self.match(CypherParser.T__7)
            self.state = 1230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1229
                self.match(CypherParser.SP)


            self.state = 1232
            self.oC_FilterExpression()
            self.state = 1241
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,220,self._ctx)
            if la_ == 1:
                self.state = 1234
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1233
                    self.match(CypherParser.SP)


                self.state = 1236
                self.match(CypherParser.T__10)
                self.state = 1238
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1237
                    self.match(CypherParser.SP)


                self.state = 1240
                self.oC_Expression()


            self.state = 1244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1243
                self.match(CypherParser.SP)


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


    class OC_PatternComprehensionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_RelationshipsPattern(self):
            return self.getTypedRuleContext(CypherParser.OC_RelationshipsPatternContext,0)


        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_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 oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


        def oC_Where(self):
            return self.getTypedRuleContext(CypherParser.OC_WhereContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_PatternComprehension

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

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

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




    def oC_PatternComprehension(self):

        localctx = CypherParser.OC_PatternComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_oC_PatternComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1248
            self.match(CypherParser.T__7)
            self.state = 1250
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1249
                self.match(CypherParser.SP)


            self.state = 1260
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & 5360119251393) != 0):
                self.state = 1252
                self.oC_Variable()
                self.state = 1254
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1253
                    self.match(CypherParser.SP)


                self.state = 1256
                self.match(CypherParser.T__2)
                self.state = 1258
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1257
                    self.match(CypherParser.SP)




            self.state = 1262
            self.oC_RelationshipsPattern()
            self.state = 1264
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1263
                self.match(CypherParser.SP)


            self.state = 1270
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==72:
                self.state = 1266
                self.oC_Where()
                self.state = 1268
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1267
                    self.match(CypherParser.SP)




            self.state = 1272
            self.match(CypherParser.T__10)
            self.state = 1274
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1273
                self.match(CypherParser.SP)


            self.state = 1276
            self.oC_Expression()
            self.state = 1278
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1277
                self.match(CypherParser.SP)


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


    class OC_QuantifierContext(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 oC_FilterExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_FilterExpressionContext,0)


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

        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_oC_Quantifier

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

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

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




    def oC_Quantifier(self):

        localctx = CypherParser.OC_QuantifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_oC_Quantifier)
        self._la = 0 # Token type
        try:
            self.state = 1338
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [47]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1282
                self.match(CypherParser.ALL)
                self.state = 1284
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1283
                    self.match(CypherParser.SP)


                self.state = 1286
                self.match(CypherParser.T__5)
                self.state = 1288
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1287
                    self.match(CypherParser.SP)


                self.state = 1290
                self.oC_FilterExpression()
                self.state = 1292
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1291
                    self.match(CypherParser.SP)


                self.state = 1294
                self.match(CypherParser.T__6)
                pass
            elif token in [89]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1296
                self.match(CypherParser.ANY)
                self.state = 1298
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1297
                    self.match(CypherParser.SP)


                self.state = 1300
                self.match(CypherParser.T__5)
                self.state = 1302
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1301
                    self.match(CypherParser.SP)


                self.state = 1304
                self.oC_FilterExpression()
                self.state = 1306
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1305
                    self.match(CypherParser.SP)


                self.state = 1308
                self.match(CypherParser.T__6)
                pass
            elif token in [90]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1310
                self.match(CypherParser.NONE)
                self.state = 1312
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1311
                    self.match(CypherParser.SP)


                self.state = 1314
                self.match(CypherParser.T__5)
                self.state = 1316
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1315
                    self.match(CypherParser.SP)


                self.state = 1318
                self.oC_FilterExpression()
                self.state = 1320
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1319
                    self.match(CypherParser.SP)


                self.state = 1322
                self.match(CypherParser.T__6)
                pass
            elif token in [91]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1324
                self.match(CypherParser.SINGLE)
                self.state = 1326
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1325
                    self.match(CypherParser.SP)


                self.state = 1328
                self.match(CypherParser.T__5)
                self.state = 1330
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1329
                    self.match(CypherParser.SP)


                self.state = 1332
                self.oC_FilterExpression()
                self.state = 1334
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1333
                    self.match(CypherParser.SP)


                self.state = 1336
                self.match(CypherParser.T__6)
                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 OC_ReduceContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


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


        def oC_IdInColl(self):
            return self.getTypedRuleContext(CypherParser.OC_IdInCollContext,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_oC_Reduce

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

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

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




    def oC_Reduce(self):

        localctx = CypherParser.OC_ReduceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_oC_Reduce)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1340
            self.match(CypherParser.REDUCE)
            self.state = 1342
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1341
                self.match(CypherParser.SP)


            self.state = 1344
            self.match(CypherParser.T__5)
            self.state = 1346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1345
                self.match(CypherParser.SP)


            self.state = 1348
            self.oC_Variable()
            self.state = 1350
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1349
                self.match(CypherParser.SP)


            self.state = 1352
            self.match(CypherParser.T__2)
            self.state = 1354
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1353
                self.match(CypherParser.SP)


            self.state = 1356
            self.oC_Expression()
            self.state = 1358
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1357
                self.match(CypherParser.SP)


            self.state = 1360
            self.match(CypherParser.T__1)
            self.state = 1362
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1361
                self.match(CypherParser.SP)


            self.state = 1364
            self.oC_IdInColl()
            self.state = 1366
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1365
                self.match(CypherParser.SP)


            self.state = 1368
            self.match(CypherParser.T__10)
            self.state = 1370
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1369
                self.match(CypherParser.SP)


            self.state = 1372
            self.oC_Expression()
            self.state = 1374
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1373
                self.match(CypherParser.SP)


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


    class OC_FilterExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_IdInColl(self):
            return self.getTypedRuleContext(CypherParser.OC_IdInCollContext,0)


        def oC_Where(self):
            return self.getTypedRuleContext(CypherParser.OC_WhereContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_FilterExpression

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

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

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




    def oC_FilterExpression(self):

        localctx = CypherParser.OC_FilterExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_oC_FilterExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1378
            self.oC_IdInColl()
            self.state = 1383
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,254,self._ctx)
            if la_ == 1:
                self.state = 1380
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1379
                    self.match(CypherParser.SP)


                self.state = 1382
                self.oC_Where()


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


    class OC_PatternPredicateContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_RelationshipsPattern(self):
            return self.getTypedRuleContext(CypherParser.OC_RelationshipsPatternContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_PatternPredicate

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

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

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




    def oC_PatternPredicate(self):

        localctx = CypherParser.OC_PatternPredicateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_oC_PatternPredicate)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1385
            self.oC_RelationshipsPattern()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ParenthesizedExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_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_oC_ParenthesizedExpression

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

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

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




    def oC_ParenthesizedExpression(self):

        localctx = CypherParser.OC_ParenthesizedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_oC_ParenthesizedExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1387
            self.match(CypherParser.T__5)
            self.state = 1389
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1388
                self.match(CypherParser.SP)


            self.state = 1391
            self.oC_Expression()
            self.state = 1393
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1392
                self.match(CypherParser.SP)


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


    class OC_IdInCollContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Variable(self):
            return self.getTypedRuleContext(CypherParser.OC_VariableContext,0)


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

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

        def oC_Expression(self):
            return self.getTypedRuleContext(CypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_IdInColl

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

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

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




    def oC_IdInColl(self):

        localctx = CypherParser.OC_IdInCollContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_oC_IdInColl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1397
            self.oC_Variable()
            self.state = 1398
            self.match(CypherParser.SP)
            self.state = 1399
            self.match(CypherParser.IN)
            self.state = 1400
            self.match(CypherParser.SP)
            self.state = 1401
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_FunctionInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_FunctionName(self):
            return self.getTypedRuleContext(CypherParser.OC_FunctionNameContext,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 oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_ExpressionContext,i)


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

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_FunctionInvocation

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

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

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




    def oC_FunctionInvocation(self):

        localctx = CypherParser.OC_FunctionInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_oC_FunctionInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1403
            self.oC_FunctionName()
            self.state = 1405
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1404
                self.match(CypherParser.SP)


            self.state = 1407
            self.match(CypherParser.T__5)
            self.state = 1409
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
            if la_ == 1:
                self.state = 1408
                self.match(CypherParser.SP)


            self.state = 1415
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==63:
                self.state = 1411
                self.match(CypherParser.DISTINCT)
                self.state = 1413
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,259,self._ctx)
                if la_ == 1:
                    self.state = 1412
                    self.match(CypherParser.SP)




            self.state = 1434
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 140737573028160) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & 686102788694465) != 0):
                self.state = 1417
                self.oC_Expression()
                self.state = 1419
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
                if la_ == 1:
                    self.state = 1418
                    self.match(CypherParser.SP)


                self.state = 1431
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1421
                    self.match(CypherParser.T__1)
                    self.state = 1423
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1422
                        self.match(CypherParser.SP)


                    self.state = 1425
                    self.oC_Expression()
                    self.state = 1427
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,263,self._ctx)
                    if la_ == 1:
                        self.state = 1426
                        self.match(CypherParser.SP)


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



            self.state = 1457
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==64 or _la==126:
                self.state = 1437
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1436
                    self.match(CypherParser.SP)


                self.state = 1439
                self.match(CypherParser.ORDER)
                self.state = 1440
                self.match(CypherParser.SP)
                self.state = 1441
                self.match(CypherParser.BY)
                self.state = 1442
                self.match(CypherParser.SP)
                self.state = 1443
                self.oC_SortItem()
                self.state = 1454
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2 or _la==126:
                    self.state = 1445
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1444
                        self.match(CypherParser.SP)


                    self.state = 1447
                    self.match(CypherParser.T__1)
                    self.state = 1449
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1448
                        self.match(CypherParser.SP)


                    self.state = 1451
                    self.oC_SortItem()
                    self.state = 1456
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



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


    class OC_FunctionNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Namespace(self):
            return self.getTypedRuleContext(CypherParser.OC_NamespaceContext,0)


        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_FunctionName

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

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

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




    def oC_FunctionName(self):

        localctx = CypherParser.OC_FunctionNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_oC_FunctionName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1461
            self.oC_Namespace()
            self.state = 1462
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ExistentialSubqueryContext(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 oC_RegularQuery(self):
            return self.getTypedRuleContext(CypherParser.OC_RegularQueryContext,0)


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

        def oC_Pattern(self):
            return self.getTypedRuleContext(CypherParser.OC_PatternContext,0)


        def oC_Where(self):
            return self.getTypedRuleContext(CypherParser.OC_WhereContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ExistentialSubquery

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

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

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




    def oC_ExistentialSubquery(self):

        localctx = CypherParser.OC_ExistentialSubqueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_oC_ExistentialSubquery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1464
            self.match(CypherParser.EXISTS)
            self.state = 1466
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1465
                self.match(CypherParser.SP)


            self.state = 1468
            self.match(CypherParser.T__23)
            self.state = 1470
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1469
                self.match(CypherParser.SP)


            self.state = 1480
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [48, 49, 50, 52, 54, 55, 56, 57, 58, 59, 61, 62]:
                self.state = 1472
                self.oC_RegularQuery()
                pass
            elif token in [6, 83, 89, 90, 91, 99, 120, 121, 122, 125]:
                self.state = 1473
                self.oC_Pattern()
                self.state = 1478
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
                if la_ == 1:
                    self.state = 1475
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1474
                        self.match(CypherParser.SP)


                    self.state = 1477
                    self.oC_Where()


                pass
            else:
                raise NoViableAltException(self)

            self.state = 1483
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1482
                self.match(CypherParser.SP)


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


    class OC_ExplicitProcedureInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_ProcedureName(self):
            return self.getTypedRuleContext(CypherParser.OC_ProcedureNameContext,0)


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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ExplicitProcedureInvocation

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

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

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




    def oC_ExplicitProcedureInvocation(self):

        localctx = CypherParser.OC_ExplicitProcedureInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_oC_ExplicitProcedureInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1487
            self.oC_ProcedureName()
            self.state = 1489
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1488
                self.match(CypherParser.SP)


            self.state = 1491
            self.match(CypherParser.T__5)
            self.state = 1493
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1492
                self.match(CypherParser.SP)


            self.state = 1512
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 140737573028160) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & 686102788694465) != 0):
                self.state = 1495
                self.oC_Expression()
                self.state = 1497
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1496
                    self.match(CypherParser.SP)


                self.state = 1509
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1499
                    self.match(CypherParser.T__1)
                    self.state = 1501
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1500
                        self.match(CypherParser.SP)


                    self.state = 1503
                    self.oC_Expression()
                    self.state = 1505
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1504
                        self.match(CypherParser.SP)


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



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


    class OC_ImplicitProcedureInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_ProcedureName(self):
            return self.getTypedRuleContext(CypherParser.OC_ProcedureNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ImplicitProcedureInvocation

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

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

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




    def oC_ImplicitProcedureInvocation(self):

        localctx = CypherParser.OC_ImplicitProcedureInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_oC_ImplicitProcedureInvocation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1516
            self.oC_ProcedureName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ProcedureResultFieldContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ProcedureResultField

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

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

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




    def oC_ProcedureResultField(self):

        localctx = CypherParser.OC_ProcedureResultFieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_oC_ProcedureResultField)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1518
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ProcedureNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Namespace(self):
            return self.getTypedRuleContext(CypherParser.OC_NamespaceContext,0)


        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ProcedureName

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

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

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




    def oC_ProcedureName(self):

        localctx = CypherParser.OC_ProcedureNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_oC_ProcedureName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1520
            self.oC_Namespace()
            self.state = 1521
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NamespaceContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Namespace

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

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

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




    def oC_Namespace(self):

        localctx = CypherParser.OC_NamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_oC_Namespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1528
            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 = 1523
                    self.oC_SymbolicName()
                    self.state = 1524
                    self.match(CypherParser.T__22) 
                self.state = 1530
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,284,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 OC_VariableContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Variable

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

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

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




    def oC_Variable(self):

        localctx = CypherParser.OC_VariableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_oC_Variable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1531
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_BooleanLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_BooleanLiteralContext,0)


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

        def oC_NumberLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_NumberLiteralContext,0)


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

        def oC_ListLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_ListLiteralContext,0)


        def oC_MapLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_MapLiteralContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Literal

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

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

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




    def oC_Literal(self):

        localctx = CypherParser.OC_LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_oC_Literal)
        try:
            self.state = 1539
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [94, 95]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1533
                self.oC_BooleanLiteral()
                pass
            elif token in [82]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1534
                self.match(CypherParser.NULL)
                pass
            elif token in [96, 97, 98, 106, 107]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1535
                self.oC_NumberLiteral()
                pass
            elif token in [108]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1536
                self.match(CypherParser.StringLiteral)
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1537
                self.oC_ListLiteral()
                pass
            elif token in [24]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1538
                self.oC_MapLiteral()
                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 OC_BooleanLiteralContext(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_oC_BooleanLiteral

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

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

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




    def oC_BooleanLiteral(self):

        localctx = CypherParser.OC_BooleanLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_oC_BooleanLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1541
            _la = self._input.LA(1)
            if not(_la==94 or _la==95):
                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 OC_NumberLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_DoubleLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_DoubleLiteralContext,0)


        def oC_IntegerLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_IntegerLiteralContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_NumberLiteral

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

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

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




    def oC_NumberLiteral(self):

        localctx = CypherParser.OC_NumberLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_oC_NumberLiteral)
        try:
            self.state = 1545
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [106, 107]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1543
                self.oC_DoubleLiteral()
                pass
            elif token in [96, 97, 98]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1544
                self.oC_IntegerLiteral()
                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 OC_IntegerLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_IntegerLiteral

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

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

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




    def oC_IntegerLiteral(self):

        localctx = CypherParser.OC_IntegerLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_oC_IntegerLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1547
            _la = self._input.LA(1)
            if not(((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & 7) != 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 OC_DoubleLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_DoubleLiteral

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

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

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




    def oC_DoubleLiteral(self):

        localctx = CypherParser.OC_DoubleLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_oC_DoubleLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1549
            _la = self._input.LA(1)
            if not(_la==106 or _la==107):
                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 OC_ListLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ListLiteral

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

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

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




    def oC_ListLiteral(self):

        localctx = CypherParser.OC_ListLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_oC_ListLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1551
            self.match(CypherParser.T__7)
            self.state = 1553
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1552
                self.match(CypherParser.SP)


            self.state = 1572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 140737573028160) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & 686102788694465) != 0):
                self.state = 1555
                self.oC_Expression()
                self.state = 1557
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1556
                    self.match(CypherParser.SP)


                self.state = 1569
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1559
                    self.match(CypherParser.T__1)
                    self.state = 1561
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1560
                        self.match(CypherParser.SP)


                    self.state = 1563
                    self.oC_Expression()
                    self.state = 1565
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1564
                        self.match(CypherParser.SP)


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



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


    class OC_MapLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_MapLiteral

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

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

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




    def oC_MapLiteral(self):

        localctx = CypherParser.OC_MapLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_oC_MapLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1576
            self.match(CypherParser.T__23)
            self.state = 1578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1577
                self.match(CypherParser.SP)


            self.state = 1613
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -1729452625654448128) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 2882233431159209983) != 0):
                self.state = 1580
                self.oC_PropertyKeyName()
                self.state = 1582
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1581
                    self.match(CypherParser.SP)


                self.state = 1584
                self.match(CypherParser.T__9)
                self.state = 1586
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1585
                    self.match(CypherParser.SP)


                self.state = 1588
                self.oC_Expression()
                self.state = 1590
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1589
                    self.match(CypherParser.SP)


                self.state = 1610
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1592
                    self.match(CypherParser.T__1)
                    self.state = 1594
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1593
                        self.match(CypherParser.SP)


                    self.state = 1596
                    self.oC_PropertyKeyName()
                    self.state = 1598
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1597
                        self.match(CypherParser.SP)


                    self.state = 1600
                    self.match(CypherParser.T__9)
                    self.state = 1602
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1601
                        self.match(CypherParser.SP)


                    self.state = 1604
                    self.oC_Expression()
                    self.state = 1606
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==126:
                        self.state = 1605
                        self.match(CypherParser.SP)


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



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


    class OC_PropertyKeyNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SchemaName(self):
            return self.getTypedRuleContext(CypherParser.OC_SchemaNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_PropertyKeyName

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

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

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




    def oC_PropertyKeyName(self):

        localctx = CypherParser.OC_PropertyKeyNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_oC_PropertyKeyName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1617
            self.oC_SchemaName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_Parameter

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

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

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




    def oC_Parameter(self):

        localctx = CypherParser.OC_ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_oC_Parameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1619
            self.match(CypherParser.T__25)
            self.state = 1622
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [83, 89, 90, 91, 99, 120, 121, 122, 125]:
                self.state = 1620
                self.oC_SymbolicName()
                pass
            elif token in [97]:
                self.state = 1621
                self.match(CypherParser.DecimalInteger)
                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 OC_SchemaNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def oC_ReservedWord(self):
            return self.getTypedRuleContext(CypherParser.OC_ReservedWordContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_SchemaName

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

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

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




    def oC_SchemaName(self):

        localctx = CypherParser.OC_SchemaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_oC_SchemaName)
        try:
            self.state = 1626
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [83, 89, 90, 91, 99, 120, 121, 122, 125]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1624
                self.oC_SymbolicName()
                pass
            elif token in [46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 93, 94, 95, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1625
                self.oC_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 OC_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 L_SKIP(self):
            return self.getToken(CypherParser.L_SKIP, 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(self):
            return self.getToken(CypherParser.NULL, 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_oC_ReservedWord

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

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

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




    def oC_ReservedWord(self):

        localctx = CypherParser.OC_ReservedWordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_oC_ReservedWord)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1628
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & -1729452625654448128) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 71987229084876799) != 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 OC_SymbolicNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def HexLetter(self):
            return self.getToken(CypherParser.HexLetter, 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_oC_SymbolicName

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

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

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




    def oC_SymbolicName(self):

        localctx = CypherParser.OC_SymbolicNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_oC_SymbolicName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1630
            _la = self._input.LA(1)
            if not(((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & 5360119251393) != 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 OC_LeftArrowHeadContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_LeftArrowHead

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

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

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




    def oC_LeftArrowHead(self):

        localctx = CypherParser.OC_LeftArrowHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_oC_LeftArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1632
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 2013282304) != 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 OC_RightArrowHeadContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_RightArrowHead

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

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

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




    def oC_RightArrowHead(self):

        localctx = CypherParser.OC_RightArrowHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_oC_RightArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1634
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 32212287488) != 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 OC_DashContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Dash

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

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

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




    def oC_Dash(self):

        localctx = CypherParser.OC_DashContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_oC_Dash)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1636
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 70334384963584) != 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





