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

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

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>", 
                     "<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", "IN", "STARTS", 
                      "ENDS", "CONTAINS", "IS", "NULL", "COUNT", "ANY", 
                      "NONE", "SINGLE", "TRUE", "FALSE", "EXISTS", "CASE", 
                      "ELSE", "END", "WHEN", "THEN", "StringLiteral", "EscapedChar", 
                      "HexInteger", "DecimalInteger", "OctalInteger", "HexLetter", 
                      "HexDigit", "Digit", "NonZeroDigit", "NonZeroOctDigit", 
                      "OctDigit", "ZeroDigit", "ExponentDecimalReal", "RegularDecimalReal", 
                      "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_NodePattern = 38
    RULE_oC_PatternElementChain = 39
    RULE_oC_RelationshipPattern = 40
    RULE_oC_RelationshipDetail = 41
    RULE_oC_Properties = 42
    RULE_oC_RelationshipTypes = 43
    RULE_oC_NodeLabels = 44
    RULE_oC_NodeLabel = 45
    RULE_oC_RangeLiteral = 46
    RULE_oC_LabelName = 47
    RULE_oC_RelTypeName = 48
    RULE_oC_Expression = 49
    RULE_oC_OrExpression = 50
    RULE_oC_XorExpression = 51
    RULE_oC_AndExpression = 52
    RULE_oC_NotExpression = 53
    RULE_oC_ComparisonExpression = 54
    RULE_oC_AddOrSubtractExpression = 55
    RULE_oC_MultiplyDivideModuloExpression = 56
    RULE_oC_PowerOfExpression = 57
    RULE_oC_UnaryAddOrSubtractExpression = 58
    RULE_oC_StringListNullOperatorExpression = 59
    RULE_oC_ListOperatorExpression = 60
    RULE_oC_StringOperatorExpression = 61
    RULE_oC_NullOperatorExpression = 62
    RULE_oC_PropertyOrLabelsExpression = 63
    RULE_oC_Atom = 64
    RULE_oC_Literal = 65
    RULE_oC_BooleanLiteral = 66
    RULE_oC_ListLiteral = 67
    RULE_oC_PartialComparisonExpression = 68
    RULE_oC_ParenthesizedExpression = 69
    RULE_oC_RelationshipsPattern = 70
    RULE_oC_FilterExpression = 71
    RULE_oC_IdInColl = 72
    RULE_oC_FunctionInvocation = 73
    RULE_oC_FunctionName = 74
    RULE_oC_ExistentialSubquery = 75
    RULE_oC_ExplicitProcedureInvocation = 76
    RULE_oC_ImplicitProcedureInvocation = 77
    RULE_oC_ProcedureResultField = 78
    RULE_oC_ProcedureName = 79
    RULE_oC_Namespace = 80
    RULE_oC_ListComprehension = 81
    RULE_oC_PatternComprehension = 82
    RULE_oC_PropertyLookup = 83
    RULE_oC_CaseExpression = 84
    RULE_oC_CaseAlternative = 85
    RULE_oC_Variable = 86
    RULE_oC_NumberLiteral = 87
    RULE_oC_MapLiteral = 88
    RULE_oC_Parameter = 89
    RULE_oC_PropertyExpression = 90
    RULE_oC_PropertyKeyName = 91
    RULE_oC_IntegerLiteral = 92
    RULE_oC_DoubleLiteral = 93
    RULE_oC_SchemaName = 94
    RULE_oC_ReservedWord = 95
    RULE_oC_SymbolicName = 96
    RULE_oC_LeftArrowHead = 97
    RULE_oC_RightArrowHead = 98
    RULE_oC_Dash = 99

    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_NodePattern", "oC_PatternElementChain", "oC_RelationshipPattern", 
                   "oC_RelationshipDetail", "oC_Properties", "oC_RelationshipTypes", 
                   "oC_NodeLabels", "oC_NodeLabel", "oC_RangeLiteral", "oC_LabelName", 
                   "oC_RelTypeName", "oC_Expression", "oC_OrExpression", 
                   "oC_XorExpression", "oC_AndExpression", "oC_NotExpression", 
                   "oC_ComparisonExpression", "oC_AddOrSubtractExpression", 
                   "oC_MultiplyDivideModuloExpression", "oC_PowerOfExpression", 
                   "oC_UnaryAddOrSubtractExpression", "oC_StringListNullOperatorExpression", 
                   "oC_ListOperatorExpression", "oC_StringOperatorExpression", 
                   "oC_NullOperatorExpression", "oC_PropertyOrLabelsExpression", 
                   "oC_Atom", "oC_Literal", "oC_BooleanLiteral", "oC_ListLiteral", 
                   "oC_PartialComparisonExpression", "oC_ParenthesizedExpression", 
                   "oC_RelationshipsPattern", "oC_FilterExpression", "oC_IdInColl", 
                   "oC_FunctionInvocation", "oC_FunctionName", "oC_ExistentialSubquery", 
                   "oC_ExplicitProcedureInvocation", "oC_ImplicitProcedureInvocation", 
                   "oC_ProcedureResultField", "oC_ProcedureName", "oC_Namespace", 
                   "oC_ListComprehension", "oC_PatternComprehension", "oC_PropertyLookup", 
                   "oC_CaseExpression", "oC_CaseAlternative", "oC_Variable", 
                   "oC_NumberLiteral", "oC_MapLiteral", "oC_Parameter", 
                   "oC_PropertyExpression", "oC_PropertyKeyName", "oC_IntegerLiteral", 
                   "oC_DoubleLiteral", "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
    IN=77
    STARTS=78
    ENDS=79
    CONTAINS=80
    IS=81
    NULL=82
    COUNT=83
    ANY=84
    NONE=85
    SINGLE=86
    TRUE=87
    FALSE=88
    EXISTS=89
    CASE=90
    ELSE=91
    END=92
    WHEN=93
    THEN=94
    StringLiteral=95
    EscapedChar=96
    HexInteger=97
    DecimalInteger=98
    OctalInteger=99
    HexLetter=100
    HexDigit=101
    Digit=102
    NonZeroDigit=103
    NonZeroOctDigit=104
    OctDigit=105
    ZeroDigit=106
    ExponentDecimalReal=107
    RegularDecimalReal=108
    CONSTRAINT=109
    DO=110
    FOR=111
    REQUIRE=112
    UNIQUE=113
    MANDATORY=114
    SCALAR=115
    OF=116
    ADD=117
    DROP=118
    FILTER=119
    EXTRACT=120
    UnescapedSymbolicName=121
    IdentifierStart=122
    IdentifierPart=123
    EscapedSymbolicName=124
    SP=125
    WHITESPACE=126
    Comment=127

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




    class 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 = 201
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 200
                self.match(CypherParser.SP)


            self.state = 203
            self.oC_Statement()
            self.state = 208
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 205
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 204
                    self.match(CypherParser.SP)


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


            self.state = 211
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 210
                self.match(CypherParser.SP)


            self.state = 213
            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 = 215
            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 = 219
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 217
                self.oC_RegularQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 218
                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 = 221
            self.oC_SingleQuery()
            self.state = 228
            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 = 223
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 222
                        self.match(CypherParser.SP)


                    self.state = 225
                    self.oC_Union() 
                self.state = 230
                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 = 243
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 231
                self.match(CypherParser.UNION)
                self.state = 232
                self.match(CypherParser.SP)
                self.state = 233
                self.match(CypherParser.ALL)
                self.state = 235
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 234
                    self.match(CypherParser.SP)


                self.state = 237
                self.oC_SingleQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 238
                self.match(CypherParser.UNION)
                self.state = 240
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 239
                    self.match(CypherParser.SP)


                self.state = 242
                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 = 247
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 245
                self.oC_SinglePartQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 246
                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 = 284
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.OPTIONAL) | (1 << CypherParser.MATCH) | (1 << CypherParser.UNWIND) | (1 << CypherParser.CALL))) != 0):
                    self.state = 249
                    self.oC_ReadingClause()
                    self.state = 251
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 250
                        self.match(CypherParser.SP)


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

                self.state = 258
                self.oC_Return()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 265
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.OPTIONAL) | (1 << CypherParser.MATCH) | (1 << CypherParser.UNWIND) | (1 << CypherParser.CALL))) != 0):
                    self.state = 259
                    self.oC_ReadingClause()
                    self.state = 261
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 260
                        self.match(CypherParser.SP)


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

                self.state = 268
                self.oC_UpdatingClause()
                self.state = 275
                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 = 270
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 269
                            self.match(CypherParser.SP)


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

                self.state = 282
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                if la_ == 1:
                    self.state = 279
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 278
                        self.match(CypherParser.SP)


                    self.state = 281
                    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 = 308 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 292
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.OPTIONAL) | (1 << CypherParser.MATCH) | (1 << CypherParser.UNWIND) | (1 << CypherParser.CALL))) != 0):
                        self.state = 286
                        self.oC_ReadingClause()
                        self.state = 288
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 287
                            self.match(CypherParser.SP)


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

                    self.state = 301
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.MERGE) | (1 << CypherParser.CREATE) | (1 << CypherParser.SET) | (1 << CypherParser.DETACH) | (1 << CypherParser.DELETE) | (1 << CypherParser.REMOVE))) != 0):
                        self.state = 295
                        self.oC_UpdatingClause()
                        self.state = 297
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 296
                            self.match(CypherParser.SP)


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

                    self.state = 304
                    self.oC_With()
                    self.state = 306
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 305
                        self.match(CypherParser.SP)



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

            self.state = 312
            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 = 319
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.CREATE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 314
                self.oC_Create()
                pass
            elif token in [CypherParser.MERGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 315
                self.oC_Merge()
                pass
            elif token in [CypherParser.DETACH, CypherParser.DELETE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 316
                self.oC_Delete()
                pass
            elif token in [CypherParser.SET]:
                self.enterOuterAlt(localctx, 4)
                self.state = 317
                self.oC_Set()
                pass
            elif token in [CypherParser.REMOVE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 318
                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 = 324
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.OPTIONAL, CypherParser.MATCH]:
                self.enterOuterAlt(localctx, 1)
                self.state = 321
                self.oC_Match()
                pass
            elif token in [CypherParser.UNWIND]:
                self.enterOuterAlt(localctx, 2)
                self.state = 322
                self.oC_Unwind()
                pass
            elif token in [CypherParser.CALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 323
                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 = 328
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.OPTIONAL:
                self.state = 326
                self.match(CypherParser.OPTIONAL)
                self.state = 327
                self.match(CypherParser.SP)


            self.state = 330
            self.match(CypherParser.MATCH)
            self.state = 332
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 331
                self.match(CypherParser.SP)


            self.state = 334
            self.oC_Pattern()
            self.state = 339
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.state = 336
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 335
                    self.match(CypherParser.SP)


                self.state = 338
                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 = 341
            self.match(CypherParser.UNWIND)
            self.state = 343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 342
                self.match(CypherParser.SP)


            self.state = 345
            self.oC_Expression()
            self.state = 346
            self.match(CypherParser.SP)
            self.state = 347
            self.match(CypherParser.AS)
            self.state = 348
            self.match(CypherParser.SP)
            self.state = 349
            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 = 351
            self.match(CypherParser.MERGE)
            self.state = 353
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 352
                self.match(CypherParser.SP)


            self.state = 355
            self.oC_PatternPart()
            self.state = 360
            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 = 356
                    self.match(CypherParser.SP)
                    self.state = 357
                    self.oC_MergeAction() 
                self.state = 362
                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 = 373
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 363
                self.match(CypherParser.ON)
                self.state = 364
                self.match(CypherParser.SP)
                self.state = 365
                self.match(CypherParser.MATCH)
                self.state = 366
                self.match(CypherParser.SP)
                self.state = 367
                self.oC_Set()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 368
                self.match(CypherParser.ON)
                self.state = 369
                self.match(CypherParser.SP)
                self.state = 370
                self.match(CypherParser.CREATE)
                self.state = 371
                self.match(CypherParser.SP)
                self.state = 372
                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 = 375
            self.match(CypherParser.CREATE)
            self.state = 377
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 376
                self.match(CypherParser.SP)


            self.state = 379
            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 = 381
            self.match(CypherParser.SET)
            self.state = 383
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 382
                self.match(CypherParser.SP)


            self.state = 385
            self.oC_SetItem()
            self.state = 396
            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 = 387
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 386
                        self.match(CypherParser.SP)


                    self.state = 389
                    self.match(CypherParser.T__1)
                    self.state = 391
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 390
                        self.match(CypherParser.SP)


                    self.state = 393
                    self.oC_SetItem() 
                self.state = 398
                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 = 435
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 399
                self.oC_PropertyExpression()
                self.state = 401
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 400
                    self.match(CypherParser.SP)


                self.state = 403
                self.match(CypherParser.T__2)
                self.state = 405
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 404
                    self.match(CypherParser.SP)


                self.state = 407
                self.oC_Expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 409
                self.oC_Variable()
                self.state = 411
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 410
                    self.match(CypherParser.SP)


                self.state = 413
                self.match(CypherParser.T__2)
                self.state = 415
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 414
                    self.match(CypherParser.SP)


                self.state = 417
                self.oC_Expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 419
                self.oC_Variable()
                self.state = 421
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 420
                    self.match(CypherParser.SP)


                self.state = 423
                self.match(CypherParser.T__3)
                self.state = 425
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 424
                    self.match(CypherParser.SP)


                self.state = 427
                self.oC_Expression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 429
                self.oC_Variable()
                self.state = 431
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 430
                    self.match(CypherParser.SP)


                self.state = 433
                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 = 439
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.DETACH:
                self.state = 437
                self.match(CypherParser.DETACH)
                self.state = 438
                self.match(CypherParser.SP)


            self.state = 441
            self.match(CypherParser.DELETE)
            self.state = 443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 442
                self.match(CypherParser.SP)


            self.state = 445
            self.oC_Expression()
            self.state = 456
            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 = 447
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 446
                        self.match(CypherParser.SP)


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


                    self.state = 453
                    self.oC_Expression() 
                self.state = 458
                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 = 459
            self.match(CypherParser.REMOVE)
            self.state = 460
            self.match(CypherParser.SP)
            self.state = 461
            self.oC_RemoveItem()
            self.state = 472
            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 = 463
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 462
                        self.match(CypherParser.SP)


                    self.state = 465
                    self.match(CypherParser.T__1)
                    self.state = 467
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 466
                        self.match(CypherParser.SP)


                    self.state = 469
                    self.oC_RemoveItem() 
                self.state = 474
                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 = 479
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 475
                self.oC_Variable()
                self.state = 476
                self.oC_NodeLabels()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 478
                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 = 481
            self.match(CypherParser.CALL)
            self.state = 482
            self.match(CypherParser.SP)
            self.state = 483
            self.oC_ExplicitProcedureInvocation()
            self.state = 490
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                self.state = 485
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 484
                    self.match(CypherParser.SP)


                self.state = 487
                self.match(CypherParser.YIELD)
                self.state = 488
                self.match(CypherParser.SP)
                self.state = 489
                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 = 492
            self.match(CypherParser.CALL)
            self.state = 493
            self.match(CypherParser.SP)
            self.state = 496
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
            if la_ == 1:
                self.state = 494
                self.oC_ExplicitProcedureInvocation()
                pass

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


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


                self.state = 501
                self.match(CypherParser.YIELD)
                self.state = 502
                self.match(CypherParser.SP)
                self.state = 505
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CypherParser.T__4]:
                    self.state = 503
                    self.match(CypherParser.T__4)
                    pass
                elif token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                    self.state = 504
                    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 = 509
            self.oC_YieldItem()
            self.state = 520
            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 = 511
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 510
                        self.match(CypherParser.SP)


                    self.state = 513
                    self.match(CypherParser.T__1)
                    self.state = 515
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 514
                        self.match(CypherParser.SP)


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

            self.state = 527
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
            if la_ == 1:
                self.state = 524
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 523
                    self.match(CypherParser.SP)


                self.state = 526
                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 = 534
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.state = 529
                self.oC_ProcedureResultField()
                self.state = 530
                self.match(CypherParser.SP)
                self.state = 531
                self.match(CypherParser.AS)
                self.state = 532
                self.match(CypherParser.SP)


            self.state = 536
            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 = 538
            self.match(CypherParser.WITH)
            self.state = 539
            self.oC_ProjectionBody()
            self.state = 544
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 541
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 540
                    self.match(CypherParser.SP)


                self.state = 543
                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 = 546
            self.match(CypherParser.RETURN)
            self.state = 547
            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 = 553
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.state = 550
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 549
                    self.match(CypherParser.SP)


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


            self.state = 555
            self.match(CypherParser.SP)
            self.state = 556
            self.oC_ProjectionItems()
            self.state = 559
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.state = 557
                self.match(CypherParser.SP)
                self.state = 558
                self.oC_Order()


            self.state = 563
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 561
                self.match(CypherParser.SP)
                self.state = 562
                self.oC_Skip()


            self.state = 567
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 565
                self.match(CypherParser.SP)
                self.state = 566
                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 = 597
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 569
                self.match(CypherParser.T__4)
                self.state = 580
                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 = 571
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 570
                            self.match(CypherParser.SP)


                        self.state = 573
                        self.match(CypherParser.T__1)
                        self.state = 575
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 574
                            self.match(CypherParser.SP)


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

                pass
            elif token in [CypherParser.T__5, CypherParser.T__7, CypherParser.T__12, CypherParser.T__13, CypherParser.T__22, CypherParser.T__25, CypherParser.ALL, CypherParser.NOT, CypherParser.NULL, CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.TRUE, CypherParser.FALSE, CypherParser.EXISTS, CypherParser.CASE, CypherParser.StringLiteral, CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger, CypherParser.HexLetter, CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.enterOuterAlt(localctx, 2)
                self.state = 583
                self.oC_ProjectionItem()
                self.state = 594
                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 = 585
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 584
                            self.match(CypherParser.SP)


                        self.state = 587
                        self.match(CypherParser.T__1)
                        self.state = 589
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 588
                            self.match(CypherParser.SP)


                        self.state = 591
                        self.oC_ProjectionItem() 
                    self.state = 596
                    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 = 606
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 599
                self.oC_Expression()
                self.state = 600
                self.match(CypherParser.SP)
                self.state = 601
                self.match(CypherParser.AS)
                self.state = 602
                self.match(CypherParser.SP)
                self.state = 603
                self.oC_Variable()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 605
                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 = 608
            self.match(CypherParser.ORDER)
            self.state = 609
            self.match(CypherParser.SP)
            self.state = 610
            self.match(CypherParser.BY)
            self.state = 611
            self.match(CypherParser.SP)
            self.state = 612
            self.oC_SortItem()
            self.state = 620
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CypherParser.T__1:
                self.state = 613
                self.match(CypherParser.T__1)
                self.state = 615
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 614
                    self.match(CypherParser.SP)


                self.state = 617
                self.oC_SortItem()
                self.state = 622
                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 = 623
            self.match(CypherParser.L_SKIP)
            self.state = 624
            self.match(CypherParser.SP)
            self.state = 625
            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 = 627
            self.match(CypherParser.LIMIT)
            self.state = 628
            self.match(CypherParser.SP)
            self.state = 629
            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 = 631
            self.oC_Expression()
            self.state = 636
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
            if la_ == 1:
                self.state = 633
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 632
                    self.match(CypherParser.SP)


                self.state = 635
                _la = self._input.LA(1)
                if not(((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (CypherParser.ASCENDING - 68)) | (1 << (CypherParser.ASC - 68)) | (1 << (CypherParser.DESCENDING - 68)) | (1 << (CypherParser.DESC - 68)))) != 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 = 638
            self.match(CypherParser.WHERE)
            self.state = 639
            self.match(CypherParser.SP)
            self.state = 640
            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 = 642
            self.oC_PatternPart()
            self.state = 653
            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 = 644
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 643
                        self.match(CypherParser.SP)


                    self.state = 646
                    self.match(CypherParser.T__1)
                    self.state = 648
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 647
                        self.match(CypherParser.SP)


                    self.state = 650
                    self.oC_PatternPart() 
                self.state = 655
                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 = 667
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.enterOuterAlt(localctx, 1)
                self.state = 656
                self.oC_Variable()
                self.state = 658
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 657
                    self.match(CypherParser.SP)


                self.state = 660
                self.match(CypherParser.T__2)
                self.state = 662
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 661
                    self.match(CypherParser.SP)


                self.state = 664
                self.oC_AnonymousPatternPart()
                pass
            elif token in [CypherParser.T__5]:
                self.enterOuterAlt(localctx, 2)
                self.state = 666
                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 = 669
            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 = 685
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 671
                self.oC_NodePattern()
                self.state = 678
                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 = 673
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 672
                            self.match(CypherParser.SP)


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

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 681
                self.match(CypherParser.T__5)
                self.state = 682
                self.oC_PatternElement()
                self.state = 683
                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_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, 76, self.RULE_oC_NodePattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 687
            self.match(CypherParser.T__5)
            self.state = 689
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 688
                self.match(CypherParser.SP)


            self.state = 695
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (CypherParser.COUNT - 83)) | (1 << (CypherParser.ANY - 83)) | (1 << (CypherParser.NONE - 83)) | (1 << (CypherParser.SINGLE - 83)) | (1 << (CypherParser.HexLetter - 83)) | (1 << (CypherParser.FILTER - 83)) | (1 << (CypherParser.EXTRACT - 83)) | (1 << (CypherParser.UnescapedSymbolicName - 83)) | (1 << (CypherParser.EscapedSymbolicName - 83)))) != 0):
                self.state = 691
                self.oC_Variable()
                self.state = 693
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 692
                    self.match(CypherParser.SP)




            self.state = 701
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__9:
                self.state = 697
                self.oC_NodeLabels()
                self.state = 699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 698
                    self.match(CypherParser.SP)




            self.state = 707
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__22 or _la==CypherParser.T__25:
                self.state = 703
                self.oC_Properties()
                self.state = 705
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 704
                    self.match(CypherParser.SP)




            self.state = 709
            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, 78, self.RULE_oC_PatternElementChain)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 711
            self.oC_RelationshipPattern()
            self.state = 713
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 712
                self.match(CypherParser.SP)


            self.state = 715
            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, 80, self.RULE_oC_RelationshipPattern)
        self._la = 0 # Token type
        try:
            self.state = 781
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 717
                self.oC_LeftArrowHead()
                self.state = 719
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 718
                    self.match(CypherParser.SP)


                self.state = 721
                self.oC_Dash()
                self.state = 723
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
                if la_ == 1:
                    self.state = 722
                    self.match(CypherParser.SP)


                self.state = 726
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.T__7:
                    self.state = 725
                    self.oC_RelationshipDetail()


                self.state = 729
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 728
                    self.match(CypherParser.SP)


                self.state = 731
                self.oC_Dash()
                self.state = 733
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 732
                    self.match(CypherParser.SP)


                self.state = 735
                self.oC_RightArrowHead()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 737
                self.oC_LeftArrowHead()
                self.state = 739
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 738
                    self.match(CypherParser.SP)


                self.state = 741
                self.oC_Dash()
                self.state = 743
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
                if la_ == 1:
                    self.state = 742
                    self.match(CypherParser.SP)


                self.state = 746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.T__7:
                    self.state = 745
                    self.oC_RelationshipDetail()


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


                self.state = 751
                self.oC_Dash()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 753
                self.oC_Dash()
                self.state = 755
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
                if la_ == 1:
                    self.state = 754
                    self.match(CypherParser.SP)


                self.state = 758
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.T__7:
                    self.state = 757
                    self.oC_RelationshipDetail()


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


                self.state = 763
                self.oC_Dash()
                self.state = 765
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 764
                    self.match(CypherParser.SP)


                self.state = 767
                self.oC_RightArrowHead()
                pass

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


                self.state = 774
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.T__7:
                    self.state = 773
                    self.oC_RelationshipDetail()


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


                self.state = 779
                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, 82, self.RULE_oC_RelationshipDetail)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 783
            self.match(CypherParser.T__7)
            self.state = 785
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 784
                self.match(CypherParser.SP)


            self.state = 791
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (CypherParser.COUNT - 83)) | (1 << (CypherParser.ANY - 83)) | (1 << (CypherParser.NONE - 83)) | (1 << (CypherParser.SINGLE - 83)) | (1 << (CypherParser.HexLetter - 83)) | (1 << (CypherParser.FILTER - 83)) | (1 << (CypherParser.EXTRACT - 83)) | (1 << (CypherParser.UnescapedSymbolicName - 83)) | (1 << (CypherParser.EscapedSymbolicName - 83)))) != 0):
                self.state = 787
                self.oC_Variable()
                self.state = 789
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 788
                    self.match(CypherParser.SP)




            self.state = 797
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__9:
                self.state = 793
                self.oC_RelationshipTypes()
                self.state = 795
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 794
                    self.match(CypherParser.SP)




            self.state = 800
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__4:
                self.state = 799
                self.oC_RangeLiteral()


            self.state = 806
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__22 or _la==CypherParser.T__25:
                self.state = 802
                self.oC_Properties()
                self.state = 804
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 803
                    self.match(CypherParser.SP)




            self.state = 808
            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, 84, self.RULE_oC_Properties)
        try:
            self.state = 812
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__22]:
                self.enterOuterAlt(localctx, 1)
                self.state = 810
                self.oC_MapLiteral()
                pass
            elif token in [CypherParser.T__25]:
                self.enterOuterAlt(localctx, 2)
                self.state = 811
                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, 86, self.RULE_oC_RelationshipTypes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 814
            self.match(CypherParser.T__9)
            self.state = 816
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 815
                self.match(CypherParser.SP)


            self.state = 818
            self.oC_RelTypeName()
            self.state = 832
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,136,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 820
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 819
                        self.match(CypherParser.SP)


                    self.state = 822
                    self.match(CypherParser.T__10)
                    self.state = 824
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.T__9:
                        self.state = 823
                        self.match(CypherParser.T__9)


                    self.state = 827
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 826
                        self.match(CypherParser.SP)


                    self.state = 829
                    self.oC_RelTypeName() 
                self.state = 834
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,136,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.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, 88, self.RULE_oC_NodeLabels)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 835
            self.oC_NodeLabel()
            self.state = 842
            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==CypherParser.SP:
                        self.state = 836
                        self.match(CypherParser.SP)


                    self.state = 839
                    self.oC_NodeLabel() 
                self.state = 844
                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_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, 90, self.RULE_oC_NodeLabel)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 845
            self.match(CypherParser.T__9)
            self.state = 847
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 846
                self.match(CypherParser.SP)


            self.state = 849
            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, 92, self.RULE_oC_RangeLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 851
            self.match(CypherParser.T__4)
            self.state = 853
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 852
                self.match(CypherParser.SP)


            self.state = 859
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 97)) & ~0x3f) == 0 and ((1 << (_la - 97)) & ((1 << (CypherParser.HexInteger - 97)) | (1 << (CypherParser.DecimalInteger - 97)) | (1 << (CypherParser.OctalInteger - 97)))) != 0):
                self.state = 855
                self.oC_IntegerLiteral()
                self.state = 857
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 856
                    self.match(CypherParser.SP)




            self.state = 871
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__11:
                self.state = 861
                self.match(CypherParser.T__11)
                self.state = 863
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 862
                    self.match(CypherParser.SP)


                self.state = 869
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 97)) & ~0x3f) == 0 and ((1 << (_la - 97)) & ((1 << (CypherParser.HexInteger - 97)) | (1 << (CypherParser.DecimalInteger - 97)) | (1 << (CypherParser.OctalInteger - 97)))) != 0):
                    self.state = 865
                    self.oC_IntegerLiteral()
                    self.state = 867
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 866
                        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, 94, self.RULE_oC_LabelName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 873
            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, 96, self.RULE_oC_RelTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 875
            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_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, 98, self.RULE_oC_Expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 877
            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, 100, self.RULE_oC_OrExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 879
            self.oC_XorExpression()
            self.state = 886
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,147,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 880
                    self.match(CypherParser.SP)
                    self.state = 881
                    self.match(CypherParser.OR)
                    self.state = 882
                    self.match(CypherParser.SP)
                    self.state = 883
                    self.oC_XorExpression() 
                self.state = 888
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,147,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, 102, self.RULE_oC_XorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 889
            self.oC_AndExpression()
            self.state = 896
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,148,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 890
                    self.match(CypherParser.SP)
                    self.state = 891
                    self.match(CypherParser.XOR)
                    self.state = 892
                    self.match(CypherParser.SP)
                    self.state = 893
                    self.oC_AndExpression() 
                self.state = 898
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,148,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, 104, self.RULE_oC_AndExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 899
            self.oC_NotExpression()
            self.state = 906
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,149,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 900
                    self.match(CypherParser.SP)
                    self.state = 901
                    self.match(CypherParser.AND)
                    self.state = 902
                    self.match(CypherParser.SP)
                    self.state = 903
                    self.oC_NotExpression() 
                self.state = 908
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,149,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, 106, self.RULE_oC_NotExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 915
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CypherParser.NOT:
                self.state = 909
                self.match(CypherParser.NOT)
                self.state = 911
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 910
                    self.match(CypherParser.SP)


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

            self.state = 918
            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_AddOrSubtractExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_AddOrSubtractExpressionContext,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, 108, self.RULE_oC_ComparisonExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 920
            self.oC_AddOrSubtractExpression()
            self.state = 927
            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 = 922
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 921
                        self.match(CypherParser.SP)


                    self.state = 924
                    self.oC_PartialComparisonExpression() 
                self.state = 929
                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_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, 110, self.RULE_oC_AddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 930
            self.oC_MultiplyDivideModuloExpression()
            self.state = 949
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,159,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 947
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
                    if la_ == 1:
                        self.state = 932
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 931
                            self.match(CypherParser.SP)


                        self.state = 934
                        self.match(CypherParser.T__12)
                        self.state = 936
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 935
                            self.match(CypherParser.SP)


                        self.state = 938
                        self.oC_MultiplyDivideModuloExpression()
                        pass

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


                        self.state = 942
                        self.match(CypherParser.T__13)
                        self.state = 944
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 943
                            self.match(CypherParser.SP)


                        self.state = 946
                        self.oC_MultiplyDivideModuloExpression()
                        pass

             
                self.state = 951
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,159,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, 112, self.RULE_oC_MultiplyDivideModuloExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 952
            self.oC_PowerOfExpression()
            self.state = 979
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,167,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 977
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
                    if la_ == 1:
                        self.state = 954
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 953
                            self.match(CypherParser.SP)


                        self.state = 956
                        self.match(CypherParser.T__4)
                        self.state = 958
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 957
                            self.match(CypherParser.SP)


                        self.state = 960
                        self.oC_PowerOfExpression()
                        pass

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


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


                        self.state = 968
                        self.oC_PowerOfExpression()
                        pass

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


                        self.state = 972
                        self.match(CypherParser.T__15)
                        self.state = 974
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 973
                            self.match(CypherParser.SP)


                        self.state = 976
                        self.oC_PowerOfExpression()
                        pass

             
                self.state = 981
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,167,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, 114, self.RULE_oC_PowerOfExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 982
            self.oC_UnaryAddOrSubtractExpression()
            self.state = 993
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,170,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 984
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 983
                        self.match(CypherParser.SP)


                    self.state = 986
                    self.match(CypherParser.T__16)
                    self.state = 988
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 987
                        self.match(CypherParser.SP)


                    self.state = 990
                    self.oC_UnaryAddOrSubtractExpression() 
                self.state = 995
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,170,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_StringListNullOperatorExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_StringListNullOperatorExpressionContext,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_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, 116, self.RULE_oC_UnaryAddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CypherParser.T__12 or _la==CypherParser.T__13:
                self.state = 996
                _la = self._input.LA(1)
                if not(_la==CypherParser.T__12 or _la==CypherParser.T__13):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 998
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 997
                    self.match(CypherParser.SP)


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

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


    class OC_StringListNullOperatorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_PropertyOrLabelsExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_PropertyOrLabelsExpressionContext,0)


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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_StringListNullOperatorExpression

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

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

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




    def oC_StringListNullOperatorExpression(self):

        localctx = CypherParser.OC_StringListNullOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_oC_StringListNullOperatorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1007
            self.oC_PropertyOrLabelsExpression()
            self.state = 1013
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,174,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1011
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
                    if la_ == 1:
                        self.state = 1008
                        self.oC_StringOperatorExpression()
                        pass

                    elif la_ == 2:
                        self.state = 1009
                        self.oC_ListOperatorExpression()
                        pass

                    elif la_ == 3:
                        self.state = 1010
                        self.oC_NullOperatorExpression()
                        pass

             
                self.state = 1015
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,174,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_ListOperatorExpressionContext(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_PropertyOrLabelsExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_PropertyOrLabelsExpressionContext,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 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, 120, self.RULE_oC_ListOperatorExpression)
        self._la = 0 # Token type
        try:
            self.state = 1041
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1016
                self.match(CypherParser.SP)
                self.state = 1017
                self.match(CypherParser.IN)
                self.state = 1019
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1018
                    self.match(CypherParser.SP)


                self.state = 1021
                self.oC_PropertyOrLabelsExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1023
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1022
                    self.match(CypherParser.SP)


                self.state = 1025
                self.match(CypherParser.T__7)
                self.state = 1026
                self.oC_Expression()
                self.state = 1027
                self.match(CypherParser.T__8)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1030
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1029
                    self.match(CypherParser.SP)


                self.state = 1032
                self.match(CypherParser.T__7)
                self.state = 1034
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__5) | (1 << CypherParser.T__7) | (1 << CypherParser.T__12) | (1 << CypherParser.T__13) | (1 << CypherParser.T__22) | (1 << CypherParser.T__25) | (1 << CypherParser.ALL))) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CypherParser.NOT - 76)) | (1 << (CypherParser.NULL - 76)) | (1 << (CypherParser.COUNT - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.CASE - 76)) | (1 << (CypherParser.StringLiteral - 76)) | (1 << (CypherParser.HexInteger - 76)) | (1 << (CypherParser.DecimalInteger - 76)) | (1 << (CypherParser.OctalInteger - 76)) | (1 << (CypherParser.HexLetter - 76)) | (1 << (CypherParser.ExponentDecimalReal - 76)) | (1 << (CypherParser.RegularDecimalReal - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                    self.state = 1033
                    self.oC_Expression()


                self.state = 1036
                self.match(CypherParser.T__11)
                self.state = 1038
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__5) | (1 << CypherParser.T__7) | (1 << CypherParser.T__12) | (1 << CypherParser.T__13) | (1 << CypherParser.T__22) | (1 << CypherParser.T__25) | (1 << CypherParser.ALL))) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CypherParser.NOT - 76)) | (1 << (CypherParser.NULL - 76)) | (1 << (CypherParser.COUNT - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.CASE - 76)) | (1 << (CypherParser.StringLiteral - 76)) | (1 << (CypherParser.HexInteger - 76)) | (1 << (CypherParser.DecimalInteger - 76)) | (1 << (CypherParser.OctalInteger - 76)) | (1 << (CypherParser.HexLetter - 76)) | (1 << (CypherParser.ExponentDecimalReal - 76)) | (1 << (CypherParser.RegularDecimalReal - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                    self.state = 1037
                    self.oC_Expression()


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

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

        def oC_PropertyOrLabelsExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_PropertyOrLabelsExpressionContext,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_StringOperatorExpression

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

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

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




    def oC_StringOperatorExpression(self):

        localctx = CypherParser.OC_StringOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_oC_StringOperatorExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1053
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
            if la_ == 1:
                self.state = 1043
                self.match(CypherParser.SP)
                self.state = 1044
                self.match(CypherParser.STARTS)
                self.state = 1045
                self.match(CypherParser.SP)
                self.state = 1046
                self.match(CypherParser.WITH)
                pass

            elif la_ == 2:
                self.state = 1047
                self.match(CypherParser.SP)
                self.state = 1048
                self.match(CypherParser.ENDS)
                self.state = 1049
                self.match(CypherParser.SP)
                self.state = 1050
                self.match(CypherParser.WITH)
                pass

            elif la_ == 3:
                self.state = 1051
                self.match(CypherParser.SP)
                self.state = 1052
                self.match(CypherParser.CONTAINS)
                pass


            self.state = 1056
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1055
                self.match(CypherParser.SP)


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


    class OC_NullOperatorExpressionContext(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_NullOperatorExpression

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

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

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




    def oC_NullOperatorExpression(self):

        localctx = CypherParser.OC_NullOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_oC_NullOperatorExpression)
        try:
            self.state = 1070
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1060
                self.match(CypherParser.SP)
                self.state = 1061
                self.match(CypherParser.IS)
                self.state = 1062
                self.match(CypherParser.SP)
                self.state = 1063
                self.match(CypherParser.NULL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1064
                self.match(CypherParser.SP)
                self.state = 1065
                self.match(CypherParser.IS)
                self.state = 1066
                self.match(CypherParser.SP)
                self.state = 1067
                self.match(CypherParser.NOT)
                self.state = 1068
                self.match(CypherParser.SP)
                self.state = 1069
                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_PropertyOrLabelsExpressionContext(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 oC_NodeLabels(self):
            return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext,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_PropertyOrLabelsExpression

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

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

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




    def oC_PropertyOrLabelsExpression(self):

        localctx = CypherParser.OC_PropertyOrLabelsExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_oC_PropertyOrLabelsExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1072
            self.oC_Atom()
            self.state = 1079
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,185,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1074
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1073
                        self.match(CypherParser.SP)


                    self.state = 1076
                    self.oC_PropertyLookup() 
                self.state = 1081
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,185,self._ctx)

            self.state = 1086
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
            if la_ == 1:
                self.state = 1083
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1082
                    self.match(CypherParser.SP)


                self.state = 1085
                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_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 ALL(self):
            return self.getToken(CypherParser.ALL, 0)

        def oC_FilterExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_FilterExpressionContext,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 oC_RelationshipsPattern(self):
            return self.getTypedRuleContext(CypherParser.OC_RelationshipsPatternContext,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, 128, self.RULE_oC_Atom)
        self._la = 0 # Token type
        try:
            self.state = 1167
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1088
                self.oC_Literal()
                pass

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

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

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1091
                self.match(CypherParser.COUNT)
                self.state = 1093
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1092
                    self.match(CypherParser.SP)


                self.state = 1095
                self.match(CypherParser.T__5)
                self.state = 1097
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1096
                    self.match(CypherParser.SP)


                self.state = 1099
                self.match(CypherParser.T__4)
                self.state = 1101
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1100
                    self.match(CypherParser.SP)


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

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

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

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1106
                self.match(CypherParser.ALL)
                self.state = 1108
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1107
                    self.match(CypherParser.SP)


                self.state = 1110
                self.match(CypherParser.T__5)
                self.state = 1112
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1111
                    self.match(CypherParser.SP)


                self.state = 1114
                self.oC_FilterExpression()
                self.state = 1116
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1115
                    self.match(CypherParser.SP)


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

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1120
                self.match(CypherParser.ANY)
                self.state = 1122
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1121
                    self.match(CypherParser.SP)


                self.state = 1124
                self.match(CypherParser.T__5)
                self.state = 1126
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1125
                    self.match(CypherParser.SP)


                self.state = 1128
                self.oC_FilterExpression()
                self.state = 1130
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1129
                    self.match(CypherParser.SP)


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

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1134
                self.match(CypherParser.NONE)
                self.state = 1136
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1135
                    self.match(CypherParser.SP)


                self.state = 1138
                self.match(CypherParser.T__5)
                self.state = 1140
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1139
                    self.match(CypherParser.SP)


                self.state = 1142
                self.oC_FilterExpression()
                self.state = 1144
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1143
                    self.match(CypherParser.SP)


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

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1148
                self.match(CypherParser.SINGLE)
                self.state = 1150
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1149
                    self.match(CypherParser.SP)


                self.state = 1152
                self.match(CypherParser.T__5)
                self.state = 1154
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1153
                    self.match(CypherParser.SP)


                self.state = 1156
                self.oC_FilterExpression()
                self.state = 1158
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1157
                    self.match(CypherParser.SP)


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

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1162
                self.oC_RelationshipsPattern()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1163
                self.oC_ParenthesizedExpression()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1164
                self.oC_FunctionInvocation()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1165
                self.oC_ExistentialSubquery()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1166
                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_LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_NumberLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_NumberLiteralContext,0)


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

        def oC_BooleanLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_BooleanLiteralContext,0)


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

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


        def oC_ListLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_ListLiteralContext,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, 130, self.RULE_oC_Literal)
        try:
            self.state = 1175
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger, CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1169
                self.oC_NumberLiteral()
                pass
            elif token in [CypherParser.StringLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1170
                self.match(CypherParser.StringLiteral)
                pass
            elif token in [CypherParser.TRUE, CypherParser.FALSE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1171
                self.oC_BooleanLiteral()
                pass
            elif token in [CypherParser.NULL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1172
                self.match(CypherParser.NULL)
                pass
            elif token in [CypherParser.T__22]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1173
                self.oC_MapLiteral()
                pass
            elif token in [CypherParser.T__7]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1174
                self.oC_ListLiteral()
                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, 132, self.RULE_oC_BooleanLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1177
            _la = self._input.LA(1)
            if not(_la==CypherParser.TRUE or _la==CypherParser.FALSE):
                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, 134, self.RULE_oC_ListLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1179
            self.match(CypherParser.T__7)
            self.state = 1181
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1180
                self.match(CypherParser.SP)


            self.state = 1200
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__5) | (1 << CypherParser.T__7) | (1 << CypherParser.T__12) | (1 << CypherParser.T__13) | (1 << CypherParser.T__22) | (1 << CypherParser.T__25) | (1 << CypherParser.ALL))) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CypherParser.NOT - 76)) | (1 << (CypherParser.NULL - 76)) | (1 << (CypherParser.COUNT - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.CASE - 76)) | (1 << (CypherParser.StringLiteral - 76)) | (1 << (CypherParser.HexInteger - 76)) | (1 << (CypherParser.DecimalInteger - 76)) | (1 << (CypherParser.OctalInteger - 76)) | (1 << (CypherParser.HexLetter - 76)) | (1 << (CypherParser.ExponentDecimalReal - 76)) | (1 << (CypherParser.RegularDecimalReal - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                self.state = 1183
                self.oC_Expression()
                self.state = 1185
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1184
                    self.match(CypherParser.SP)


                self.state = 1197
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CypherParser.T__1:
                    self.state = 1187
                    self.match(CypherParser.T__1)
                    self.state = 1189
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1188
                        self.match(CypherParser.SP)


                    self.state = 1191
                    self.oC_Expression()
                    self.state = 1193
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1192
                        self.match(CypherParser.SP)


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



            self.state = 1202
            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_PartialComparisonExpressionContext(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):
            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, 136, self.RULE_oC_PartialComparisonExpression)
        self._la = 0 # Token type
        try:
            self.state = 1234
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__2]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1204
                self.match(CypherParser.T__2)
                self.state = 1206
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1205
                    self.match(CypherParser.SP)


                self.state = 1208
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [CypherParser.T__17]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1209
                self.match(CypherParser.T__17)
                self.state = 1211
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1210
                    self.match(CypherParser.SP)


                self.state = 1213
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [CypherParser.T__18]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1214
                self.match(CypherParser.T__18)
                self.state = 1216
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1215
                    self.match(CypherParser.SP)


                self.state = 1218
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [CypherParser.T__19]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1219
                self.match(CypherParser.T__19)
                self.state = 1221
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1220
                    self.match(CypherParser.SP)


                self.state = 1223
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [CypherParser.T__20]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1224
                self.match(CypherParser.T__20)
                self.state = 1226
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1225
                    self.match(CypherParser.SP)


                self.state = 1228
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [CypherParser.T__21]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1229
                self.match(CypherParser.T__21)
                self.state = 1231
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1230
                    self.match(CypherParser.SP)


                self.state = 1233
                self.oC_AddOrSubtractExpression()
                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_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, 138, self.RULE_oC_ParenthesizedExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1236
            self.match(CypherParser.T__5)
            self.state = 1238
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1237
                self.match(CypherParser.SP)


            self.state = 1240
            self.oC_Expression()
            self.state = 1242
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1241
                self.match(CypherParser.SP)


            self.state = 1244
            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_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, 140, self.RULE_oC_RelationshipsPattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1246
            self.oC_NodePattern()
            self.state = 1251 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1248
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1247
                        self.match(CypherParser.SP)


                    self.state = 1250
                    self.oC_PatternElementChain()

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

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


    class 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, 142, self.RULE_oC_FilterExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1255
            self.oC_IdInColl()
            self.state = 1260
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
            if la_ == 1:
                self.state = 1257
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1256
                    self.match(CypherParser.SP)


                self.state = 1259
                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_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, 144, self.RULE_oC_IdInColl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1262
            self.oC_Variable()
            self.state = 1263
            self.match(CypherParser.SP)
            self.state = 1264
            self.match(CypherParser.IN)
            self.state = 1265
            self.match(CypherParser.SP)
            self.state = 1266
            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 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, 146, self.RULE_oC_FunctionInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1268
            self.oC_FunctionName()
            self.state = 1270
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1269
                self.match(CypherParser.SP)


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


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




            self.state = 1299
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__5) | (1 << CypherParser.T__7) | (1 << CypherParser.T__12) | (1 << CypherParser.T__13) | (1 << CypherParser.T__22) | (1 << CypherParser.T__25) | (1 << CypherParser.ALL))) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CypherParser.NOT - 76)) | (1 << (CypherParser.NULL - 76)) | (1 << (CypherParser.COUNT - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.CASE - 76)) | (1 << (CypherParser.StringLiteral - 76)) | (1 << (CypherParser.HexInteger - 76)) | (1 << (CypherParser.DecimalInteger - 76)) | (1 << (CypherParser.OctalInteger - 76)) | (1 << (CypherParser.HexLetter - 76)) | (1 << (CypherParser.ExponentDecimalReal - 76)) | (1 << (CypherParser.RegularDecimalReal - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                self.state = 1282
                self.oC_Expression()
                self.state = 1284
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1283
                    self.match(CypherParser.SP)


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


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


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



            self.state = 1301
            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, 148, self.RULE_oC_FunctionName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1303
            self.oC_Namespace()
            self.state = 1304
            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, 150, self.RULE_oC_ExistentialSubquery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1306
            self.match(CypherParser.EXISTS)
            self.state = 1308
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1307
                self.match(CypherParser.SP)


            self.state = 1310
            self.match(CypherParser.T__22)
            self.state = 1312
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1311
                self.match(CypherParser.SP)


            self.state = 1322
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.OPTIONAL, CypherParser.MATCH, CypherParser.UNWIND, CypherParser.MERGE, CypherParser.CREATE, CypherParser.SET, CypherParser.DETACH, CypherParser.DELETE, CypherParser.REMOVE, CypherParser.CALL, CypherParser.WITH, CypherParser.RETURN]:
                self.state = 1314
                self.oC_RegularQuery()
                pass
            elif token in [CypherParser.T__5, CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.state = 1315
                self.oC_Pattern()
                self.state = 1320
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,236,self._ctx)
                if la_ == 1:
                    self.state = 1317
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1316
                        self.match(CypherParser.SP)


                    self.state = 1319
                    self.oC_Where()


                pass
            else:
                raise NoViableAltException(self)

            self.state = 1325
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1324
                self.match(CypherParser.SP)


            self.state = 1327
            self.match(CypherParser.T__23)
        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, 152, self.RULE_oC_ExplicitProcedureInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1329
            self.oC_ProcedureName()
            self.state = 1331
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1330
                self.match(CypherParser.SP)


            self.state = 1333
            self.match(CypherParser.T__5)
            self.state = 1335
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1334
                self.match(CypherParser.SP)


            self.state = 1354
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__5) | (1 << CypherParser.T__7) | (1 << CypherParser.T__12) | (1 << CypherParser.T__13) | (1 << CypherParser.T__22) | (1 << CypherParser.T__25) | (1 << CypherParser.ALL))) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CypherParser.NOT - 76)) | (1 << (CypherParser.NULL - 76)) | (1 << (CypherParser.COUNT - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.CASE - 76)) | (1 << (CypherParser.StringLiteral - 76)) | (1 << (CypherParser.HexInteger - 76)) | (1 << (CypherParser.DecimalInteger - 76)) | (1 << (CypherParser.OctalInteger - 76)) | (1 << (CypherParser.HexLetter - 76)) | (1 << (CypherParser.ExponentDecimalReal - 76)) | (1 << (CypherParser.RegularDecimalReal - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                self.state = 1337
                self.oC_Expression()
                self.state = 1339
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1338
                    self.match(CypherParser.SP)


                self.state = 1351
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CypherParser.T__1:
                    self.state = 1341
                    self.match(CypherParser.T__1)
                    self.state = 1343
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1342
                        self.match(CypherParser.SP)


                    self.state = 1345
                    self.oC_Expression()
                    self.state = 1347
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1346
                        self.match(CypherParser.SP)


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



            self.state = 1356
            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, 154, self.RULE_oC_ImplicitProcedureInvocation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1358
            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, 156, self.RULE_oC_ProcedureResultField)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1360
            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, 158, self.RULE_oC_ProcedureName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1362
            self.oC_Namespace()
            self.state = 1363
            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, 160, self.RULE_oC_Namespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1370
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,246,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1365
                    self.oC_SymbolicName()
                    self.state = 1366
                    self.match(CypherParser.T__24) 
                self.state = 1372
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,246,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_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, 162, self.RULE_oC_ListComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1373
            self.match(CypherParser.T__7)
            self.state = 1375
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1374
                self.match(CypherParser.SP)


            self.state = 1377
            self.oC_FilterExpression()
            self.state = 1386
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,250,self._ctx)
            if la_ == 1:
                self.state = 1379
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1378
                    self.match(CypherParser.SP)


                self.state = 1381
                self.match(CypherParser.T__10)
                self.state = 1383
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1382
                    self.match(CypherParser.SP)


                self.state = 1385
                self.oC_Expression()


            self.state = 1389
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1388
                self.match(CypherParser.SP)


            self.state = 1391
            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, 164, self.RULE_oC_PatternComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1393
            self.match(CypherParser.T__7)
            self.state = 1395
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1394
                self.match(CypherParser.SP)


            self.state = 1405
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (CypherParser.COUNT - 83)) | (1 << (CypherParser.ANY - 83)) | (1 << (CypherParser.NONE - 83)) | (1 << (CypherParser.SINGLE - 83)) | (1 << (CypherParser.HexLetter - 83)) | (1 << (CypherParser.FILTER - 83)) | (1 << (CypherParser.EXTRACT - 83)) | (1 << (CypherParser.UnescapedSymbolicName - 83)) | (1 << (CypherParser.EscapedSymbolicName - 83)))) != 0):
                self.state = 1397
                self.oC_Variable()
                self.state = 1399
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1398
                    self.match(CypherParser.SP)


                self.state = 1401
                self.match(CypherParser.T__2)
                self.state = 1403
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1402
                    self.match(CypherParser.SP)




            self.state = 1407
            self.oC_RelationshipsPattern()
            self.state = 1409
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1408
                self.match(CypherParser.SP)


            self.state = 1415
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.WHERE:
                self.state = 1411
                self.oC_Where()
                self.state = 1413
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1412
                    self.match(CypherParser.SP)




            self.state = 1417
            self.match(CypherParser.T__10)
            self.state = 1419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1418
                self.match(CypherParser.SP)


            self.state = 1421
            self.oC_Expression()
            self.state = 1423
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1422
                self.match(CypherParser.SP)


            self.state = 1425
            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_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, 166, self.RULE_oC_PropertyLookup)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1427
            self.match(CypherParser.T__24)
            self.state = 1429
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1428
                self.match(CypherParser.SP)


            self.state = 1431
            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_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, 168, self.RULE_oC_CaseExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,267,self._ctx)
            if la_ == 1:
                self.state = 1433
                self.match(CypherParser.CASE)
                self.state = 1438 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1435
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1434
                            self.match(CypherParser.SP)


                        self.state = 1437
                        self.oC_CaseAlternative()

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

                pass

            elif la_ == 2:
                self.state = 1442
                self.match(CypherParser.CASE)
                self.state = 1444
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1443
                    self.match(CypherParser.SP)


                self.state = 1446
                self.oC_Expression()
                self.state = 1451 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1448
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1447
                            self.match(CypherParser.SP)


                        self.state = 1450
                        self.oC_CaseAlternative()

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

                pass


            self.state = 1465
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,270,self._ctx)
            if la_ == 1:
                self.state = 1458
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1457
                    self.match(CypherParser.SP)


                self.state = 1460
                self.match(CypherParser.ELSE)
                self.state = 1462
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1461
                    self.match(CypherParser.SP)


                self.state = 1464
                self.oC_Expression()


            self.state = 1468
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1467
                self.match(CypherParser.SP)


            self.state = 1470
            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, 170, self.RULE_oC_CaseAlternative)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1472
            self.match(CypherParser.WHEN)
            self.state = 1474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1473
                self.match(CypherParser.SP)


            self.state = 1476
            self.oC_Expression()
            self.state = 1478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1477
                self.match(CypherParser.SP)


            self.state = 1480
            self.match(CypherParser.THEN)
            self.state = 1482
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1481
                self.match(CypherParser.SP)


            self.state = 1484
            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_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, 172, self.RULE_oC_Variable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1486
            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_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, 174, self.RULE_oC_NumberLiteral)
        try:
            self.state = 1490
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1488
                self.oC_DoubleLiteral()
                pass
            elif token in [CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1489
                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_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, 176, self.RULE_oC_MapLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1492
            self.match(CypherParser.T__22)
            self.state = 1494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1493
                self.match(CypherParser.SP)


            self.state = 1529
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.UNION) | (1 << CypherParser.ALL) | (1 << CypherParser.OPTIONAL) | (1 << CypherParser.MATCH) | (1 << CypherParser.UNWIND) | (1 << CypherParser.AS) | (1 << CypherParser.MERGE) | (1 << CypherParser.ON) | (1 << CypherParser.CREATE) | (1 << CypherParser.SET) | (1 << CypherParser.DETACH) | (1 << CypherParser.DELETE) | (1 << CypherParser.REMOVE) | (1 << CypherParser.WITH) | (1 << CypherParser.RETURN) | (1 << CypherParser.DISTINCT))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CypherParser.ORDER - 64)) | (1 << (CypherParser.BY - 64)) | (1 << (CypherParser.L_SKIP - 64)) | (1 << (CypherParser.LIMIT - 64)) | (1 << (CypherParser.ASCENDING - 64)) | (1 << (CypherParser.ASC - 64)) | (1 << (CypherParser.DESCENDING - 64)) | (1 << (CypherParser.DESC - 64)) | (1 << (CypherParser.WHERE - 64)) | (1 << (CypherParser.OR - 64)) | (1 << (CypherParser.XOR - 64)) | (1 << (CypherParser.AND - 64)) | (1 << (CypherParser.NOT - 64)) | (1 << (CypherParser.IN - 64)) | (1 << (CypherParser.STARTS - 64)) | (1 << (CypherParser.ENDS - 64)) | (1 << (CypherParser.CONTAINS - 64)) | (1 << (CypherParser.IS - 64)) | (1 << (CypherParser.NULL - 64)) | (1 << (CypherParser.COUNT - 64)) | (1 << (CypherParser.ANY - 64)) | (1 << (CypherParser.NONE - 64)) | (1 << (CypherParser.SINGLE - 64)) | (1 << (CypherParser.TRUE - 64)) | (1 << (CypherParser.FALSE - 64)) | (1 << (CypherParser.EXISTS - 64)) | (1 << (CypherParser.CASE - 64)) | (1 << (CypherParser.ELSE - 64)) | (1 << (CypherParser.END - 64)) | (1 << (CypherParser.WHEN - 64)) | (1 << (CypherParser.THEN - 64)) | (1 << (CypherParser.HexLetter - 64)) | (1 << (CypherParser.CONSTRAINT - 64)) | (1 << (CypherParser.DO - 64)) | (1 << (CypherParser.FOR - 64)) | (1 << (CypherParser.REQUIRE - 64)) | (1 << (CypherParser.UNIQUE - 64)) | (1 << (CypherParser.MANDATORY - 64)) | (1 << (CypherParser.SCALAR - 64)) | (1 << (CypherParser.OF - 64)) | (1 << (CypherParser.ADD - 64)) | (1 << (CypherParser.DROP - 64)) | (1 << (CypherParser.FILTER - 64)) | (1 << (CypherParser.EXTRACT - 64)) | (1 << (CypherParser.UnescapedSymbolicName - 64)) | (1 << (CypherParser.EscapedSymbolicName - 64)))) != 0):
                self.state = 1496
                self.oC_PropertyKeyName()
                self.state = 1498
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1497
                    self.match(CypherParser.SP)


                self.state = 1500
                self.match(CypherParser.T__9)
                self.state = 1502
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1501
                    self.match(CypherParser.SP)


                self.state = 1504
                self.oC_Expression()
                self.state = 1506
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1505
                    self.match(CypherParser.SP)


                self.state = 1526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CypherParser.T__1:
                    self.state = 1508
                    self.match(CypherParser.T__1)
                    self.state = 1510
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1509
                        self.match(CypherParser.SP)


                    self.state = 1512
                    self.oC_PropertyKeyName()
                    self.state = 1514
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1513
                        self.match(CypherParser.SP)


                    self.state = 1516
                    self.match(CypherParser.T__9)
                    self.state = 1518
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1517
                        self.match(CypherParser.SP)


                    self.state = 1520
                    self.oC_Expression()
                    self.state = 1522
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1521
                        self.match(CypherParser.SP)


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



            self.state = 1531
            self.match(CypherParser.T__23)
        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, 178, self.RULE_oC_Parameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1533
            self.match(CypherParser.T__25)
            self.state = 1536
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.state = 1534
                self.oC_SymbolicName()
                pass
            elif token in [CypherParser.DecimalInteger]:
                self.state = 1535
                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_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, 180, self.RULE_oC_PropertyExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1538
            self.oC_Atom()
            self.state = 1543 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1540
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1539
                        self.match(CypherParser.SP)


                    self.state = 1542
                    self.oC_PropertyLookup()

                else:
                    raise NoViableAltException(self)
                self.state = 1545 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,288,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_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, 182, self.RULE_oC_PropertyKeyName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1547
            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_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 = 1549
            _la = self._input.LA(1)
            if not(((((_la - 97)) & ~0x3f) == 0 and ((1 << (_la - 97)) & ((1 << (CypherParser.HexInteger - 97)) | (1 << (CypherParser.DecimalInteger - 97)) | (1 << (CypherParser.OctalInteger - 97)))) != 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 = 1551
            _la = self._input.LA(1)
            if not(_la==CypherParser.ExponentDecimalReal or _la==CypherParser.RegularDecimalReal):
                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_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, 188, self.RULE_oC_SchemaName)
        try:
            self.state = 1555
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1553
                self.oC_SymbolicName()
                pass
            elif token in [CypherParser.UNION, CypherParser.ALL, CypherParser.OPTIONAL, CypherParser.MATCH, CypherParser.UNWIND, CypherParser.AS, CypherParser.MERGE, CypherParser.ON, CypherParser.CREATE, CypherParser.SET, CypherParser.DETACH, CypherParser.DELETE, CypherParser.REMOVE, CypherParser.WITH, CypherParser.RETURN, CypherParser.DISTINCT, CypherParser.ORDER, CypherParser.BY, CypherParser.L_SKIP, CypherParser.LIMIT, CypherParser.ASCENDING, CypherParser.ASC, CypherParser.DESCENDING, CypherParser.DESC, CypherParser.WHERE, CypherParser.OR, CypherParser.XOR, CypherParser.AND, CypherParser.NOT, CypherParser.IN, CypherParser.STARTS, CypherParser.ENDS, CypherParser.CONTAINS, CypherParser.IS, CypherParser.NULL, CypherParser.TRUE, CypherParser.FALSE, CypherParser.EXISTS, CypherParser.CASE, CypherParser.ELSE, CypherParser.END, CypherParser.WHEN, CypherParser.THEN, CypherParser.CONSTRAINT, CypherParser.DO, CypherParser.FOR, CypherParser.REQUIRE, CypherParser.UNIQUE, CypherParser.MANDATORY, CypherParser.SCALAR, CypherParser.OF, CypherParser.ADD, CypherParser.DROP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1554
                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, 190, self.RULE_oC_ReservedWord)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1557
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.UNION) | (1 << CypherParser.ALL) | (1 << CypherParser.OPTIONAL) | (1 << CypherParser.MATCH) | (1 << CypherParser.UNWIND) | (1 << CypherParser.AS) | (1 << CypherParser.MERGE) | (1 << CypherParser.ON) | (1 << CypherParser.CREATE) | (1 << CypherParser.SET) | (1 << CypherParser.DETACH) | (1 << CypherParser.DELETE) | (1 << CypherParser.REMOVE) | (1 << CypherParser.WITH) | (1 << CypherParser.RETURN) | (1 << CypherParser.DISTINCT))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CypherParser.ORDER - 64)) | (1 << (CypherParser.BY - 64)) | (1 << (CypherParser.L_SKIP - 64)) | (1 << (CypherParser.LIMIT - 64)) | (1 << (CypherParser.ASCENDING - 64)) | (1 << (CypherParser.ASC - 64)) | (1 << (CypherParser.DESCENDING - 64)) | (1 << (CypherParser.DESC - 64)) | (1 << (CypherParser.WHERE - 64)) | (1 << (CypherParser.OR - 64)) | (1 << (CypherParser.XOR - 64)) | (1 << (CypherParser.AND - 64)) | (1 << (CypherParser.NOT - 64)) | (1 << (CypherParser.IN - 64)) | (1 << (CypherParser.STARTS - 64)) | (1 << (CypherParser.ENDS - 64)) | (1 << (CypherParser.CONTAINS - 64)) | (1 << (CypherParser.IS - 64)) | (1 << (CypherParser.NULL - 64)) | (1 << (CypherParser.TRUE - 64)) | (1 << (CypherParser.FALSE - 64)) | (1 << (CypherParser.EXISTS - 64)) | (1 << (CypherParser.CASE - 64)) | (1 << (CypherParser.ELSE - 64)) | (1 << (CypherParser.END - 64)) | (1 << (CypherParser.WHEN - 64)) | (1 << (CypherParser.THEN - 64)) | (1 << (CypherParser.CONSTRAINT - 64)) | (1 << (CypherParser.DO - 64)) | (1 << (CypherParser.FOR - 64)) | (1 << (CypherParser.REQUIRE - 64)) | (1 << (CypherParser.UNIQUE - 64)) | (1 << (CypherParser.MANDATORY - 64)) | (1 << (CypherParser.SCALAR - 64)) | (1 << (CypherParser.OF - 64)) | (1 << (CypherParser.ADD - 64)) | (1 << (CypherParser.DROP - 64)))) != 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, 192, self.RULE_oC_SymbolicName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1559
            _la = self._input.LA(1)
            if not(((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (CypherParser.COUNT - 83)) | (1 << (CypherParser.ANY - 83)) | (1 << (CypherParser.NONE - 83)) | (1 << (CypherParser.SINGLE - 83)) | (1 << (CypherParser.HexLetter - 83)) | (1 << (CypherParser.FILTER - 83)) | (1 << (CypherParser.EXTRACT - 83)) | (1 << (CypherParser.UnescapedSymbolicName - 83)) | (1 << (CypherParser.EscapedSymbolicName - 83)))) != 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, 194, self.RULE_oC_LeftArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1561
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__18) | (1 << CypherParser.T__26) | (1 << CypherParser.T__27) | (1 << CypherParser.T__28) | (1 << CypherParser.T__29))) != 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, 196, self.RULE_oC_RightArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1563
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__19) | (1 << CypherParser.T__30) | (1 << CypherParser.T__31) | (1 << CypherParser.T__32) | (1 << CypherParser.T__33))) != 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, 198, self.RULE_oC_Dash)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1565
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__13) | (1 << CypherParser.T__34) | (1 << CypherParser.T__35) | (1 << CypherParser.T__36) | (1 << CypherParser.T__37) | (1 << CypherParser.T__38) | (1 << CypherParser.T__39) | (1 << CypherParser.T__40) | (1 << CypherParser.T__41) | (1 << CypherParser.T__42) | (1 << CypherParser.T__43) | (1 << CypherParser.T__44))) != 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





