# Generated from ./Cypher.g4 by ANTLR 4.9.3
# 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():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0081")
        buf.write("\u0644\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
        buf.write("h\th\4i\ti\3\2\5\2\u00d4\n\2\3\2\3\2\5\2\u00d8\n\2\3\2")
        buf.write("\5\2\u00db\n\2\3\2\5\2\u00de\n\2\3\2\3\2\3\3\3\3\3\4\3")
        buf.write("\4\3\4\5\4\u00e7\n\4\3\5\3\5\5\5\u00eb\n\5\3\5\3\5\5\5")
        buf.write("\u00ef\n\5\3\5\3\5\5\5\u00f3\n\5\3\5\3\5\5\5\u00f7\n\5")
        buf.write("\3\5\3\5\3\6\3\6\5\6\u00fd\n\6\3\6\7\6\u0100\n\6\f\6\16")
        buf.write("\6\u0103\13\6\3\7\3\7\3\7\3\7\5\7\u0109\n\7\3\7\3\7\3")
        buf.write("\7\5\7\u010e\n\7\3\7\5\7\u0111\n\7\3\b\3\b\5\b\u0115\n")
        buf.write("\b\3\t\3\t\5\t\u0119\n\t\7\t\u011b\n\t\f\t\16\t\u011e")
        buf.write("\13\t\3\t\3\t\3\t\5\t\u0123\n\t\7\t\u0125\n\t\f\t\16\t")
        buf.write("\u0128\13\t\3\t\3\t\5\t\u012c\n\t\3\t\7\t\u012f\n\t\f")
        buf.write("\t\16\t\u0132\13\t\3\t\5\t\u0135\n\t\3\t\5\t\u0138\n\t")
        buf.write("\5\t\u013a\n\t\3\n\3\n\5\n\u013e\n\n\7\n\u0140\n\n\f\n")
        buf.write("\16\n\u0143\13\n\3\n\3\n\5\n\u0147\n\n\7\n\u0149\n\n\f")
        buf.write("\n\16\n\u014c\13\n\3\n\3\n\5\n\u0150\n\n\6\n\u0152\n\n")
        buf.write("\r\n\16\n\u0153\3\n\3\n\3\13\3\13\3\13\3\13\3\13\5\13")
        buf.write("\u015d\n\13\3\f\3\f\3\f\5\f\u0162\n\f\3\r\3\r\5\r\u0166")
        buf.write("\n\r\3\r\3\r\5\r\u016a\n\r\3\r\3\r\5\r\u016e\n\r\3\r\5")
        buf.write("\r\u0171\n\r\3\16\3\16\5\16\u0175\n\16\3\16\3\16\3\16")
        buf.write("\3\16\3\16\3\16\3\17\3\17\5\17\u017f\n\17\3\17\3\17\3")
        buf.write("\17\7\17\u0184\n\17\f\17\16\17\u0187\13\17\3\20\3\20\3")
        buf.write("\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u0193\n\20")
        buf.write("\3\21\3\21\5\21\u0197\n\21\3\21\3\21\3\22\3\22\5\22\u019d")
        buf.write("\n\22\3\22\3\22\5\22\u01a1\n\22\3\22\3\22\5\22\u01a5\n")
        buf.write("\22\3\22\7\22\u01a8\n\22\f\22\16\22\u01ab\13\22\3\23\3")
        buf.write("\23\5\23\u01af\n\23\3\23\3\23\5\23\u01b3\n\23\3\23\3\23")
        buf.write("\3\23\3\23\5\23\u01b9\n\23\3\23\3\23\5\23\u01bd\n\23\3")
        buf.write("\23\3\23\3\23\3\23\5\23\u01c3\n\23\3\23\3\23\5\23\u01c7")
        buf.write("\n\23\3\23\3\23\3\23\3\23\5\23\u01cd\n\23\3\23\3\23\5")
        buf.write("\23\u01d1\n\23\3\24\3\24\5\24\u01d5\n\24\3\24\3\24\5\24")
        buf.write("\u01d9\n\24\3\24\3\24\5\24\u01dd\n\24\3\24\3\24\5\24\u01e1")
        buf.write("\n\24\3\24\7\24\u01e4\n\24\f\24\16\24\u01e7\13\24\3\25")
        buf.write("\3\25\3\25\3\25\5\25\u01ed\n\25\3\25\3\25\5\25\u01f1\n")
        buf.write("\25\3\25\7\25\u01f4\n\25\f\25\16\25\u01f7\13\25\3\26\3")
        buf.write("\26\3\26\3\26\5\26\u01fd\n\26\3\27\3\27\3\27\3\27\5\27")
        buf.write("\u0203\n\27\3\27\3\27\3\27\5\27\u0208\n\27\3\30\3\30\3")
        buf.write("\30\3\30\5\30\u020e\n\30\3\30\5\30\u0211\n\30\3\30\3\30")
        buf.write("\3\30\3\30\5\30\u0217\n\30\5\30\u0219\n\30\3\31\3\31\5")
        buf.write("\31\u021d\n\31\3\31\3\31\5\31\u0221\n\31\3\31\7\31\u0224")
        buf.write("\n\31\f\31\16\31\u0227\13\31\3\31\5\31\u022a\n\31\3\31")
        buf.write("\5\31\u022d\n\31\3\32\3\32\3\32\3\32\3\32\5\32\u0234\n")
        buf.write("\32\3\32\3\32\3\33\3\33\3\33\5\33\u023b\n\33\3\33\5\33")
        buf.write("\u023e\n\33\3\34\3\34\3\34\3\35\5\35\u0244\n\35\3\35\5")
        buf.write("\35\u0247\n\35\3\35\3\35\3\35\3\35\5\35\u024d\n\35\3\35")
        buf.write("\3\35\5\35\u0251\n\35\3\35\3\35\5\35\u0255\n\35\3\36\3")
        buf.write("\36\5\36\u0259\n\36\3\36\3\36\5\36\u025d\n\36\3\36\7\36")
        buf.write("\u0260\n\36\f\36\16\36\u0263\13\36\3\36\3\36\5\36\u0267")
        buf.write("\n\36\3\36\3\36\5\36\u026b\n\36\3\36\7\36\u026e\n\36\f")
        buf.write("\36\16\36\u0271\13\36\5\36\u0273\n\36\3\37\3\37\3\37\3")
        buf.write("\37\3\37\3\37\3\37\5\37\u027c\n\37\3 \3 \3 \3 \3 \3 \3")
        buf.write(" \5 \u0285\n \3 \7 \u0288\n \f \16 \u028b\13 \3!\3!\3")
        buf.write("!\3!\3\"\3\"\3\"\3\"\3#\3#\5#\u0297\n#\3#\5#\u029a\n#")
        buf.write("\3$\3$\3$\3$\3%\3%\5%\u02a2\n%\3%\3%\5%\u02a6\n%\3%\7")
        buf.write("%\u02a9\n%\f%\16%\u02ac\13%\3&\3&\5&\u02b0\n&\3&\3&\5")
        buf.write("&\u02b4\n&\3&\3&\3&\5&\u02b9\n&\3\'\3\'\3(\3(\5(\u02bf")
        buf.write("\n(\3(\7(\u02c2\n(\f(\16(\u02c5\13(\3(\3(\3(\3(\5(\u02cb")
        buf.write("\n(\3)\3)\5)\u02cf\n)\3)\6)\u02d2\n)\r)\16)\u02d3\3*\3")
        buf.write("*\5*\u02d8\n*\3*\3*\5*\u02dc\n*\5*\u02de\n*\3*\3*\5*\u02e2")
        buf.write("\n*\5*\u02e4\n*\3*\3*\5*\u02e8\n*\5*\u02ea\n*\3*\3*\3")
        buf.write("+\3+\5+\u02f0\n+\3+\3+\3,\3,\5,\u02f6\n,\3,\3,\5,\u02fa")
        buf.write("\n,\3,\5,\u02fd\n,\3,\5,\u0300\n,\3,\3,\5,\u0304\n,\3")
        buf.write(",\3,\3,\3,\5,\u030a\n,\3,\3,\5,\u030e\n,\3,\5,\u0311\n")
        buf.write(",\3,\5,\u0314\n,\3,\3,\3,\3,\5,\u031a\n,\3,\5,\u031d\n")
        buf.write(",\3,\5,\u0320\n,\3,\3,\5,\u0324\n,\3,\3,\3,\3,\5,\u032a")
        buf.write("\n,\3,\5,\u032d\n,\3,\5,\u0330\n,\3,\3,\5,\u0334\n,\3")
        buf.write("-\3-\5-\u0338\n-\3-\3-\5-\u033c\n-\5-\u033e\n-\3-\3-\5")
        buf.write("-\u0342\n-\5-\u0344\n-\3-\5-\u0347\n-\3-\3-\5-\u034b\n")
        buf.write("-\5-\u034d\n-\3-\3-\3.\3.\5.\u0353\n.\3/\3/\5/\u0357\n")
        buf.write("/\3/\3/\5/\u035b\n/\3/\3/\5/\u035f\n/\3/\5/\u0362\n/\3")
        buf.write("/\7/\u0365\n/\f/\16/\u0368\13/\3\60\3\60\5\60\u036c\n")
        buf.write("\60\3\60\7\60\u036f\n\60\f\60\16\60\u0372\13\60\3\61\3")
        buf.write("\61\5\61\u0376\n\61\3\61\3\61\3\62\3\62\5\62\u037c\n\62")
        buf.write("\3\62\3\62\5\62\u0380\n\62\5\62\u0382\n\62\3\62\3\62\5")
        buf.write("\62\u0386\n\62\3\62\3\62\5\62\u038a\n\62\5\62\u038c\n")
        buf.write("\62\5\62\u038e\n\62\3\63\3\63\3\64\3\64\3\65\3\65\5\65")
        buf.write("\u0396\n\65\3\65\6\65\u0399\n\65\r\65\16\65\u039a\3\66")
        buf.write("\3\66\3\67\3\67\3\67\3\67\3\67\7\67\u03a4\n\67\f\67\16")
        buf.write("\67\u03a7\13\67\38\38\38\38\38\78\u03ae\n8\f8\168\u03b1")
        buf.write("\138\39\39\39\39\39\79\u03b8\n9\f9\169\u03bb\139\3:\3")
        buf.write(":\5:\u03bf\n:\7:\u03c1\n:\f:\16:\u03c4\13:\3:\3:\3;\3")
        buf.write(";\5;\u03ca\n;\3;\7;\u03cd\n;\f;\16;\u03d0\13;\3<\3<\5")
        buf.write("<\u03d4\n<\3<\3<\3<\5<\u03d9\n<\3<\3<\3<\5<\u03de\n<\3")
        buf.write("<\3<\3<\5<\u03e3\n<\3<\3<\3<\5<\u03e8\n<\3<\3<\3<\5<\u03ed")
        buf.write("\n<\3<\5<\u03f0\n<\3=\3=\3=\3=\7=\u03f6\n=\f=\16=\u03f9")
        buf.write("\13=\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\5>\u0405\n>\3>\5>\u0408")
        buf.write("\n>\3>\3>\3?\3?\3?\5?\u040f\n?\3?\3?\3@\3@\3@\3@\3@\3")
        buf.write("@\3@\3@\3@\3@\5@\u041d\n@\3A\3A\5A\u0421\nA\3A\3A\5A\u0425")
        buf.write("\nA\3A\3A\5A\u0429\nA\3A\3A\5A\u042d\nA\3A\7A\u0430\n")
        buf.write("A\fA\16A\u0433\13A\3B\3B\5B\u0437\nB\3B\3B\5B\u043b\n")
        buf.write("B\3B\3B\5B\u043f\nB\3B\3B\5B\u0443\nB\3B\3B\5B\u0447\n")
        buf.write("B\3B\3B\5B\u044b\nB\3B\7B\u044e\nB\fB\16B\u0451\13B\3")
        buf.write("C\3C\5C\u0455\nC\3C\3C\5C\u0459\nC\3C\7C\u045c\nC\fC\16")
        buf.write("C\u045f\13C\3D\3D\3D\5D\u0464\nD\3D\5D\u0467\nD\3E\3E")
        buf.write("\5E\u046b\nE\3E\3E\3E\3E\3E\5E\u0472\nE\3E\3E\5E\u0476")
        buf.write("\nE\3E\3E\5E\u047a\nE\3E\7E\u047d\nE\fE\16E\u0480\13E")
        buf.write("\3F\3F\5F\u0484\nF\3F\7F\u0487\nF\fF\16F\u048a\13F\3F")
        buf.write("\5F\u048d\nF\3F\5F\u0490\nF\3G\3G\5G\u0494\nG\3G\3G\3")
        buf.write("H\3H\3H\3H\3H\5H\u049d\nH\3H\3H\5H\u04a1\nH\3H\3H\5H\u04a5")
        buf.write("\nH\3H\3H\3H\3H\3H\3H\3H\3H\3H\5H\u04b0\nH\3I\3I\5I\u04b4")
        buf.write("\nI\3I\6I\u04b7\nI\rI\16I\u04b8\3I\3I\5I\u04bd\nI\3I\3")
        buf.write("I\5I\u04c1\nI\3I\6I\u04c4\nI\rI\16I\u04c5\5I\u04c8\nI")
        buf.write("\3I\5I\u04cb\nI\3I\3I\5I\u04cf\nI\3I\5I\u04d2\nI\3I\5")
        buf.write("I\u04d5\nI\3I\3I\3J\3J\5J\u04db\nJ\3J\3J\5J\u04df\nJ\3")
        buf.write("J\3J\5J\u04e3\nJ\3J\3J\3K\3K\5K\u04e9\nK\3K\3K\5K\u04ed")
        buf.write("\nK\3K\3K\5K\u04f1\nK\3K\5K\u04f4\nK\3K\5K\u04f7\nK\3")
        buf.write("K\3K\3L\3L\5L\u04fd\nL\3L\3L\5L\u0501\nL\3L\3L\5L\u0505")
        buf.write("\nL\5L\u0507\nL\3L\3L\5L\u050b\nL\3L\3L\5L\u050f\nL\5")
        buf.write("L\u0511\nL\3L\3L\5L\u0515\nL\3L\3L\5L\u0519\nL\3L\3L\3")
        buf.write("M\3M\5M\u051f\nM\3M\3M\5M\u0523\nM\3M\3M\5M\u0527\nM\3")
        buf.write("M\3M\3M\3M\5M\u052d\nM\3M\3M\5M\u0531\nM\3M\3M\5M\u0535")
        buf.write("\nM\3M\3M\3M\3M\5M\u053b\nM\3M\3M\5M\u053f\nM\3M\3M\5")
        buf.write("M\u0543\nM\3M\3M\3M\3M\5M\u0549\nM\3M\3M\5M\u054d\nM\3")
        buf.write("M\3M\5M\u0551\nM\3M\3M\5M\u0555\nM\3N\3N\5N\u0559\nN\3")
        buf.write("N\5N\u055c\nN\3O\3O\3P\3P\5P\u0562\nP\3P\3P\5P\u0566\n")
        buf.write("P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\5R\u0572\nR\3R\3R\5R\u0576")
        buf.write("\nR\3R\3R\5R\u057a\nR\5R\u057c\nR\3R\3R\5R\u0580\nR\3")
        buf.write("R\3R\5R\u0584\nR\3R\3R\5R\u0588\nR\7R\u058a\nR\fR\16R")
        buf.write("\u058d\13R\5R\u058f\nR\3R\3R\3S\3S\3S\3T\3T\5T\u0598\n")
        buf.write("T\3T\3T\5T\u059c\nT\3T\3T\3T\5T\u05a1\nT\3T\5T\u05a4\n")
        buf.write("T\5T\u05a6\nT\3T\5T\u05a9\nT\3T\3T\3U\3U\5U\u05af\nU\3")
        buf.write("U\3U\5U\u05b3\nU\3U\3U\5U\u05b7\nU\3U\3U\5U\u05bb\nU\3")
        buf.write("U\3U\5U\u05bf\nU\7U\u05c1\nU\fU\16U\u05c4\13U\5U\u05c6")
        buf.write("\nU\3U\3U\3V\3V\3W\3W\3X\3X\3X\3Y\3Y\3Y\7Y\u05d4\nY\f")
        buf.write("Y\16Y\u05d7\13Y\3Z\3Z\3[\3[\3[\3[\3[\3[\5[\u05e1\n[\3")
        buf.write("\\\3\\\3]\3]\5]\u05e7\n]\3^\3^\3_\3_\3`\3`\5`\u05ef\n")
        buf.write("`\3`\3`\5`\u05f3\n`\3`\3`\5`\u05f7\n`\3`\3`\5`\u05fb\n")
        buf.write("`\7`\u05fd\n`\f`\16`\u0600\13`\5`\u0602\n`\3`\3`\3a\3")
        buf.write("a\5a\u0608\na\3a\3a\5a\u060c\na\3a\3a\5a\u0610\na\3a\3")
        buf.write("a\5a\u0614\na\3a\3a\5a\u0618\na\3a\3a\5a\u061c\na\3a\3")
        buf.write("a\5a\u0620\na\3a\3a\5a\u0624\na\7a\u0626\na\fa\16a\u0629")
        buf.write("\13a\5a\u062b\na\3a\3a\3b\3b\3c\3c\3c\5c\u0634\nc\3d\3")
        buf.write("d\5d\u0638\nd\3e\3e\3f\3f\3g\3g\3h\3h\3i\3i\3i\2\2j\2")
        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
        buf.write("\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084")
        buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096")
        buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8")
        buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba")
        buf.write("\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc")
        buf.write("\u00ce\u00d0\2\f\3\2FI\3\2\26\27\3\2_`\3\2ac\3\2kl\7\2")
        buf.write("\60<?TVZ^`ox\7\2UU[]ddy{~~\4\2\22\22\35 \4\2\23\23!$\4")
        buf.write("\2\27\27%/\2\u0723\2\u00d3\3\2\2\2\4\u00e1\3\2\2\2\6\u00e6")
        buf.write("\3\2\2\2\b\u00e8\3\2\2\2\n\u00fa\3\2\2\2\f\u0110\3\2\2")
        buf.write("\2\16\u0114\3\2\2\2\20\u0139\3\2\2\2\22\u0151\3\2\2\2")
        buf.write("\24\u015c\3\2\2\2\26\u0161\3\2\2\2\30\u0165\3\2\2\2\32")
        buf.write("\u0172\3\2\2\2\34\u017c\3\2\2\2\36\u0192\3\2\2\2 \u0194")
        buf.write("\3\2\2\2\"\u019a\3\2\2\2$\u01d0\3\2\2\2&\u01d4\3\2\2\2")
        buf.write("(\u01e8\3\2\2\2*\u01fc\3\2\2\2,\u01fe\3\2\2\2.\u0209\3")
        buf.write("\2\2\2\60\u021a\3\2\2\2\62\u0233\3\2\2\2\64\u0237\3\2")
        buf.write("\2\2\66\u023f\3\2\2\28\u0246\3\2\2\2:\u0272\3\2\2\2<\u027b")
        buf.write("\3\2\2\2>\u027d\3\2\2\2@\u028c\3\2\2\2B\u0290\3\2\2\2")
        buf.write("D\u0294\3\2\2\2F\u029b\3\2\2\2H\u029f\3\2\2\2J\u02b8\3")
        buf.write("\2\2\2L\u02ba\3\2\2\2N\u02ca\3\2\2\2P\u02cc\3\2\2\2R\u02d5")
        buf.write("\3\2\2\2T\u02ed\3\2\2\2V\u0333\3\2\2\2X\u0335\3\2\2\2")
        buf.write("Z\u0352\3\2\2\2\\\u0354\3\2\2\2^\u0369\3\2\2\2`\u0373")
        buf.write("\3\2\2\2b\u0379\3\2\2\2d\u038f\3\2\2\2f\u0391\3\2\2\2")
        buf.write("h\u0393\3\2\2\2j\u039c\3\2\2\2l\u039e\3\2\2\2n\u03a8\3")
        buf.write("\2\2\2p\u03b2\3\2\2\2r\u03c2\3\2\2\2t\u03c7\3\2\2\2v\u03ef")
        buf.write("\3\2\2\2x\u03f1\3\2\2\2z\u0404\3\2\2\2|\u040b\3\2\2\2")
        buf.write("~\u041c\3\2\2\2\u0080\u041e\3\2\2\2\u0082\u0434\3\2\2")
        buf.write("\2\u0084\u0452\3\2\2\2\u0086\u0466\3\2\2\2\u0088\u0468")
        buf.write("\3\2\2\2\u008a\u0481\3\2\2\2\u008c\u0491\3\2\2\2\u008e")
        buf.write("\u04af\3\2\2\2\u0090\u04c7\3\2\2\2\u0092\u04d8\3\2\2\2")
        buf.write("\u0094\u04e6\3\2\2\2\u0096\u04fa\3\2\2\2\u0098\u0554\3")
        buf.write("\2\2\2\u009a\u0556\3\2\2\2\u009c\u055d\3\2\2\2\u009e\u055f")
        buf.write("\3\2\2\2\u00a0\u0569\3\2\2\2\u00a2\u056f\3\2\2\2\u00a4")
        buf.write("\u0592\3\2\2\2\u00a6\u0595\3\2\2\2\u00a8\u05ac\3\2\2\2")
        buf.write("\u00aa\u05c9\3\2\2\2\u00ac\u05cb\3\2\2\2\u00ae\u05cd\3")
        buf.write("\2\2\2\u00b0\u05d5\3\2\2\2\u00b2\u05d8\3\2\2\2\u00b4\u05e0")
        buf.write("\3\2\2\2\u00b6\u05e2\3\2\2\2\u00b8\u05e6\3\2\2\2\u00ba")
        buf.write("\u05e8\3\2\2\2\u00bc\u05ea\3\2\2\2\u00be\u05ec\3\2\2\2")
        buf.write("\u00c0\u0605\3\2\2\2\u00c2\u062e\3\2\2\2\u00c4\u0630\3")
        buf.write("\2\2\2\u00c6\u0637\3\2\2\2\u00c8\u0639\3\2\2\2\u00ca\u063b")
        buf.write("\3\2\2\2\u00cc\u063d\3\2\2\2\u00ce\u063f\3\2\2\2\u00d0")
        buf.write("\u0641\3\2\2\2\u00d2\u00d4\7\177\2\2\u00d3\u00d2\3\2\2")
        buf.write("\2\u00d3\u00d4\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00da")
        buf.write("\5\4\3\2\u00d6\u00d8\7\177\2\2\u00d7\u00d6\3\2\2\2\u00d7")
        buf.write("\u00d8\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00db\7\3\2\2")
        buf.write("\u00da\u00d7\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dd\3")
        buf.write("\2\2\2\u00dc\u00de\7\177\2\2\u00dd\u00dc\3\2\2\2\u00dd")
        buf.write("\u00de\3\2\2\2\u00de\u00df\3\2\2\2\u00df\u00e0\7\2\2\3")
        buf.write("\u00e0\3\3\2\2\2\u00e1\u00e2\5\6\4\2\u00e2\5\3\2\2\2\u00e3")
        buf.write("\u00e7\5\n\6\2\u00e4\u00e7\5.\30\2\u00e5\u00e7\5\b\5\2")
        buf.write("\u00e6\u00e3\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e6\u00e5\3")
        buf.write("\2\2\2\u00e7\7\3\2\2\2\u00e8\u00ea\7=\2\2\u00e9\u00eb")
        buf.write("\7\177\2\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb")
        buf.write("\u00ec\3\2\2\2\u00ec\u00ee\7\4\2\2\u00ed\u00ef\7\177\2")
        buf.write("\2\u00ee\u00ed\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0")
        buf.write("\3\2\2\2\u00f0\u00f2\5\n\6\2\u00f1\u00f3\7\177\2\2\u00f2")
        buf.write("\u00f1\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\3\2\2\2")
        buf.write("\u00f4\u00f6\7\5\2\2\u00f5\u00f7\7\177\2\2\u00f6\u00f5")
        buf.write("\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8")
        buf.write("\u00f9\5\n\6\2\u00f9\t\3\2\2\2\u00fa\u0101\5\16\b\2\u00fb")
        buf.write("\u00fd\7\177\2\2\u00fc\u00fb\3\2\2\2\u00fc\u00fd\3\2\2")
        buf.write("\2\u00fd\u00fe\3\2\2\2\u00fe\u0100\5\f\7\2\u00ff\u00fc")
        buf.write("\3\2\2\2\u0100\u0103\3\2\2\2\u0101\u00ff\3\2\2\2\u0101")
        buf.write("\u0102\3\2\2\2\u0102\13\3\2\2\2\u0103\u0101\3\2\2\2\u0104")
        buf.write("\u0105\7\60\2\2\u0105\u0106\7\177\2\2\u0106\u0108\7\61")
        buf.write("\2\2\u0107\u0109\7\177\2\2\u0108\u0107\3\2\2\2\u0108\u0109")
        buf.write("\3\2\2\2\u0109\u010a\3\2\2\2\u010a\u0111\5\16\b\2\u010b")
        buf.write("\u010d\7\60\2\2\u010c\u010e\7\177\2\2\u010d\u010c\3\2")
        buf.write("\2\2\u010d\u010e\3\2\2\2\u010e\u010f\3\2\2\2\u010f\u0111")
        buf.write("\5\16\b\2\u0110\u0104\3\2\2\2\u0110\u010b\3\2\2\2\u0111")
        buf.write("\r\3\2\2\2\u0112\u0115\5\20\t\2\u0113\u0115\5\22\n\2\u0114")
        buf.write("\u0112\3\2\2\2\u0114\u0113\3\2\2\2\u0115\17\3\2\2\2\u0116")
        buf.write("\u0118\5\26\f\2\u0117\u0119\7\177\2\2\u0118\u0117\3\2")
        buf.write("\2\2\u0118\u0119\3\2\2\2\u0119\u011b\3\2\2\2\u011a\u0116")
        buf.write("\3\2\2\2\u011b\u011e\3\2\2\2\u011c\u011a\3\2\2\2\u011c")
        buf.write("\u011d\3\2\2\2\u011d\u011f\3\2\2\2\u011e\u011c\3\2\2\2")
        buf.write("\u011f\u013a\5\66\34\2\u0120\u0122\5\26\f\2\u0121\u0123")
        buf.write("\7\177\2\2\u0122\u0121\3\2\2\2\u0122\u0123\3\2\2\2\u0123")
        buf.write("\u0125\3\2\2\2\u0124\u0120\3\2\2\2\u0125\u0128\3\2\2\2")
        buf.write("\u0126\u0124\3\2\2\2\u0126\u0127\3\2\2\2\u0127\u0129\3")
        buf.write("\2\2\2\u0128\u0126\3\2\2\2\u0129\u0130\5\24\13\2\u012a")
        buf.write("\u012c\7\177\2\2\u012b\u012a\3\2\2\2\u012b\u012c\3\2\2")
        buf.write("\2\u012c\u012d\3\2\2\2\u012d\u012f\5\24\13\2\u012e\u012b")
        buf.write("\3\2\2\2\u012f\u0132\3\2\2\2\u0130\u012e\3\2\2\2\u0130")
        buf.write("\u0131\3\2\2\2\u0131\u0137\3\2\2\2\u0132\u0130\3\2\2\2")
        buf.write("\u0133\u0135\7\177\2\2\u0134\u0133\3\2\2\2\u0134\u0135")
        buf.write("\3\2\2\2\u0135\u0136\3\2\2\2\u0136\u0138\5\66\34\2\u0137")
        buf.write("\u0134\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u013a\3\2\2\2")
        buf.write("\u0139\u011c\3\2\2\2\u0139\u0126\3\2\2\2\u013a\21\3\2")
        buf.write("\2\2\u013b\u013d\5\26\f\2\u013c\u013e\7\177\2\2\u013d")
        buf.write("\u013c\3\2\2\2\u013d\u013e\3\2\2\2\u013e\u0140\3\2\2\2")
        buf.write("\u013f\u013b\3\2\2\2\u0140\u0143\3\2\2\2\u0141\u013f\3")
        buf.write("\2\2\2\u0141\u0142\3\2\2\2\u0142\u014a\3\2\2\2\u0143\u0141")
        buf.write("\3\2\2\2\u0144\u0146\5\24\13\2\u0145\u0147\7\177\2\2\u0146")
        buf.write("\u0145\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u0149\3\2\2\2")
        buf.write("\u0148\u0144\3\2\2\2\u0149\u014c\3\2\2\2\u014a\u0148\3")
        buf.write("\2\2\2\u014a\u014b\3\2\2\2\u014b\u014d\3\2\2\2\u014c\u014a")
        buf.write("\3\2\2\2\u014d\u014f\5\64\33\2\u014e\u0150\7\177\2\2\u014f")
        buf.write("\u014e\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0152\3\2\2\2")
        buf.write("\u0151\u0141\3\2\2\2\u0152\u0153\3\2\2\2\u0153\u0151\3")
        buf.write("\2\2\2\u0153\u0154\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u0156")
        buf.write("\5\20\t\2\u0156\23\3\2\2\2\u0157\u015d\5 \21\2\u0158\u015d")
        buf.write("\5\34\17\2\u0159\u015d\5&\24\2\u015a\u015d\5\"\22\2\u015b")
        buf.write("\u015d\5(\25\2\u015c\u0157\3\2\2\2\u015c\u0158\3\2\2\2")
        buf.write("\u015c\u0159\3\2\2\2\u015c\u015a\3\2\2\2\u015c\u015b\3")
        buf.write("\2\2\2\u015d\25\3\2\2\2\u015e\u0162\5\30\r\2\u015f\u0162")
        buf.write("\5\32\16\2\u0160\u0162\5,\27\2\u0161\u015e\3\2\2\2\u0161")
        buf.write("\u015f\3\2\2\2\u0161\u0160\3\2\2\2\u0162\27\3\2\2\2\u0163")
        buf.write("\u0164\7\62\2\2\u0164\u0166\7\177\2\2\u0165\u0163\3\2")
        buf.write("\2\2\u0165\u0166\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0169")
        buf.write("\7\63\2\2\u0168\u016a\7\177\2\2\u0169\u0168\3\2\2\2\u0169")
        buf.write("\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u0170\5H%\2\u016c")
        buf.write("\u016e\7\177\2\2\u016d\u016c\3\2\2\2\u016d\u016e\3\2\2")
        buf.write("\2\u016e\u016f\3\2\2\2\u016f\u0171\5F$\2\u0170\u016d\3")
        buf.write("\2\2\2\u0170\u0171\3\2\2\2\u0171\31\3\2\2\2\u0172\u0174")
        buf.write("\7\64\2\2\u0173\u0175\7\177\2\2\u0174\u0173\3\2\2\2\u0174")
        buf.write("\u0175\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0177\5j\66\2")
        buf.write("\u0177\u0178\7\177\2\2\u0178\u0179\7\65\2\2\u0179\u017a")
        buf.write("\7\177\2\2\u017a\u017b\5\u00b2Z\2\u017b\33\3\2\2\2\u017c")
        buf.write("\u017e\7\66\2\2\u017d\u017f\7\177\2\2\u017e\u017d\3\2")
        buf.write("\2\2\u017e\u017f\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0185")
        buf.write("\5J&\2\u0181\u0182\7\177\2\2\u0182\u0184\5\36\20\2\u0183")
        buf.write("\u0181\3\2\2\2\u0184\u0187\3\2\2\2\u0185\u0183\3\2\2\2")
        buf.write("\u0185\u0186\3\2\2\2\u0186\35\3\2\2\2\u0187\u0185\3\2")
        buf.write("\2\2\u0188\u0189\7\67\2\2\u0189\u018a\7\177\2\2\u018a")
        buf.write("\u018b\7\63\2\2\u018b\u018c\7\177\2\2\u018c\u0193\5\"")
        buf.write("\22\2\u018d\u018e\7\67\2\2\u018e\u018f\7\177\2\2\u018f")
        buf.write("\u0190\78\2\2\u0190\u0191\7\177\2\2\u0191\u0193\5\"\22")
        buf.write("\2\u0192\u0188\3\2\2\2\u0192\u018d\3\2\2\2\u0193\37\3")
        buf.write("\2\2\2\u0194\u0196\78\2\2\u0195\u0197\7\177\2\2\u0196")
        buf.write("\u0195\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0198\3\2\2\2")
        buf.write("\u0198\u0199\5H%\2\u0199!\3\2\2\2\u019a\u019c\79\2\2\u019b")
        buf.write("\u019d\7\177\2\2\u019c\u019b\3\2\2\2\u019c\u019d\3\2\2")
        buf.write("\2\u019d\u019e\3\2\2\2\u019e\u01a9\5$\23\2\u019f\u01a1")
        buf.write("\7\177\2\2\u01a0\u019f\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1")
        buf.write("\u01a2\3\2\2\2\u01a2\u01a4\7\6\2\2\u01a3\u01a5\7\177\2")
        buf.write("\2\u01a4\u01a3\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a6")
        buf.write("\3\2\2\2\u01a6\u01a8\5$\23\2\u01a7\u01a0\3\2\2\2\u01a8")
        buf.write("\u01ab\3\2\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01aa\3\2\2\2")
        buf.write("\u01aa#\3\2\2\2\u01ab\u01a9\3\2\2\2\u01ac\u01ae\5h\65")
        buf.write("\2\u01ad\u01af\7\177\2\2\u01ae\u01ad\3\2\2\2\u01ae\u01af")
        buf.write("\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b2\7\7\2\2\u01b1")
        buf.write("\u01b3\7\177\2\2\u01b2\u01b1\3\2\2\2\u01b2\u01b3\3\2\2")
        buf.write("\2\u01b3\u01b4\3\2\2\2\u01b4\u01b5\5j\66\2\u01b5\u01d1")
        buf.write("\3\2\2\2\u01b6\u01b8\5\u00b2Z\2\u01b7\u01b9\7\177\2\2")
        buf.write("\u01b8\u01b7\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\3")
        buf.write("\2\2\2\u01ba\u01bc\7\7\2\2\u01bb\u01bd\7\177\2\2\u01bc")
        buf.write("\u01bb\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd\u01be\3\2\2\2")
        buf.write("\u01be\u01bf\5j\66\2\u01bf\u01d1\3\2\2\2\u01c0\u01c2\5")
        buf.write("\u00b2Z\2\u01c1\u01c3\7\177\2\2\u01c2\u01c1\3\2\2\2\u01c2")
        buf.write("\u01c3\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c6\7\b\2\2")
        buf.write("\u01c5\u01c7\7\177\2\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7")
        buf.write("\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9\5j\66\2\u01c9")
        buf.write("\u01d1\3\2\2\2\u01ca\u01cc\5\u00b2Z\2\u01cb\u01cd\7\177")
        buf.write("\2\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01ce")
        buf.write("\3\2\2\2\u01ce\u01cf\5^\60\2\u01cf\u01d1\3\2\2\2\u01d0")
        buf.write("\u01ac\3\2\2\2\u01d0\u01b6\3\2\2\2\u01d0\u01c0\3\2\2\2")
        buf.write("\u01d0\u01ca\3\2\2\2\u01d1%\3\2\2\2\u01d2\u01d3\7:\2\2")
        buf.write("\u01d3\u01d5\7\177\2\2\u01d4\u01d2\3\2\2\2\u01d4\u01d5")
        buf.write("\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u01d8\7;\2\2\u01d7")
        buf.write("\u01d9\7\177\2\2\u01d8\u01d7\3\2\2\2\u01d8\u01d9\3\2\2")
        buf.write("\2\u01d9\u01da\3\2\2\2\u01da\u01e5\5j\66\2\u01db\u01dd")
        buf.write("\7\177\2\2\u01dc\u01db\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd")
        buf.write("\u01de\3\2\2\2\u01de\u01e0\7\6\2\2\u01df\u01e1\7\177\2")
        buf.write("\2\u01e0\u01df\3\2\2\2\u01e0\u01e1\3\2\2\2\u01e1\u01e2")
        buf.write("\3\2\2\2\u01e2\u01e4\5j\66\2\u01e3\u01dc\3\2\2\2\u01e4")
        buf.write("\u01e7\3\2\2\2\u01e5\u01e3\3\2\2\2\u01e5\u01e6\3\2\2\2")
        buf.write("\u01e6\'\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e8\u01e9\7<\2")
        buf.write("\2\u01e9\u01ea\7\177\2\2\u01ea\u01f5\5*\26\2\u01eb\u01ed")
        buf.write("\7\177\2\2\u01ec\u01eb\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed")
        buf.write("\u01ee\3\2\2\2\u01ee\u01f0\7\6\2\2\u01ef\u01f1\7\177\2")
        buf.write("\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u01f2")
        buf.write("\3\2\2\2\u01f2\u01f4\5*\26\2\u01f3\u01ec\3\2\2\2\u01f4")
        buf.write("\u01f7\3\2\2\2\u01f5\u01f3\3\2\2\2\u01f5\u01f6\3\2\2\2")
        buf.write("\u01f6)\3\2\2\2\u01f7\u01f5\3\2\2\2\u01f8\u01f9\5\u00b2")
        buf.write("Z\2\u01f9\u01fa\5^\60\2\u01fa\u01fd\3\2\2\2\u01fb\u01fd")
        buf.write("\5h\65\2\u01fc\u01f8\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd")
        buf.write("+\3\2\2\2\u01fe\u01ff\7=\2\2\u01ff\u0200\7\177\2\2\u0200")
        buf.write("\u0207\5\u00a8U\2\u0201\u0203\7\177\2\2\u0202\u0201\3")
        buf.write("\2\2\2\u0202\u0203\3\2\2\2\u0203\u0204\3\2\2\2\u0204\u0205")
        buf.write("\7>\2\2\u0205\u0206\7\177\2\2\u0206\u0208\5\60\31\2\u0207")
        buf.write("\u0202\3\2\2\2\u0207\u0208\3\2\2\2\u0208-\3\2\2\2\u0209")
        buf.write("\u020a\7=\2\2\u020a\u020d\7\177\2\2\u020b\u020e\5\u00a8")
        buf.write("U\2\u020c\u020e\5\u00aaV\2\u020d\u020b\3\2\2\2\u020d\u020c")
        buf.write("\3\2\2\2\u020e\u0218\3\2\2\2\u020f\u0211\7\177\2\2\u0210")
        buf.write("\u020f\3\2\2\2\u0210\u0211\3\2\2\2\u0211\u0212\3\2\2\2")
        buf.write("\u0212\u0213\7>\2\2\u0213\u0216\7\177\2\2\u0214\u0217")
        buf.write("\7\t\2\2\u0215\u0217\5\60\31\2\u0216\u0214\3\2\2\2\u0216")
        buf.write("\u0215\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0210\3\2\2\2")
        buf.write("\u0218\u0219\3\2\2\2\u0219/\3\2\2\2\u021a\u0225\5\62\32")
        buf.write("\2\u021b\u021d\7\177\2\2\u021c\u021b\3\2\2\2\u021c\u021d")
        buf.write("\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u0220\7\6\2\2\u021f")
        buf.write("\u0221\7\177\2\2\u0220\u021f\3\2\2\2\u0220\u0221\3\2\2")
        buf.write("\2\u0221\u0222\3\2\2\2\u0222\u0224\5\62\32\2\u0223\u021c")
        buf.write("\3\2\2\2\u0224\u0227\3\2\2\2\u0225\u0223\3\2\2\2\u0225")
        buf.write("\u0226\3\2\2\2\u0226\u022c\3\2\2\2\u0227\u0225\3\2\2\2")
        buf.write("\u0228\u022a\7\177\2\2\u0229\u0228\3\2\2\2\u0229\u022a")
        buf.write("\3\2\2\2\u022a\u022b\3\2\2\2\u022b\u022d\5F$\2\u022c\u0229")
        buf.write("\3\2\2\2\u022c\u022d\3\2\2\2\u022d\61\3\2\2\2\u022e\u022f")
        buf.write("\5\u00acW\2\u022f\u0230\7\177\2\2\u0230\u0231\7\65\2\2")
        buf.write("\u0231\u0232\7\177\2\2\u0232\u0234\3\2\2\2\u0233\u022e")
        buf.write("\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0235\3\2\2\2\u0235")
        buf.write("\u0236\5\u00b2Z\2\u0236\63\3\2\2\2\u0237\u0238\7?\2\2")
        buf.write("\u0238\u023d\58\35\2\u0239\u023b\7\177\2\2\u023a\u0239")
        buf.write("\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023c\3\2\2\2\u023c")
        buf.write("\u023e\5F$\2\u023d\u023a\3\2\2\2\u023d\u023e\3\2\2\2\u023e")
        buf.write("\65\3\2\2\2\u023f\u0240\7@\2\2\u0240\u0241\58\35\2\u0241")
        buf.write("\67\3\2\2\2\u0242\u0244\7\177\2\2\u0243\u0242\3\2\2\2")
        buf.write("\u0243\u0244\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0247\7")
        buf.write("A\2\2\u0246\u0243\3\2\2\2\u0246\u0247\3\2\2\2\u0247\u0248")
        buf.write("\3\2\2\2\u0248\u0249\7\177\2\2\u0249\u024c\5:\36\2\u024a")
        buf.write("\u024b\7\177\2\2\u024b\u024d\5> \2\u024c\u024a\3\2\2\2")
        buf.write("\u024c\u024d\3\2\2\2\u024d\u0250\3\2\2\2\u024e\u024f\7")
        buf.write("\177\2\2\u024f\u0251\5@!\2\u0250\u024e\3\2\2\2\u0250\u0251")
        buf.write("\3\2\2\2\u0251\u0254\3\2\2\2\u0252\u0253\7\177\2\2\u0253")
        buf.write("\u0255\5B\"\2\u0254\u0252\3\2\2\2\u0254\u0255\3\2\2\2")
        buf.write("\u02559\3\2\2\2\u0256\u0261\7\t\2\2\u0257\u0259\7\177")
        buf.write("\2\2\u0258\u0257\3\2\2\2\u0258\u0259\3\2\2\2\u0259\u025a")
        buf.write("\3\2\2\2\u025a\u025c\7\6\2\2\u025b\u025d\7\177\2\2\u025c")
        buf.write("\u025b\3\2\2\2\u025c\u025d\3\2\2\2\u025d\u025e\3\2\2\2")
        buf.write("\u025e\u0260\5<\37\2\u025f\u0258\3\2\2\2\u0260\u0263\3")
        buf.write("\2\2\2\u0261\u025f\3\2\2\2\u0261\u0262\3\2\2\2\u0262\u0273")
        buf.write("\3\2\2\2\u0263\u0261\3\2\2\2\u0264\u026f\5<\37\2\u0265")
        buf.write("\u0267\7\177\2\2\u0266\u0265\3\2\2\2\u0266\u0267\3\2\2")
        buf.write("\2\u0267\u0268\3\2\2\2\u0268\u026a\7\6\2\2\u0269\u026b")
        buf.write("\7\177\2\2\u026a\u0269\3\2\2\2\u026a\u026b\3\2\2\2\u026b")
        buf.write("\u026c\3\2\2\2\u026c\u026e\5<\37\2\u026d\u0266\3\2\2\2")
        buf.write("\u026e\u0271\3\2\2\2\u026f\u026d\3\2\2\2\u026f\u0270\3")
        buf.write("\2\2\2\u0270\u0273\3\2\2\2\u0271\u026f\3\2\2\2\u0272\u0256")
        buf.write("\3\2\2\2\u0272\u0264\3\2\2\2\u0273;\3\2\2\2\u0274\u0275")
        buf.write("\5j\66\2\u0275\u0276\7\177\2\2\u0276\u0277\7\65\2\2\u0277")
        buf.write("\u0278\7\177\2\2\u0278\u0279\5\u00b2Z\2\u0279\u027c\3")
        buf.write("\2\2\2\u027a\u027c\5j\66\2\u027b\u0274\3\2\2\2\u027b\u027a")
        buf.write("\3\2\2\2\u027c=\3\2\2\2\u027d\u027e\7B\2\2\u027e\u027f")
        buf.write("\7\177\2\2\u027f\u0280\7C\2\2\u0280\u0281\7\177\2\2\u0281")
        buf.write("\u0289\5D#\2\u0282\u0284\7\6\2\2\u0283\u0285\7\177\2\2")
        buf.write("\u0284\u0283\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u0286\3")
        buf.write("\2\2\2\u0286\u0288\5D#\2\u0287\u0282\3\2\2\2\u0288\u028b")
        buf.write("\3\2\2\2\u0289\u0287\3\2\2\2\u0289\u028a\3\2\2\2\u028a")
        buf.write("?\3\2\2\2\u028b\u0289\3\2\2\2\u028c\u028d\7D\2\2\u028d")
        buf.write("\u028e\7\177\2\2\u028e\u028f\5j\66\2\u028fA\3\2\2\2\u0290")
        buf.write("\u0291\7E\2\2\u0291\u0292\7\177\2\2\u0292\u0293\5j\66")
        buf.write("\2\u0293C\3\2\2\2\u0294\u0299\5j\66\2\u0295\u0297\7\177")
        buf.write("\2\2\u0296\u0295\3\2\2\2\u0296\u0297\3\2\2\2\u0297\u0298")
        buf.write("\3\2\2\2\u0298\u029a\t\2\2\2\u0299\u0296\3\2\2\2\u0299")
        buf.write("\u029a\3\2\2\2\u029aE\3\2\2\2\u029b\u029c\7J\2\2\u029c")
        buf.write("\u029d\7\177\2\2\u029d\u029e\5j\66\2\u029eG\3\2\2\2\u029f")
        buf.write("\u02aa\5J&\2\u02a0\u02a2\7\177\2\2\u02a1\u02a0\3\2\2\2")
        buf.write("\u02a1\u02a2\3\2\2\2\u02a2\u02a3\3\2\2\2\u02a3\u02a5\7")
        buf.write("\6\2\2\u02a4\u02a6\7\177\2\2\u02a5\u02a4\3\2\2\2\u02a5")
        buf.write("\u02a6\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02a9\5J&\2\u02a8")
        buf.write("\u02a1\3\2\2\2\u02a9\u02ac\3\2\2\2\u02aa\u02a8\3\2\2\2")
        buf.write("\u02aa\u02ab\3\2\2\2\u02abI\3\2\2\2\u02ac\u02aa\3\2\2")
        buf.write("\2\u02ad\u02af\5\u00b2Z\2\u02ae\u02b0\7\177\2\2\u02af")
        buf.write("\u02ae\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b1\3\2\2\2")
        buf.write("\u02b1\u02b3\7\7\2\2\u02b2\u02b4\7\177\2\2\u02b3\u02b2")
        buf.write("\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5")
        buf.write("\u02b6\5L\'\2\u02b6\u02b9\3\2\2\2\u02b7\u02b9\5L\'\2\u02b8")
        buf.write("\u02ad\3\2\2\2\u02b8\u02b7\3\2\2\2\u02b9K\3\2\2\2\u02ba")
        buf.write("\u02bb\5N(\2\u02bbM\3\2\2\2\u02bc\u02c3\5R*\2\u02bd\u02bf")
        buf.write("\7\177\2\2\u02be\u02bd\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf")
        buf.write("\u02c0\3\2\2\2\u02c0\u02c2\5T+\2\u02c1\u02be\3\2\2\2\u02c2")
        buf.write("\u02c5\3\2\2\2\u02c3\u02c1\3\2\2\2\u02c3\u02c4\3\2\2\2")
        buf.write("\u02c4\u02cb\3\2\2\2\u02c5\u02c3\3\2\2\2\u02c6\u02c7\7")
        buf.write("\n\2\2\u02c7\u02c8\5N(\2\u02c8\u02c9\7\13\2\2\u02c9\u02cb")
        buf.write("\3\2\2\2\u02ca\u02bc\3\2\2\2\u02ca\u02c6\3\2\2\2\u02cb")
        buf.write("O\3\2\2\2\u02cc\u02d1\5R*\2\u02cd\u02cf\7\177\2\2\u02ce")
        buf.write("\u02cd\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d0\3\2\2\2")
        buf.write("\u02d0\u02d2\5T+\2\u02d1\u02ce\3\2\2\2\u02d2\u02d3\3\2")
        buf.write("\2\2\u02d3\u02d1\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4Q\3")
        buf.write("\2\2\2\u02d5\u02d7\7\n\2\2\u02d6\u02d8\7\177\2\2\u02d7")
        buf.write("\u02d6\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u02dd\3\2\2\2")
        buf.write("\u02d9\u02db\5\u00b2Z\2\u02da\u02dc\7\177\2\2\u02db\u02da")
        buf.write("\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02de\3\2\2\2\u02dd")
        buf.write("\u02d9\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02e3\3\2\2\2")
        buf.write("\u02df\u02e1\5^\60\2\u02e0\u02e2\7\177\2\2\u02e1\u02e0")
        buf.write("\3\2\2\2\u02e1\u02e2\3\2\2\2\u02e2\u02e4\3\2\2\2\u02e3")
        buf.write("\u02df\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e9\3\2\2\2")
        buf.write("\u02e5\u02e7\5Z.\2\u02e6\u02e8\7\177\2\2\u02e7\u02e6\3")
        buf.write("\2\2\2\u02e7\u02e8\3\2\2\2\u02e8\u02ea\3\2\2\2\u02e9\u02e5")
        buf.write("\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea\u02eb\3\2\2\2\u02eb")
        buf.write("\u02ec\7\13\2\2\u02ecS\3\2\2\2\u02ed\u02ef\5V,\2\u02ee")
        buf.write("\u02f0\7\177\2\2\u02ef\u02ee\3\2\2\2\u02ef\u02f0\3\2\2")
        buf.write("\2\u02f0\u02f1\3\2\2\2\u02f1\u02f2\5R*\2\u02f2U\3\2\2")
        buf.write("\2\u02f3\u02f5\5\u00ccg\2\u02f4\u02f6\7\177\2\2\u02f5")
        buf.write("\u02f4\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u02f7\3\2\2\2")
        buf.write("\u02f7\u02f9\5\u00d0i\2\u02f8\u02fa\7\177\2\2\u02f9\u02f8")
        buf.write("\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fc\3\2\2\2\u02fb")
        buf.write("\u02fd\5X-\2\u02fc\u02fb\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd")
        buf.write("\u02ff\3\2\2\2\u02fe\u0300\7\177\2\2\u02ff\u02fe\3\2\2")
        buf.write("\2\u02ff\u0300\3\2\2\2\u0300\u0301\3\2\2\2\u0301\u0303")
        buf.write("\5\u00d0i\2\u0302\u0304\7\177\2\2\u0303\u0302\3\2\2\2")
        buf.write("\u0303\u0304\3\2\2\2\u0304\u0305\3\2\2\2\u0305\u0306\5")
        buf.write("\u00ceh\2\u0306\u0334\3\2\2\2\u0307\u0309\5\u00ccg\2\u0308")
        buf.write("\u030a\7\177\2\2\u0309\u0308\3\2\2\2\u0309\u030a\3\2\2")
        buf.write("\2\u030a\u030b\3\2\2\2\u030b\u030d\5\u00d0i\2\u030c\u030e")
        buf.write("\7\177\2\2\u030d\u030c\3\2\2\2\u030d\u030e\3\2\2\2\u030e")
        buf.write("\u0310\3\2\2\2\u030f\u0311\5X-\2\u0310\u030f\3\2\2\2\u0310")
        buf.write("\u0311\3\2\2\2\u0311\u0313\3\2\2\2\u0312\u0314\7\177\2")
        buf.write("\2\u0313\u0312\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u0315")
        buf.write("\3\2\2\2\u0315\u0316\5\u00d0i\2\u0316\u0334\3\2\2\2\u0317")
        buf.write("\u0319\5\u00d0i\2\u0318\u031a\7\177\2\2\u0319\u0318\3")
        buf.write("\2\2\2\u0319\u031a\3\2\2\2\u031a\u031c\3\2\2\2\u031b\u031d")
        buf.write("\5X-\2\u031c\u031b\3\2\2\2\u031c\u031d\3\2\2\2\u031d\u031f")
        buf.write("\3\2\2\2\u031e\u0320\7\177\2\2\u031f\u031e\3\2\2\2\u031f")
        buf.write("\u0320\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u0323\5\u00d0")
        buf.write("i\2\u0322\u0324\7\177\2\2\u0323\u0322\3\2\2\2\u0323\u0324")
        buf.write("\3\2\2\2\u0324\u0325\3\2\2\2\u0325\u0326\5\u00ceh\2\u0326")
        buf.write("\u0334\3\2\2\2\u0327\u0329\5\u00d0i\2\u0328\u032a\7\177")
        buf.write("\2\2\u0329\u0328\3\2\2\2\u0329\u032a\3\2\2\2\u032a\u032c")
        buf.write("\3\2\2\2\u032b\u032d\5X-\2\u032c\u032b\3\2\2\2\u032c\u032d")
        buf.write("\3\2\2\2\u032d\u032f\3\2\2\2\u032e\u0330\7\177\2\2\u032f")
        buf.write("\u032e\3\2\2\2\u032f\u0330\3\2\2\2\u0330\u0331\3\2\2\2")
        buf.write("\u0331\u0332\5\u00d0i\2\u0332\u0334\3\2\2\2\u0333\u02f3")
        buf.write("\3\2\2\2\u0333\u0307\3\2\2\2\u0333\u0317\3\2\2\2\u0333")
        buf.write("\u0327\3\2\2\2\u0334W\3\2\2\2\u0335\u0337\7\f\2\2\u0336")
        buf.write("\u0338\7\177\2\2\u0337\u0336\3\2\2\2\u0337\u0338\3\2\2")
        buf.write("\2\u0338\u033d\3\2\2\2\u0339\u033b\5\u00b2Z\2\u033a\u033c")
        buf.write("\7\177\2\2\u033b\u033a\3\2\2\2\u033b\u033c\3\2\2\2\u033c")
        buf.write("\u033e\3\2\2\2\u033d\u0339\3\2\2\2\u033d\u033e\3\2\2\2")
        buf.write("\u033e\u0343\3\2\2\2\u033f\u0341\5\\/\2\u0340\u0342\7")
        buf.write("\177\2\2\u0341\u0340\3\2\2\2\u0341\u0342\3\2\2\2\u0342")
        buf.write("\u0344\3\2\2\2\u0343\u033f\3\2\2\2\u0343\u0344\3\2\2\2")
        buf.write("\u0344\u0346\3\2\2\2\u0345\u0347\5b\62\2\u0346\u0345\3")
        buf.write("\2\2\2\u0346\u0347\3\2\2\2\u0347\u034c\3\2\2\2\u0348\u034a")
        buf.write("\5Z.\2\u0349\u034b\7\177\2\2\u034a\u0349\3\2\2\2\u034a")
        buf.write("\u034b\3\2\2\2\u034b\u034d\3\2\2\2\u034c\u0348\3\2\2\2")
        buf.write("\u034c\u034d\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u034f\7")
        buf.write("\r\2\2\u034fY\3\2\2\2\u0350\u0353\5\u00c0a\2\u0351\u0353")
        buf.write("\5\u00c4c\2\u0352\u0350\3\2\2\2\u0352\u0351\3\2\2\2\u0353")
        buf.write("[\3\2\2\2\u0354\u0356\7\16\2\2\u0355\u0357\7\177\2\2\u0356")
        buf.write("\u0355\3\2\2\2\u0356\u0357\3\2\2\2\u0357\u0358\3\2\2\2")
        buf.write("\u0358\u0366\5f\64\2\u0359\u035b\7\177\2\2\u035a\u0359")
        buf.write("\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u035c\3\2\2\2\u035c")
        buf.write("\u035e\7\17\2\2\u035d\u035f\7\16\2\2\u035e\u035d\3\2\2")
        buf.write("\2\u035e\u035f\3\2\2\2\u035f\u0361\3\2\2\2\u0360\u0362")
        buf.write("\7\177\2\2\u0361\u0360\3\2\2\2\u0361\u0362\3\2\2\2\u0362")
        buf.write("\u0363\3\2\2\2\u0363\u0365\5f\64\2\u0364\u035a\3\2\2\2")
        buf.write("\u0365\u0368\3\2\2\2\u0366\u0364\3\2\2\2\u0366\u0367\3")
        buf.write("\2\2\2\u0367]\3\2\2\2\u0368\u0366\3\2\2\2\u0369\u0370")
        buf.write("\5`\61\2\u036a\u036c\7\177\2\2\u036b\u036a\3\2\2\2\u036b")
        buf.write("\u036c\3\2\2\2\u036c\u036d\3\2\2\2\u036d\u036f\5`\61\2")
        buf.write("\u036e\u036b\3\2\2\2\u036f\u0372\3\2\2\2\u0370\u036e\3")
        buf.write("\2\2\2\u0370\u0371\3\2\2\2\u0371_\3\2\2\2\u0372\u0370")
        buf.write("\3\2\2\2\u0373\u0375\7\16\2\2\u0374\u0376\7\177\2\2\u0375")
        buf.write("\u0374\3\2\2\2\u0375\u0376\3\2\2\2\u0376\u0377\3\2\2\2")
        buf.write("\u0377\u0378\5d\63\2\u0378a\3\2\2\2\u0379\u037b\7\t\2")
        buf.write("\2\u037a\u037c\7\177\2\2\u037b\u037a\3\2\2\2\u037b\u037c")
        buf.write("\3\2\2\2\u037c\u0381\3\2\2\2\u037d\u037f\5\u00ba^\2\u037e")
        buf.write("\u0380\7\177\2\2\u037f\u037e\3\2\2\2\u037f\u0380\3\2\2")
        buf.write("\2\u0380\u0382\3\2\2\2\u0381\u037d\3\2\2\2\u0381\u0382")
        buf.write("\3\2\2\2\u0382\u038d\3\2\2\2\u0383\u0385\7\20\2\2\u0384")
        buf.write("\u0386\7\177\2\2\u0385\u0384\3\2\2\2\u0385\u0386\3\2\2")
        buf.write("\2\u0386\u038b\3\2\2\2\u0387\u0389\5\u00ba^\2\u0388\u038a")
        buf.write("\7\177\2\2\u0389\u0388\3\2\2\2\u0389\u038a\3\2\2\2\u038a")
        buf.write("\u038c\3\2\2\2\u038b\u0387\3\2\2\2\u038b\u038c\3\2\2\2")
        buf.write("\u038c\u038e\3\2\2\2\u038d\u0383\3\2\2\2\u038d\u038e\3")
        buf.write("\2\2\2\u038ec\3\2\2\2\u038f\u0390\5\u00c6d\2\u0390e\3")
        buf.write("\2\2\2\u0391\u0392\5\u00c6d\2\u0392g\3\2\2\2\u0393\u0398")
        buf.write("\5\u008eH\2\u0394\u0396\7\177\2\2\u0395\u0394\3\2\2\2")
        buf.write("\u0395\u0396\3\2\2\2\u0396\u0397\3\2\2\2\u0397\u0399\5")
        buf.write("\u008cG\2\u0398\u0395\3\2\2\2\u0399\u039a\3\2\2\2\u039a")
        buf.write("\u0398\3\2\2\2\u039a\u039b\3\2\2\2\u039bi\3\2\2\2\u039c")
        buf.write("\u039d\5l\67\2\u039dk\3\2\2\2\u039e\u03a5\5n8\2\u039f")
        buf.write("\u03a0\7\177\2\2\u03a0\u03a1\7K\2\2\u03a1\u03a2\7\177")
        buf.write("\2\2\u03a2\u03a4\5n8\2\u03a3\u039f\3\2\2\2\u03a4\u03a7")
        buf.write("\3\2\2\2\u03a5\u03a3\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6")
        buf.write("m\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a8\u03af\5p9\2\u03a9")
        buf.write("\u03aa\7\177\2\2\u03aa\u03ab\7L\2\2\u03ab\u03ac\7\177")
        buf.write("\2\2\u03ac\u03ae\5p9\2\u03ad\u03a9\3\2\2\2\u03ae\u03b1")
        buf.write("\3\2\2\2\u03af\u03ad\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0")
        buf.write("o\3\2\2\2\u03b1\u03af\3\2\2\2\u03b2\u03b9\5r:\2\u03b3")
        buf.write("\u03b4\7\177\2\2\u03b4\u03b5\7M\2\2\u03b5\u03b6\7\177")
        buf.write("\2\2\u03b6\u03b8\5r:\2\u03b7\u03b3\3\2\2\2\u03b8\u03bb")
        buf.write("\3\2\2\2\u03b9\u03b7\3\2\2\2\u03b9\u03ba\3\2\2\2\u03ba")
        buf.write("q\3\2\2\2\u03bb\u03b9\3\2\2\2\u03bc\u03be\7N\2\2\u03bd")
        buf.write("\u03bf\7\177\2\2\u03be\u03bd\3\2\2\2\u03be\u03bf\3\2\2")
        buf.write("\2\u03bf\u03c1\3\2\2\2\u03c0\u03bc\3\2\2\2\u03c1\u03c4")
        buf.write("\3\2\2\2\u03c2\u03c0\3\2\2\2\u03c2\u03c3\3\2\2\2\u03c3")
        buf.write("\u03c5\3\2\2\2\u03c4\u03c2\3\2\2\2\u03c5\u03c6\5t;\2\u03c6")
        buf.write("s\3\2\2\2\u03c7\u03ce\5x=\2\u03c8\u03ca\7\177\2\2\u03c9")
        buf.write("\u03c8\3\2\2\2\u03c9\u03ca\3\2\2\2\u03ca\u03cb\3\2\2\2")
        buf.write("\u03cb\u03cd\5v<\2\u03cc\u03c9\3\2\2\2\u03cd\u03d0\3\2")
        buf.write("\2\2\u03ce\u03cc\3\2\2\2\u03ce\u03cf\3\2\2\2\u03cfu\3")
        buf.write("\2\2\2\u03d0\u03ce\3\2\2\2\u03d1\u03d3\7\7\2\2\u03d2\u03d4")
        buf.write("\7\177\2\2\u03d3\u03d2\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4")
        buf.write("\u03d5\3\2\2\2\u03d5\u03f0\5x=\2\u03d6\u03d8\7\21\2\2")
        buf.write("\u03d7\u03d9\7\177\2\2\u03d8\u03d7\3\2\2\2\u03d8\u03d9")
        buf.write("\3\2\2\2\u03d9\u03da\3\2\2\2\u03da\u03f0\5x=\2\u03db\u03dd")
        buf.write("\7\22\2\2\u03dc\u03de\7\177\2\2\u03dd\u03dc\3\2\2\2\u03dd")
        buf.write("\u03de\3\2\2\2\u03de\u03df\3\2\2\2\u03df\u03f0\5x=\2\u03e0")
        buf.write("\u03e2\7\23\2\2\u03e1\u03e3\7\177\2\2\u03e2\u03e1\3\2")
        buf.write("\2\2\u03e2\u03e3\3\2\2\2\u03e3\u03e4\3\2\2\2\u03e4\u03f0")
        buf.write("\5x=\2\u03e5\u03e7\7\24\2\2\u03e6\u03e8\7\177\2\2\u03e7")
        buf.write("\u03e6\3\2\2\2\u03e7\u03e8\3\2\2\2\u03e8\u03e9\3\2\2\2")
        buf.write("\u03e9\u03f0\5x=\2\u03ea\u03ec\7\25\2\2\u03eb\u03ed\7")
        buf.write("\177\2\2\u03ec\u03eb\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed")
        buf.write("\u03ee\3\2\2\2\u03ee\u03f0\5x=\2\u03ef\u03d1\3\2\2\2\u03ef")
        buf.write("\u03d6\3\2\2\2\u03ef\u03db\3\2\2\2\u03ef\u03e0\3\2\2\2")
        buf.write("\u03ef\u03e5\3\2\2\2\u03ef\u03ea\3\2\2\2\u03f0w\3\2\2")
        buf.write("\2\u03f1\u03f7\5\u0080A\2\u03f2\u03f6\5z>\2\u03f3\u03f6")
        buf.write("\5|?\2\u03f4\u03f6\5~@\2\u03f5\u03f2\3\2\2\2\u03f5\u03f3")
        buf.write("\3\2\2\2\u03f5\u03f4\3\2\2\2\u03f6\u03f9\3\2\2\2\u03f7")
        buf.write("\u03f5\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8y\3\2\2\2\u03f9")
        buf.write("\u03f7\3\2\2\2\u03fa\u03fb\7\177\2\2\u03fb\u03fc\7O\2")
        buf.write("\2\u03fc\u03fd\7\177\2\2\u03fd\u0405\7?\2\2\u03fe\u03ff")
        buf.write("\7\177\2\2\u03ff\u0400\7P\2\2\u0400\u0401\7\177\2\2\u0401")
        buf.write("\u0405\7?\2\2\u0402\u0403\7\177\2\2\u0403\u0405\7Q\2\2")
        buf.write("\u0404\u03fa\3\2\2\2\u0404\u03fe\3\2\2\2\u0404\u0402\3")
        buf.write("\2\2\2\u0405\u0407\3\2\2\2\u0406\u0408\7\177\2\2\u0407")
        buf.write("\u0406\3\2\2\2\u0407\u0408\3\2\2\2\u0408\u0409\3\2\2\2")
        buf.write("\u0409\u040a\5\u0080A\2\u040a{\3\2\2\2\u040b\u040c\7\177")
        buf.write("\2\2\u040c\u040e\7R\2\2\u040d\u040f\7\177\2\2\u040e\u040d")
        buf.write("\3\2\2\2\u040e\u040f\3\2\2\2\u040f\u0410\3\2\2\2\u0410")
        buf.write("\u0411\5\u0080A\2\u0411}\3\2\2\2\u0412\u0413\7\177\2\2")
        buf.write("\u0413\u0414\7S\2\2\u0414\u0415\7\177\2\2\u0415\u041d")
        buf.write("\7T\2\2\u0416\u0417\7\177\2\2\u0417\u0418\7S\2\2\u0418")
        buf.write("\u0419\7\177\2\2\u0419\u041a\7N\2\2\u041a\u041b\7\177")
        buf.write("\2\2\u041b\u041d\7T\2\2\u041c\u0412\3\2\2\2\u041c\u0416")
        buf.write("\3\2\2\2\u041d\177\3\2\2\2\u041e\u0431\5\u0082B\2\u041f")
        buf.write("\u0421\7\177\2\2\u0420\u041f\3\2\2\2\u0420\u0421\3\2\2")
        buf.write("\2\u0421\u0422\3\2\2\2\u0422\u0424\7\26\2\2\u0423\u0425")
        buf.write("\7\177\2\2\u0424\u0423\3\2\2\2\u0424\u0425\3\2\2\2\u0425")
        buf.write("\u0426\3\2\2\2\u0426\u0430\5\u0082B\2\u0427\u0429\7\177")
        buf.write("\2\2\u0428\u0427\3\2\2\2\u0428\u0429\3\2\2\2\u0429\u042a")
        buf.write("\3\2\2\2\u042a\u042c\7\27\2\2\u042b\u042d\7\177\2\2\u042c")
        buf.write("\u042b\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042e\3\2\2\2")
        buf.write("\u042e\u0430\5\u0082B\2\u042f\u0420\3\2\2\2\u042f\u0428")
        buf.write("\3\2\2\2\u0430\u0433\3\2\2\2\u0431\u042f\3\2\2\2\u0431")
        buf.write("\u0432\3\2\2\2\u0432\u0081\3\2\2\2\u0433\u0431\3\2\2\2")
        buf.write("\u0434\u044f\5\u0084C\2\u0435\u0437\7\177\2\2\u0436\u0435")
        buf.write("\3\2\2\2\u0436\u0437\3\2\2\2\u0437\u0438\3\2\2\2\u0438")
        buf.write("\u043a\7\t\2\2\u0439\u043b\7\177\2\2\u043a\u0439\3\2\2")
        buf.write("\2\u043a\u043b\3\2\2\2\u043b\u043c\3\2\2\2\u043c\u044e")
        buf.write("\5\u0084C\2\u043d\u043f\7\177\2\2\u043e\u043d\3\2\2\2")
        buf.write("\u043e\u043f\3\2\2\2\u043f\u0440\3\2\2\2\u0440\u0442\7")
        buf.write("\30\2\2\u0441\u0443\7\177\2\2\u0442\u0441\3\2\2\2\u0442")
        buf.write("\u0443\3\2\2\2\u0443\u0444\3\2\2\2\u0444\u044e\5\u0084")
        buf.write("C\2\u0445\u0447\7\177\2\2\u0446\u0445\3\2\2\2\u0446\u0447")
        buf.write("\3\2\2\2\u0447\u0448\3\2\2\2\u0448\u044a\7\31\2\2\u0449")
        buf.write("\u044b\7\177\2\2\u044a\u0449\3\2\2\2\u044a\u044b\3\2\2")
        buf.write("\2\u044b\u044c\3\2\2\2\u044c\u044e\5\u0084C\2\u044d\u0436")
        buf.write("\3\2\2\2\u044d\u043e\3\2\2\2\u044d\u0446\3\2\2\2\u044e")
        buf.write("\u0451\3\2\2\2\u044f\u044d\3\2\2\2\u044f\u0450\3\2\2\2")
        buf.write("\u0450\u0083\3\2\2\2\u0451\u044f\3\2\2\2\u0452\u045d\5")
        buf.write("\u0086D\2\u0453\u0455\7\177\2\2\u0454\u0453\3\2\2\2\u0454")
        buf.write("\u0455\3\2\2\2\u0455\u0456\3\2\2\2\u0456\u0458\7\32\2")
        buf.write("\2\u0457\u0459\7\177\2\2\u0458\u0457\3\2\2\2\u0458\u0459")
        buf.write("\3\2\2\2\u0459\u045a\3\2\2\2\u045a\u045c\5\u0086D\2\u045b")
        buf.write("\u0454\3\2\2\2\u045c\u045f\3\2\2\2\u045d\u045b\3\2\2\2")
        buf.write("\u045d\u045e\3\2\2\2\u045e\u0085\3\2\2\2\u045f\u045d\3")
        buf.write("\2\2\2\u0460\u0467\5\u0088E\2\u0461\u0463\t\3\2\2\u0462")
        buf.write("\u0464\7\177\2\2\u0463\u0462\3\2\2\2\u0463\u0464\3\2\2")
        buf.write("\2\u0464\u0465\3\2\2\2\u0465\u0467\5\u0088E\2\u0466\u0460")
        buf.write("\3\2\2\2\u0466\u0461\3\2\2\2\u0467\u0087\3\2\2\2\u0468")
        buf.write("\u047e\5\u008aF\2\u0469\u046b\7\177\2\2\u046a\u0469\3")
        buf.write("\2\2\2\u046a\u046b\3\2\2\2\u046b\u046c\3\2\2\2\u046c\u046d")
        buf.write("\7\f\2\2\u046d\u046e\5j\66\2\u046e\u046f\7\r\2\2\u046f")
        buf.write("\u047d\3\2\2\2\u0470\u0472\7\177\2\2\u0471\u0470\3\2\2")
        buf.write("\2\u0471\u0472\3\2\2\2\u0472\u0473\3\2\2\2\u0473\u0475")
        buf.write("\7\f\2\2\u0474\u0476\5j\66\2\u0475\u0474\3\2\2\2\u0475")
        buf.write("\u0476\3\2\2\2\u0476\u0477\3\2\2\2\u0477\u0479\7\20\2")
        buf.write("\2\u0478\u047a\5j\66\2\u0479\u0478\3\2\2\2\u0479\u047a")
        buf.write("\3\2\2\2\u047a\u047b\3\2\2\2\u047b\u047d\7\r\2\2\u047c")
        buf.write("\u046a\3\2\2\2\u047c\u0471\3\2\2\2\u047d\u0480\3\2\2\2")
        buf.write("\u047e\u047c\3\2\2\2\u047e\u047f\3\2\2\2\u047f\u0089\3")
        buf.write("\2\2\2\u0480\u047e\3\2\2\2\u0481\u0488\5\u008eH\2\u0482")
        buf.write("\u0484\7\177\2\2\u0483\u0482\3\2\2\2\u0483\u0484\3\2\2")
        buf.write("\2\u0484\u0485\3\2\2\2\u0485\u0487\5\u008cG\2\u0486\u0483")
        buf.write("\3\2\2\2\u0487\u048a\3\2\2\2\u0488\u0486\3\2\2\2\u0488")
        buf.write("\u0489\3\2\2\2\u0489\u048f\3\2\2\2\u048a\u0488\3\2\2\2")
        buf.write("\u048b\u048d\7\177\2\2\u048c\u048b\3\2\2\2\u048c\u048d")
        buf.write("\3\2\2\2\u048d\u048e\3\2\2\2\u048e\u0490\5^\60\2\u048f")
        buf.write("\u048c\3\2\2\2\u048f\u0490\3\2\2\2\u0490\u008b\3\2\2\2")
        buf.write("\u0491\u0493\7\33\2\2\u0492\u0494\7\177\2\2\u0493\u0492")
        buf.write("\3\2\2\2\u0493\u0494\3\2\2\2\u0494\u0495\3\2\2\2\u0495")
        buf.write("\u0496\5\u00c2b\2\u0496\u008d\3\2\2\2\u0497\u04b0\5\u00b4")
        buf.write("[\2\u0498\u04b0\5\u00c4c\2\u0499\u04b0\5\u0090I\2\u049a")
        buf.write("\u049c\7U\2\2\u049b\u049d\7\177\2\2\u049c\u049b\3\2\2")
        buf.write("\2\u049c\u049d\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u04a0")
        buf.write("\7\n\2\2\u049f\u04a1\7\177\2\2\u04a0\u049f\3\2\2\2\u04a0")
        buf.write("\u04a1\3\2\2\2\u04a1\u04a2\3\2\2\2\u04a2\u04a4\7\t\2\2")
        buf.write("\u04a3\u04a5\7\177\2\2\u04a4\u04a3\3\2\2\2\u04a4\u04a5")
        buf.write("\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u04b0\7\13\2\2\u04a7")
        buf.write("\u04b0\5\u0094K\2\u04a8\u04b0\5\u0096L\2\u04a9\u04b0\5")
        buf.write("\u0098M\2\u04aa\u04b0\5\u009cO\2\u04ab\u04b0\5\u009eP")
        buf.write("\2\u04ac\u04b0\5\u00a2R\2\u04ad\u04b0\5\u00a6T\2\u04ae")
        buf.write("\u04b0\5\u00b2Z\2\u04af\u0497\3\2\2\2\u04af\u0498\3\2")
        buf.write("\2\2\u04af\u0499\3\2\2\2\u04af\u049a\3\2\2\2\u04af\u04a7")
        buf.write("\3\2\2\2\u04af\u04a8\3\2\2\2\u04af\u04a9\3\2\2\2\u04af")
        buf.write("\u04aa\3\2\2\2\u04af\u04ab\3\2\2\2\u04af\u04ac\3\2\2\2")
        buf.write("\u04af\u04ad\3\2\2\2\u04af\u04ae\3\2\2\2\u04b0\u008f\3")
        buf.write("\2\2\2\u04b1\u04b6\7V\2\2\u04b2\u04b4\7\177\2\2\u04b3")
        buf.write("\u04b2\3\2\2\2\u04b3\u04b4\3\2\2\2\u04b4\u04b5\3\2\2\2")
        buf.write("\u04b5\u04b7\5\u0092J\2\u04b6\u04b3\3\2\2\2\u04b7\u04b8")
        buf.write("\3\2\2\2\u04b8\u04b6\3\2\2\2\u04b8\u04b9\3\2\2\2\u04b9")
        buf.write("\u04c8\3\2\2\2\u04ba\u04bc\7V\2\2\u04bb\u04bd\7\177\2")
        buf.write("\2\u04bc\u04bb\3\2\2\2\u04bc\u04bd\3\2\2\2\u04bd\u04be")
        buf.write("\3\2\2\2\u04be\u04c3\5j\66\2\u04bf\u04c1\7\177\2\2\u04c0")
        buf.write("\u04bf\3\2\2\2\u04c0\u04c1\3\2\2\2\u04c1\u04c2\3\2\2\2")
        buf.write("\u04c2\u04c4\5\u0092J\2\u04c3\u04c0\3\2\2\2\u04c4\u04c5")
        buf.write("\3\2\2\2\u04c5\u04c3\3\2\2\2\u04c5\u04c6\3\2\2\2\u04c6")
        buf.write("\u04c8\3\2\2\2\u04c7\u04b1\3\2\2\2\u04c7\u04ba\3\2\2\2")
        buf.write("\u04c8\u04d1\3\2\2\2\u04c9\u04cb\7\177\2\2\u04ca\u04c9")
        buf.write("\3\2\2\2\u04ca\u04cb\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc")
        buf.write("\u04ce\7W\2\2\u04cd\u04cf\7\177\2\2\u04ce\u04cd\3\2\2")
        buf.write("\2\u04ce\u04cf\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\u04d2")
        buf.write("\5j\66\2\u04d1\u04ca\3\2\2\2\u04d1\u04d2\3\2\2\2\u04d2")
        buf.write("\u04d4\3\2\2\2\u04d3\u04d5\7\177\2\2\u04d4\u04d3\3\2\2")
        buf.write("\2\u04d4\u04d5\3\2\2\2\u04d5\u04d6\3\2\2\2\u04d6\u04d7")
        buf.write("\7X\2\2\u04d7\u0091\3\2\2\2\u04d8\u04da\7Y\2\2\u04d9\u04db")
        buf.write("\7\177\2\2\u04da\u04d9\3\2\2\2\u04da\u04db\3\2\2\2\u04db")
        buf.write("\u04dc\3\2\2\2\u04dc\u04de\5j\66\2\u04dd\u04df\7\177\2")
        buf.write("\2\u04de\u04dd\3\2\2\2\u04de\u04df\3\2\2\2\u04df\u04e0")
        buf.write("\3\2\2\2\u04e0\u04e2\7Z\2\2\u04e1\u04e3\7\177\2\2\u04e2")
        buf.write("\u04e1\3\2\2\2\u04e2\u04e3\3\2\2\2\u04e3\u04e4\3\2\2\2")
        buf.write("\u04e4\u04e5\5j\66\2\u04e5\u0093\3\2\2\2\u04e6\u04e8\7")
        buf.write("\f\2\2\u04e7\u04e9\7\177\2\2\u04e8\u04e7\3\2\2\2\u04e8")
        buf.write("\u04e9\3\2\2\2\u04e9\u04ea\3\2\2\2\u04ea\u04f3\5\u009a")
        buf.write("N\2\u04eb\u04ed\7\177\2\2\u04ec\u04eb\3\2\2\2\u04ec\u04ed")
        buf.write("\3\2\2\2\u04ed\u04ee\3\2\2\2\u04ee\u04f0\7\17\2\2\u04ef")
        buf.write("\u04f1\7\177\2\2\u04f0\u04ef\3\2\2\2\u04f0\u04f1\3\2\2")
        buf.write("\2\u04f1\u04f2\3\2\2\2\u04f2\u04f4\5j\66\2\u04f3\u04ec")
        buf.write("\3\2\2\2\u04f3\u04f4\3\2\2\2\u04f4\u04f6\3\2\2\2\u04f5")
        buf.write("\u04f7\7\177\2\2\u04f6\u04f5\3\2\2\2\u04f6\u04f7\3\2\2")
        buf.write("\2\u04f7\u04f8\3\2\2\2\u04f8\u04f9\7\r\2\2\u04f9\u0095")
        buf.write("\3\2\2\2\u04fa\u04fc\7\f\2\2\u04fb\u04fd\7\177\2\2\u04fc")
        buf.write("\u04fb\3\2\2\2\u04fc\u04fd\3\2\2\2\u04fd\u0506\3\2\2\2")
        buf.write("\u04fe\u0500\5\u00b2Z\2\u04ff\u0501\7\177\2\2\u0500\u04ff")
        buf.write("\3\2\2\2\u0500\u0501\3\2\2\2\u0501\u0502\3\2\2\2\u0502")
        buf.write("\u0504\7\7\2\2\u0503\u0505\7\177\2\2\u0504\u0503\3\2\2")
        buf.write("\2\u0504\u0505\3\2\2\2\u0505\u0507\3\2\2\2\u0506\u04fe")
        buf.write("\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u0508\3\2\2\2\u0508")
        buf.write("\u050a\5P)\2\u0509\u050b\7\177\2\2\u050a\u0509\3\2\2\2")
        buf.write("\u050a\u050b\3\2\2\2\u050b\u0510\3\2\2\2\u050c\u050e\5")
        buf.write("F$\2\u050d\u050f\7\177\2\2\u050e\u050d\3\2\2\2\u050e\u050f")
        buf.write("\3\2\2\2\u050f\u0511\3\2\2\2\u0510\u050c\3\2\2\2\u0510")
        buf.write("\u0511\3\2\2\2\u0511\u0512\3\2\2\2\u0512\u0514\7\17\2")
        buf.write("\2\u0513\u0515\7\177\2\2\u0514\u0513\3\2\2\2\u0514\u0515")
        buf.write("\3\2\2\2\u0515\u0516\3\2\2\2\u0516\u0518\5j\66\2\u0517")
        buf.write("\u0519\7\177\2\2\u0518\u0517\3\2\2\2\u0518\u0519\3\2\2")
        buf.write("\2\u0519\u051a\3\2\2\2\u051a\u051b\7\r\2\2\u051b\u0097")
        buf.write("\3\2\2\2\u051c\u051e\7\61\2\2\u051d\u051f\7\177\2\2\u051e")
        buf.write("\u051d\3\2\2\2\u051e\u051f\3\2\2\2\u051f\u0520\3\2\2\2")
        buf.write("\u0520\u0522\7\n\2\2\u0521\u0523\7\177\2\2\u0522\u0521")
        buf.write("\3\2\2\2\u0522\u0523\3\2\2\2\u0523\u0524\3\2\2\2\u0524")
        buf.write("\u0526\5\u009aN\2\u0525\u0527\7\177\2\2\u0526\u0525\3")
        buf.write("\2\2\2\u0526\u0527\3\2\2\2\u0527\u0528\3\2\2\2\u0528\u0529")
        buf.write("\7\13\2\2\u0529\u0555\3\2\2\2\u052a\u052c\7[\2\2\u052b")
        buf.write("\u052d\7\177\2\2\u052c\u052b\3\2\2\2\u052c\u052d\3\2\2")
        buf.write("\2\u052d\u052e\3\2\2\2\u052e\u0530\7\n\2\2\u052f\u0531")
        buf.write("\7\177\2\2\u0530\u052f\3\2\2\2\u0530\u0531\3\2\2\2\u0531")
        buf.write("\u0532\3\2\2\2\u0532\u0534\5\u009aN\2\u0533\u0535\7\177")
        buf.write("\2\2\u0534\u0533\3\2\2\2\u0534\u0535\3\2\2\2\u0535\u0536")
        buf.write("\3\2\2\2\u0536\u0537\7\13\2\2\u0537\u0555\3\2\2\2\u0538")
        buf.write("\u053a\7\\\2\2\u0539\u053b\7\177\2\2\u053a\u0539\3\2\2")
        buf.write("\2\u053a\u053b\3\2\2\2\u053b\u053c\3\2\2\2\u053c\u053e")
        buf.write("\7\n\2\2\u053d\u053f\7\177\2\2\u053e\u053d\3\2\2\2\u053e")
        buf.write("\u053f\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0542\5\u009a")
        buf.write("N\2\u0541\u0543\7\177\2\2\u0542\u0541\3\2\2\2\u0542\u0543")
        buf.write("\3\2\2\2\u0543\u0544\3\2\2\2\u0544\u0545\7\13\2\2\u0545")
        buf.write("\u0555\3\2\2\2\u0546\u0548\7]\2\2\u0547\u0549\7\177\2")
        buf.write("\2\u0548\u0547\3\2\2\2\u0548\u0549\3\2\2\2\u0549\u054a")
        buf.write("\3\2\2\2\u054a\u054c\7\n\2\2\u054b\u054d\7\177\2\2\u054c")
        buf.write("\u054b\3\2\2\2\u054c\u054d\3\2\2\2\u054d\u054e\3\2\2\2")
        buf.write("\u054e\u0550\5\u009aN\2\u054f\u0551\7\177\2\2\u0550\u054f")
        buf.write("\3\2\2\2\u0550\u0551\3\2\2\2\u0551\u0552\3\2\2\2\u0552")
        buf.write("\u0553\7\13\2\2\u0553\u0555\3\2\2\2\u0554\u051c\3\2\2")
        buf.write("\2\u0554\u052a\3\2\2\2\u0554\u0538\3\2\2\2\u0554\u0546")
        buf.write("\3\2\2\2\u0555\u0099\3\2\2\2\u0556\u055b\5\u00a0Q\2\u0557")
        buf.write("\u0559\7\177\2\2\u0558\u0557\3\2\2\2\u0558\u0559\3\2\2")
        buf.write("\2\u0559\u055a\3\2\2\2\u055a\u055c\5F$\2\u055b\u0558\3")
        buf.write("\2\2\2\u055b\u055c\3\2\2\2\u055c\u009b\3\2\2\2\u055d\u055e")
        buf.write("\5P)\2\u055e\u009d\3\2\2\2\u055f\u0561\7\n\2\2\u0560\u0562")
        buf.write("\7\177\2\2\u0561\u0560\3\2\2\2\u0561\u0562\3\2\2\2\u0562")
        buf.write("\u0563\3\2\2\2\u0563\u0565\5j\66\2\u0564\u0566\7\177\2")
        buf.write("\2\u0565\u0564\3\2\2\2\u0565\u0566\3\2\2\2\u0566\u0567")
        buf.write("\3\2\2\2\u0567\u0568\7\13\2\2\u0568\u009f\3\2\2\2\u0569")
        buf.write("\u056a\5\u00b2Z\2\u056a\u056b\7\177\2\2\u056b\u056c\7")
        buf.write("R\2\2\u056c\u056d\7\177\2\2\u056d\u056e\5j\66\2\u056e")
        buf.write("\u00a1\3\2\2\2\u056f\u0571\5\u00a4S\2\u0570\u0572\7\177")
        buf.write("\2\2\u0571\u0570\3\2\2\2\u0571\u0572\3\2\2\2\u0572\u0573")
        buf.write("\3\2\2\2\u0573\u0575\7\n\2\2\u0574\u0576\7\177\2\2\u0575")
        buf.write("\u0574\3\2\2\2\u0575\u0576\3\2\2\2\u0576\u057b\3\2\2\2")
        buf.write("\u0577\u0579\7A\2\2\u0578\u057a\7\177\2\2\u0579\u0578")
        buf.write("\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057c\3\2\2\2\u057b")
        buf.write("\u0577\3\2\2\2\u057b\u057c\3\2\2\2\u057c\u058e\3\2\2\2")
        buf.write("\u057d\u057f\5j\66\2\u057e\u0580\7\177\2\2\u057f\u057e")
        buf.write("\3\2\2\2\u057f\u0580\3\2\2\2\u0580\u058b\3\2\2\2\u0581")
        buf.write("\u0583\7\6\2\2\u0582\u0584\7\177\2\2\u0583\u0582\3\2\2")
        buf.write("\2\u0583\u0584\3\2\2\2\u0584\u0585\3\2\2\2\u0585\u0587")
        buf.write("\5j\66\2\u0586\u0588\7\177\2\2\u0587\u0586\3\2\2\2\u0587")
        buf.write("\u0588\3\2\2\2\u0588\u058a\3\2\2\2\u0589\u0581\3\2\2\2")
        buf.write("\u058a\u058d\3\2\2\2\u058b\u0589\3\2\2\2\u058b\u058c\3")
        buf.write("\2\2\2\u058c\u058f\3\2\2\2\u058d\u058b\3\2\2\2\u058e\u057d")
        buf.write("\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0590\3\2\2\2\u0590")
        buf.write("\u0591\7\13\2\2\u0591\u00a3\3\2\2\2\u0592\u0593\5\u00b0")
        buf.write("Y\2\u0593\u0594\5\u00caf\2\u0594\u00a5\3\2\2\2\u0595\u0597")
        buf.write("\7^\2\2\u0596\u0598\7\177\2\2\u0597\u0596\3\2\2\2\u0597")
        buf.write("\u0598\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u059b\7\4\2\2")
        buf.write("\u059a\u059c\7\177\2\2\u059b\u059a\3\2\2\2\u059b\u059c")
        buf.write("\3\2\2\2\u059c\u05a5\3\2\2\2\u059d\u05a6\5\n\6\2\u059e")
        buf.write("\u05a3\5H%\2\u059f\u05a1\7\177\2\2\u05a0\u059f\3\2\2\2")
        buf.write("\u05a0\u05a1\3\2\2\2\u05a1\u05a2\3\2\2\2\u05a2\u05a4\5")
        buf.write("F$\2\u05a3\u05a0\3\2\2\2\u05a3\u05a4\3\2\2\2\u05a4\u05a6")
        buf.write("\3\2\2\2\u05a5\u059d\3\2\2\2\u05a5\u059e\3\2\2\2\u05a6")
        buf.write("\u05a8\3\2\2\2\u05a7\u05a9\7\177\2\2\u05a8\u05a7\3\2\2")
        buf.write("\2\u05a8\u05a9\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aa\u05ab")
        buf.write("\7\5\2\2\u05ab\u00a7\3\2\2\2\u05ac\u05ae\5\u00aeX\2\u05ad")
        buf.write("\u05af\7\177\2\2\u05ae\u05ad\3\2\2\2\u05ae\u05af\3\2\2")
        buf.write("\2\u05af\u05b0\3\2\2\2\u05b0\u05b2\7\n\2\2\u05b1\u05b3")
        buf.write("\7\177\2\2\u05b2\u05b1\3\2\2\2\u05b2\u05b3\3\2\2\2\u05b3")
        buf.write("\u05c5\3\2\2\2\u05b4\u05b6\5j\66\2\u05b5\u05b7\7\177\2")
        buf.write("\2\u05b6\u05b5\3\2\2\2\u05b6\u05b7\3\2\2\2\u05b7\u05c2")
        buf.write("\3\2\2\2\u05b8\u05ba\7\6\2\2\u05b9\u05bb\7\177\2\2\u05ba")
        buf.write("\u05b9\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb\u05bc\3\2\2\2")
        buf.write("\u05bc\u05be\5j\66\2\u05bd\u05bf\7\177\2\2\u05be\u05bd")
        buf.write("\3\2\2\2\u05be\u05bf\3\2\2\2\u05bf\u05c1\3\2\2\2\u05c0")
        buf.write("\u05b8\3\2\2\2\u05c1\u05c4\3\2\2\2\u05c2\u05c0\3\2\2\2")
        buf.write("\u05c2\u05c3\3\2\2\2\u05c3\u05c6\3\2\2\2\u05c4\u05c2\3")
        buf.write("\2\2\2\u05c5\u05b4\3\2\2\2\u05c5\u05c6\3\2\2\2\u05c6\u05c7")
        buf.write("\3\2\2\2\u05c7\u05c8\7\13\2\2\u05c8\u00a9\3\2\2\2\u05c9")
        buf.write("\u05ca\5\u00aeX\2\u05ca\u00ab\3\2\2\2\u05cb\u05cc\5\u00ca")
        buf.write("f\2\u05cc\u00ad\3\2\2\2\u05cd\u05ce\5\u00b0Y\2\u05ce\u05cf")
        buf.write("\5\u00caf\2\u05cf\u00af\3\2\2\2\u05d0\u05d1\5\u00caf\2")
        buf.write("\u05d1\u05d2\7\33\2\2\u05d2\u05d4\3\2\2\2\u05d3\u05d0")
        buf.write("\3\2\2\2\u05d4\u05d7\3\2\2\2\u05d5\u05d3\3\2\2\2\u05d5")
        buf.write("\u05d6\3\2\2\2\u05d6\u00b1\3\2\2\2\u05d7\u05d5\3\2\2\2")
        buf.write("\u05d8\u05d9\5\u00caf\2\u05d9\u00b3\3\2\2\2\u05da\u05e1")
        buf.write("\5\u00b6\\\2\u05db\u05e1\7T\2\2\u05dc\u05e1\5\u00b8]\2")
        buf.write("\u05dd\u05e1\7m\2\2\u05de\u05e1\5\u00be`\2\u05df\u05e1")
        buf.write("\5\u00c0a\2\u05e0\u05da\3\2\2\2\u05e0\u05db\3\2\2\2\u05e0")
        buf.write("\u05dc\3\2\2\2\u05e0\u05dd\3\2\2\2\u05e0\u05de\3\2\2\2")
        buf.write("\u05e0\u05df\3\2\2\2\u05e1\u00b5\3\2\2\2\u05e2\u05e3\t")
        buf.write("\4\2\2\u05e3\u00b7\3\2\2\2\u05e4\u05e7\5\u00bc_\2\u05e5")
        buf.write("\u05e7\5\u00ba^\2\u05e6\u05e4\3\2\2\2\u05e6\u05e5\3\2")
        buf.write("\2\2\u05e7\u00b9\3\2\2\2\u05e8\u05e9\t\5\2\2\u05e9\u00bb")
        buf.write("\3\2\2\2\u05ea\u05eb\t\6\2\2\u05eb\u00bd\3\2\2\2\u05ec")
        buf.write("\u05ee\7\f\2\2\u05ed\u05ef\7\177\2\2\u05ee\u05ed\3\2\2")
        buf.write("\2\u05ee\u05ef\3\2\2\2\u05ef\u0601\3\2\2\2\u05f0\u05f2")
        buf.write("\5j\66\2\u05f1\u05f3\7\177\2\2\u05f2\u05f1\3\2\2\2\u05f2")
        buf.write("\u05f3\3\2\2\2\u05f3\u05fe\3\2\2\2\u05f4\u05f6\7\6\2\2")
        buf.write("\u05f5\u05f7\7\177\2\2\u05f6\u05f5\3\2\2\2\u05f6\u05f7")
        buf.write("\3\2\2\2\u05f7\u05f8\3\2\2\2\u05f8\u05fa\5j\66\2\u05f9")
        buf.write("\u05fb\7\177\2\2\u05fa\u05f9\3\2\2\2\u05fa\u05fb\3\2\2")
        buf.write("\2\u05fb\u05fd\3\2\2\2\u05fc\u05f4\3\2\2\2\u05fd\u0600")
        buf.write("\3\2\2\2\u05fe\u05fc\3\2\2\2\u05fe\u05ff\3\2\2\2\u05ff")
        buf.write("\u0602\3\2\2\2\u0600\u05fe\3\2\2\2\u0601\u05f0\3\2\2\2")
        buf.write("\u0601\u0602\3\2\2\2\u0602\u0603\3\2\2\2\u0603\u0604\7")
        buf.write("\r\2\2\u0604\u00bf\3\2\2\2\u0605\u0607\7\4\2\2\u0606\u0608")
        buf.write("\7\177\2\2\u0607\u0606\3\2\2\2\u0607\u0608\3\2\2\2\u0608")
        buf.write("\u062a\3\2\2\2\u0609\u060b\5\u00c2b\2\u060a\u060c\7\177")
        buf.write("\2\2\u060b\u060a\3\2\2\2\u060b\u060c\3\2\2\2\u060c\u060d")
        buf.write("\3\2\2\2\u060d\u060f\7\16\2\2\u060e\u0610\7\177\2\2\u060f")
        buf.write("\u060e\3\2\2\2\u060f\u0610\3\2\2\2\u0610\u0611\3\2\2\2")
        buf.write("\u0611\u0613\5j\66\2\u0612\u0614\7\177\2\2\u0613\u0612")
        buf.write("\3\2\2\2\u0613\u0614\3\2\2\2\u0614\u0627\3\2\2\2\u0615")
        buf.write("\u0617\7\6\2\2\u0616\u0618\7\177\2\2\u0617\u0616\3\2\2")
        buf.write("\2\u0617\u0618\3\2\2\2\u0618\u0619\3\2\2\2\u0619\u061b")
        buf.write("\5\u00c2b\2\u061a\u061c\7\177\2\2\u061b\u061a\3\2\2\2")
        buf.write("\u061b\u061c\3\2\2\2\u061c\u061d\3\2\2\2\u061d\u061f\7")
        buf.write("\16\2\2\u061e\u0620\7\177\2\2\u061f\u061e\3\2\2\2\u061f")
        buf.write("\u0620\3\2\2\2\u0620\u0621\3\2\2\2\u0621\u0623\5j\66\2")
        buf.write("\u0622\u0624\7\177\2\2\u0623\u0622\3\2\2\2\u0623\u0624")
        buf.write("\3\2\2\2\u0624\u0626\3\2\2\2\u0625\u0615\3\2\2\2\u0626")
        buf.write("\u0629\3\2\2\2\u0627\u0625\3\2\2\2\u0627\u0628\3\2\2\2")
        buf.write("\u0628\u062b\3\2\2\2\u0629\u0627\3\2\2\2\u062a\u0609\3")
        buf.write("\2\2\2\u062a\u062b\3\2\2\2\u062b\u062c\3\2\2\2\u062c\u062d")
        buf.write("\7\5\2\2\u062d\u00c1\3\2\2\2\u062e\u062f\5\u00c6d\2\u062f")
        buf.write("\u00c3\3\2\2\2\u0630\u0633\7\34\2\2\u0631\u0634\5\u00ca")
        buf.write("f\2\u0632\u0634\7b\2\2\u0633\u0631\3\2\2\2\u0633\u0632")
        buf.write("\3\2\2\2\u0634\u00c5\3\2\2\2\u0635\u0638\5\u00caf\2\u0636")
        buf.write("\u0638\5\u00c8e\2\u0637\u0635\3\2\2\2\u0637\u0636\3\2")
        buf.write("\2\2\u0638\u00c7\3\2\2\2\u0639\u063a\t\7\2\2\u063a\u00c9")
        buf.write("\3\2\2\2\u063b\u063c\t\b\2\2\u063c\u00cb\3\2\2\2\u063d")
        buf.write("\u063e\t\t\2\2\u063e\u00cd\3\2\2\2\u063f\u0640\t\n\2\2")
        buf.write("\u0640\u00cf\3\2\2\2\u0641\u0642\t\13\2\2\u0642\u00d1")
        buf.write("\3\2\2\2\u012a\u00d3\u00d7\u00da\u00dd\u00e6\u00ea\u00ee")
        buf.write("\u00f2\u00f6\u00fc\u0101\u0108\u010d\u0110\u0114\u0118")
        buf.write("\u011c\u0122\u0126\u012b\u0130\u0134\u0137\u0139\u013d")
        buf.write("\u0141\u0146\u014a\u014f\u0153\u015c\u0161\u0165\u0169")
        buf.write("\u016d\u0170\u0174\u017e\u0185\u0192\u0196\u019c\u01a0")
        buf.write("\u01a4\u01a9\u01ae\u01b2\u01b8\u01bc\u01c2\u01c6\u01cc")
        buf.write("\u01d0\u01d4\u01d8\u01dc\u01e0\u01e5\u01ec\u01f0\u01f5")
        buf.write("\u01fc\u0202\u0207\u020d\u0210\u0216\u0218\u021c\u0220")
        buf.write("\u0225\u0229\u022c\u0233\u023a\u023d\u0243\u0246\u024c")
        buf.write("\u0250\u0254\u0258\u025c\u0261\u0266\u026a\u026f\u0272")
        buf.write("\u027b\u0284\u0289\u0296\u0299\u02a1\u02a5\u02aa\u02af")
        buf.write("\u02b3\u02b8\u02be\u02c3\u02ca\u02ce\u02d3\u02d7\u02db")
        buf.write("\u02dd\u02e1\u02e3\u02e7\u02e9\u02ef\u02f5\u02f9\u02fc")
        buf.write("\u02ff\u0303\u0309\u030d\u0310\u0313\u0319\u031c\u031f")
        buf.write("\u0323\u0329\u032c\u032f\u0333\u0337\u033b\u033d\u0341")
        buf.write("\u0343\u0346\u034a\u034c\u0352\u0356\u035a\u035e\u0361")
        buf.write("\u0366\u036b\u0370\u0375\u037b\u037f\u0381\u0385\u0389")
        buf.write("\u038b\u038d\u0395\u039a\u03a5\u03af\u03b9\u03be\u03c2")
        buf.write("\u03c9\u03ce\u03d3\u03d8\u03dd\u03e2\u03e7\u03ec\u03ef")
        buf.write("\u03f5\u03f7\u0404\u0407\u040e\u041c\u0420\u0424\u0428")
        buf.write("\u042c\u042f\u0431\u0436\u043a\u043e\u0442\u0446\u044a")
        buf.write("\u044d\u044f\u0454\u0458\u045d\u0463\u0466\u046a\u0471")
        buf.write("\u0475\u0479\u047c\u047e\u0483\u0488\u048c\u048f\u0493")
        buf.write("\u049c\u04a0\u04a4\u04af\u04b3\u04b8\u04bc\u04c0\u04c5")
        buf.write("\u04c7\u04ca\u04ce\u04d1\u04d4\u04da\u04de\u04e2\u04e8")
        buf.write("\u04ec\u04f0\u04f3\u04f6\u04fc\u0500\u0504\u0506\u050a")
        buf.write("\u050e\u0510\u0514\u0518\u051e\u0522\u0526\u052c\u0530")
        buf.write("\u0534\u053a\u053e\u0542\u0548\u054c\u0550\u0554\u0558")
        buf.write("\u055b\u0561\u0565\u0571\u0575\u0579\u057b\u057f\u0583")
        buf.write("\u0587\u058b\u058e\u0597\u059b\u05a0\u05a3\u05a5\u05a8")
        buf.write("\u05ae\u05b2\u05b6\u05ba\u05be\u05c2\u05c5\u05d5\u05e0")
        buf.write("\u05e6\u05ee\u05f2\u05f6\u05fa\u05fe\u0601\u0607\u060b")
        buf.write("\u060f\u0613\u0617\u061b\u061f\u0623\u0627\u062a\u0633")
        buf.write("\u0637")
        return buf.getvalue()


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>", "'0'" ]

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

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

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

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    UNION=46
    ALL=47
    OPTIONAL=48
    MATCH=49
    UNWIND=50
    AS=51
    MERGE=52
    ON=53
    CREATE=54
    SET=55
    DETACH=56
    DELETE=57
    REMOVE=58
    CALL=59
    YIELD=60
    WITH=61
    RETURN=62
    DISTINCT=63
    ORDER=64
    BY=65
    L_SKIP=66
    LIMIT=67
    ASCENDING=68
    ASC=69
    DESCENDING=70
    DESC=71
    WHERE=72
    OR=73
    XOR=74
    AND=75
    NOT=76
    STARTS=77
    ENDS=78
    CONTAINS=79
    IN=80
    IS=81
    NULL=82
    COUNT=83
    CASE=84
    ELSE=85
    END=86
    WHEN=87
    THEN=88
    ANY=89
    NONE=90
    SINGLE=91
    EXISTS=92
    TRUE=93
    FALSE=94
    HexInteger=95
    DecimalInteger=96
    OctalInteger=97
    HexLetter=98
    HexDigit=99
    Digit=100
    NonZeroDigit=101
    NonZeroOctDigit=102
    OctDigit=103
    ZeroDigit=104
    ExponentDecimalReal=105
    RegularDecimalReal=106
    StringLiteral=107
    EscapedChar=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.9.3")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class OC_CypherContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Statement(self):
            return self.getTypedRuleContext(CypherParser.OC_StatementContext,0)


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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_Cypher

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

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

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




    def oC_Cypher(self):

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


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


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


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


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


    class OC_StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Statement

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

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

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




    def oC_Statement(self):

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


    class OC_QueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def oC_CallSubQuery(self):
            return self.getTypedRuleContext(CypherParser.OC_CallSubQueryContext,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 = 228
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 225
                self.oC_RegularQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 226
                self.oC_StandaloneCall()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 227
                self.oC_CallSubQuery()
                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_CallSubQueryContext(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 oC_RegularQuery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CypherParser.OC_RegularQueryContext)
            else:
                return self.getTypedRuleContext(CypherParser.OC_RegularQueryContext,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_CallSubQuery

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

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

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




    def oC_CallSubQuery(self):

        localctx = CypherParser.OC_CallSubQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_oC_CallSubQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 230
            self.match(CypherParser.CALL)
            self.state = 232
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 231
                self.match(CypherParser.SP)


            self.state = 234
            self.match(CypherParser.T__1)
            self.state = 236
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 235
                self.match(CypherParser.SP)


            self.state = 238
            self.oC_RegularQuery()
            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.match(CypherParser.T__2)
            self.state = 244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 243
                self.match(CypherParser.SP)


            self.state = 246
            self.oC_RegularQuery()
        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, 8, self.RULE_oC_RegularQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 248
            self.oC_SingleQuery()
            self.state = 255
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,10,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 250
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 249
                        self.match(CypherParser.SP)


                    self.state = 252
                    self.oC_Union() 
                self.state = 257
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,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, 10, self.RULE_oC_Union)
        self._la = 0 # Token type
        try:
            self.state = 270
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 258
                self.match(CypherParser.UNION)
                self.state = 259
                self.match(CypherParser.SP)
                self.state = 260
                self.match(CypherParser.ALL)
                self.state = 262
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 261
                    self.match(CypherParser.SP)


                self.state = 264
                self.oC_SingleQuery()
                pass

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


                self.state = 269
                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, 12, self.RULE_oC_SingleQuery)
        try:
            self.state = 274
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 272
                self.oC_SinglePartQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 273
                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, 14, self.RULE_oC_SinglePartQuery)
        self._la = 0 # Token type
        try:
            self.state = 311
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 282
                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 = 276
                    self.oC_ReadingClause()
                    self.state = 278
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 277
                        self.match(CypherParser.SP)


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

                self.state = 285
                self.oC_Return()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                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 = 295
                self.oC_UpdatingClause()
                self.state = 302
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,20,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        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 = 299
                        self.oC_UpdatingClause() 
                    self.state = 304
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,20,self._ctx)

                self.state = 309
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
                if la_ == 1:
                    self.state = 306
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 305
                        self.match(CypherParser.SP)


                    self.state = 308
                    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, 16, self.RULE_oC_MultiPartQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 335 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 319
                    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 = 313
                        self.oC_ReadingClause()
                        self.state = 315
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 314
                            self.match(CypherParser.SP)


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

                    self.state = 328
                    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 = 322
                        self.oC_UpdatingClause()
                        self.state = 324
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 323
                            self.match(CypherParser.SP)


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

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



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

            self.state = 339
            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, 18, self.RULE_oC_UpdatingClause)
        try:
            self.state = 346
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.CREATE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 341
                self.oC_Create()
                pass
            elif token in [CypherParser.MERGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 342
                self.oC_Merge()
                pass
            elif token in [CypherParser.DETACH, CypherParser.DELETE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 343
                self.oC_Delete()
                pass
            elif token in [CypherParser.SET]:
                self.enterOuterAlt(localctx, 4)
                self.state = 344
                self.oC_Set()
                pass
            elif token in [CypherParser.REMOVE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 345
                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, 20, self.RULE_oC_ReadingClause)
        try:
            self.state = 351
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.OPTIONAL, CypherParser.MATCH]:
                self.enterOuterAlt(localctx, 1)
                self.state = 348
                self.oC_Match()
                pass
            elif token in [CypherParser.UNWIND]:
                self.enterOuterAlt(localctx, 2)
                self.state = 349
                self.oC_Unwind()
                pass
            elif token in [CypherParser.CALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 350
                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, 22, self.RULE_oC_Match)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 355
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.OPTIONAL:
                self.state = 353
                self.match(CypherParser.OPTIONAL)
                self.state = 354
                self.match(CypherParser.SP)


            self.state = 357
            self.match(CypherParser.MATCH)
            self.state = 359
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 358
                self.match(CypherParser.SP)


            self.state = 361
            self.oC_Pattern()
            self.state = 366
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.state = 363
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 362
                    self.match(CypherParser.SP)


                self.state = 365
                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, 24, self.RULE_oC_Unwind)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 368
            self.match(CypherParser.UNWIND)
            self.state = 370
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 369
                self.match(CypherParser.SP)


            self.state = 372
            self.oC_Expression()
            self.state = 373
            self.match(CypherParser.SP)
            self.state = 374
            self.match(CypherParser.AS)
            self.state = 375
            self.match(CypherParser.SP)
            self.state = 376
            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, 26, self.RULE_oC_Merge)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            self.match(CypherParser.MERGE)
            self.state = 380
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 379
                self.match(CypherParser.SP)


            self.state = 382
            self.oC_PatternPart()
            self.state = 387
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,38,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 383
                    self.match(CypherParser.SP)
                    self.state = 384
                    self.oC_MergeAction() 
                self.state = 389
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,38,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, 28, self.RULE_oC_MergeAction)
        try:
            self.state = 400
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 390
                self.match(CypherParser.ON)
                self.state = 391
                self.match(CypherParser.SP)
                self.state = 392
                self.match(CypherParser.MATCH)
                self.state = 393
                self.match(CypherParser.SP)
                self.state = 394
                self.oC_Set()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 395
                self.match(CypherParser.ON)
                self.state = 396
                self.match(CypherParser.SP)
                self.state = 397
                self.match(CypherParser.CREATE)
                self.state = 398
                self.match(CypherParser.SP)
                self.state = 399
                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, 30, self.RULE_oC_Create)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 402
            self.match(CypherParser.CREATE)
            self.state = 404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 403
                self.match(CypherParser.SP)


            self.state = 406
            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, 32, self.RULE_oC_Set)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 408
            self.match(CypherParser.SET)
            self.state = 410
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 409
                self.match(CypherParser.SP)


            self.state = 412
            self.oC_SetItem()
            self.state = 423
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,44,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 414
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 413
                        self.match(CypherParser.SP)


                    self.state = 416
                    self.match(CypherParser.T__3)
                    self.state = 418
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 417
                        self.match(CypherParser.SP)


                    self.state = 420
                    self.oC_SetItem() 
                self.state = 425
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,44,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, 34, self.RULE_oC_SetItem)
        self._la = 0 # Token type
        try:
            self.state = 462
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 426
                self.oC_PropertyExpression()
                self.state = 428
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 427
                    self.match(CypherParser.SP)


                self.state = 430
                self.match(CypherParser.T__4)
                self.state = 432
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 431
                    self.match(CypherParser.SP)


                self.state = 434
                self.oC_Expression()
                pass

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


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


                self.state = 444
                self.oC_Expression()
                pass

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


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


                self.state = 454
                self.oC_Expression()
                pass

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


                self.state = 460
                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, 36, self.RULE_oC_Delete)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 466
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.DETACH:
                self.state = 464
                self.match(CypherParser.DETACH)
                self.state = 465
                self.match(CypherParser.SP)


            self.state = 468
            self.match(CypherParser.DELETE)
            self.state = 470
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 469
                self.match(CypherParser.SP)


            self.state = 472
            self.oC_Expression()
            self.state = 483
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,57,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 474
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 473
                        self.match(CypherParser.SP)


                    self.state = 476
                    self.match(CypherParser.T__3)
                    self.state = 478
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 477
                        self.match(CypherParser.SP)


                    self.state = 480
                    self.oC_Expression() 
                self.state = 485
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,57,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, 38, self.RULE_oC_Remove)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 486
            self.match(CypherParser.REMOVE)
            self.state = 487
            self.match(CypherParser.SP)
            self.state = 488
            self.oC_RemoveItem()
            self.state = 499
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 490
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 489
                        self.match(CypherParser.SP)


                    self.state = 492
                    self.match(CypherParser.T__3)
                    self.state = 494
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 493
                        self.match(CypherParser.SP)


                    self.state = 496
                    self.oC_RemoveItem() 
                self.state = 501
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,60,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, 40, self.RULE_oC_RemoveItem)
        try:
            self.state = 506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 502
                self.oC_Variable()
                self.state = 503
                self.oC_NodeLabels()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 505
                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, 42, self.RULE_oC_InQueryCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 508
            self.match(CypherParser.CALL)
            self.state = 509
            self.match(CypherParser.SP)
            self.state = 510
            self.oC_ExplicitProcedureInvocation()
            self.state = 517
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
            if la_ == 1:
                self.state = 512
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 511
                    self.match(CypherParser.SP)


                self.state = 514
                self.match(CypherParser.YIELD)
                self.state = 515
                self.match(CypherParser.SP)
                self.state = 516
                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, 44, self.RULE_oC_StandaloneCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 519
            self.match(CypherParser.CALL)
            self.state = 520
            self.match(CypherParser.SP)
            self.state = 523
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
            if la_ == 1:
                self.state = 521
                self.oC_ExplicitProcedureInvocation()
                pass

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


            self.state = 534
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
            if la_ == 1:
                self.state = 526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 525
                    self.match(CypherParser.SP)


                self.state = 528
                self.match(CypherParser.YIELD)
                self.state = 529
                self.match(CypherParser.SP)
                self.state = 532
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CypherParser.T__6]:
                    self.state = 530
                    self.match(CypherParser.T__6)
                    pass
                elif token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                    self.state = 531
                    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, 46, self.RULE_oC_YieldItems)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 536
            self.oC_YieldItem()
            self.state = 547
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,70,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 538
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 537
                        self.match(CypherParser.SP)


                    self.state = 540
                    self.match(CypherParser.T__3)
                    self.state = 542
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 541
                        self.match(CypherParser.SP)


                    self.state = 544
                    self.oC_YieldItem() 
                self.state = 549
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,70,self._ctx)

            self.state = 554
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 551
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 550
                    self.match(CypherParser.SP)


                self.state = 553
                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, 48, self.RULE_oC_YieldItem)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 561
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.state = 556
                self.oC_ProcedureResultField()
                self.state = 557
                self.match(CypherParser.SP)
                self.state = 558
                self.match(CypherParser.AS)
                self.state = 559
                self.match(CypherParser.SP)


            self.state = 563
            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, 50, self.RULE_oC_With)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 565
            self.match(CypherParser.WITH)
            self.state = 566
            self.oC_ProjectionBody()
            self.state = 571
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 568
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 567
                    self.match(CypherParser.SP)


                self.state = 570
                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, 52, self.RULE_oC_Return)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 573
            self.match(CypherParser.RETURN)
            self.state = 574
            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, 54, self.RULE_oC_ProjectionBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 580
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
            if la_ == 1:
                self.state = 577
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 576
                    self.match(CypherParser.SP)


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


            self.state = 582
            self.match(CypherParser.SP)
            self.state = 583
            self.oC_ProjectionItems()
            self.state = 586
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.state = 584
                self.match(CypherParser.SP)
                self.state = 585
                self.oC_Order()


            self.state = 590
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                self.state = 588
                self.match(CypherParser.SP)
                self.state = 589
                self.oC_Skip()


            self.state = 594
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
            if la_ == 1:
                self.state = 592
                self.match(CypherParser.SP)
                self.state = 593
                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, 56, self.RULE_oC_ProjectionItems)
        self._la = 0 # Token type
        try:
            self.state = 624
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__6]:
                self.enterOuterAlt(localctx, 1)
                self.state = 596
                self.match(CypherParser.T__6)
                self.state = 607
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,83,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 598
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 597
                            self.match(CypherParser.SP)


                        self.state = 600
                        self.match(CypherParser.T__3)
                        self.state = 602
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 601
                            self.match(CypherParser.SP)


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

                pass
            elif token in [CypherParser.T__1, CypherParser.T__7, CypherParser.T__9, CypherParser.T__19, CypherParser.T__20, CypherParser.T__25, CypherParser.ALL, CypherParser.NOT, CypherParser.NULL, CypherParser.COUNT, CypherParser.CASE, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.EXISTS, CypherParser.TRUE, CypherParser.FALSE, CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger, CypherParser.HexLetter, CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal, CypherParser.StringLiteral, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.enterOuterAlt(localctx, 2)
                self.state = 610
                self.oC_ProjectionItem()
                self.state = 621
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,86,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 612
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 611
                            self.match(CypherParser.SP)


                        self.state = 614
                        self.match(CypherParser.T__3)
                        self.state = 616
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 615
                            self.match(CypherParser.SP)


                        self.state = 618
                        self.oC_ProjectionItem() 
                    self.state = 623
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,86,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, 58, self.RULE_oC_ProjectionItem)
        try:
            self.state = 633
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 626
                self.oC_Expression()
                self.state = 627
                self.match(CypherParser.SP)
                self.state = 628
                self.match(CypherParser.AS)
                self.state = 629
                self.match(CypherParser.SP)
                self.state = 630
                self.oC_Variable()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 632
                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, 60, self.RULE_oC_Order)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 635
            self.match(CypherParser.ORDER)
            self.state = 636
            self.match(CypherParser.SP)
            self.state = 637
            self.match(CypherParser.BY)
            self.state = 638
            self.match(CypherParser.SP)
            self.state = 639
            self.oC_SortItem()
            self.state = 647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CypherParser.T__3:
                self.state = 640
                self.match(CypherParser.T__3)
                self.state = 642
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 641
                    self.match(CypherParser.SP)


                self.state = 644
                self.oC_SortItem()
                self.state = 649
                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, 62, self.RULE_oC_Skip)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 650
            self.match(CypherParser.L_SKIP)
            self.state = 651
            self.match(CypherParser.SP)
            self.state = 652
            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, 64, self.RULE_oC_Limit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 654
            self.match(CypherParser.LIMIT)
            self.state = 655
            self.match(CypherParser.SP)
            self.state = 656
            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, 66, self.RULE_oC_SortItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 658
            self.oC_Expression()
            self.state = 663
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
            if la_ == 1:
                self.state = 660
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 659
                    self.match(CypherParser.SP)


                self.state = 662
                _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, 68, self.RULE_oC_Where)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.match(CypherParser.WHERE)
            self.state = 666
            self.match(CypherParser.SP)
            self.state = 667
            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, 70, self.RULE_oC_Pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 669
            self.oC_PatternPart()
            self.state = 680
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,95,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 671
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 670
                        self.match(CypherParser.SP)


                    self.state = 673
                    self.match(CypherParser.T__3)
                    self.state = 675
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 674
                        self.match(CypherParser.SP)


                    self.state = 677
                    self.oC_PatternPart() 
                self.state = 682
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,95,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, 72, self.RULE_oC_PatternPart)
        self._la = 0 # Token type
        try:
            self.state = 694
            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 = 683
                self.oC_Variable()
                self.state = 685
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 684
                    self.match(CypherParser.SP)


                self.state = 687
                self.match(CypherParser.T__4)
                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 = 691
                self.oC_AnonymousPatternPart()
                pass
            elif token in [CypherParser.T__7]:
                self.enterOuterAlt(localctx, 2)
                self.state = 693
                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, 74, self.RULE_oC_AnonymousPatternPart)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 696
            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, 76, self.RULE_oC_PatternElement)
        self._la = 0 # Token type
        try:
            self.state = 712
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 698
                self.oC_NodePattern()
                self.state = 705
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,100,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 700
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 699
                            self.match(CypherParser.SP)


                        self.state = 702
                        self.oC_PatternElementChain() 
                    self.state = 707
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,100,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 708
                self.match(CypherParser.T__7)
                self.state = 709
                self.oC_PatternElement()
                self.state = 710
                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_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, 78, self.RULE_oC_RelationshipsPattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 714
            self.oC_NodePattern()
            self.state = 719 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 716
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 715
                        self.match(CypherParser.SP)


                    self.state = 718
                    self.oC_PatternElementChain()

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

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


    class OC_NodePatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_NodePattern

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

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

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




    def oC_NodePattern(self):

        localctx = CypherParser.OC_NodePatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_oC_NodePattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 723
            self.match(CypherParser.T__7)
            self.state = 725
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 724
                self.match(CypherParser.SP)


            self.state = 731
            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 = 727
                self.oC_Variable()
                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 = 737
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__11:
                self.state = 733
                self.oC_NodeLabels()
                self.state = 735
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 734
                    self.match(CypherParser.SP)




            self.state = 743
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__1 or _la==CypherParser.T__25:
                self.state = 739
                self.oC_Properties()
                self.state = 741
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 740
                    self.match(CypherParser.SP)




            self.state = 745
            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_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, 82, self.RULE_oC_PatternElementChain)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 747
            self.oC_RelationshipPattern()
            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_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, 84, self.RULE_oC_RelationshipPattern)
        self._la = 0 # Token type
        try:
            self.state = 817
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 753
                self.oC_LeftArrowHead()
                self.state = 755
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 754
                    self.match(CypherParser.SP)


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


                self.state = 762
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.T__9:
                    self.state = 761
                    self.oC_RelationshipDetail()


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


                self.state = 771
                self.oC_RightArrowHead()
                pass

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


                self.state = 777
                self.oC_Dash()
                self.state = 779
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
                if la_ == 1:
                    self.state = 778
                    self.match(CypherParser.SP)


                self.state = 782
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.T__9:
                    self.state = 781
                    self.oC_RelationshipDetail()


                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 = 787
                self.oC_Dash()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 789
                self.oC_Dash()
                self.state = 791
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
                if la_ == 1:
                    self.state = 790
                    self.match(CypherParser.SP)


                self.state = 794
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.T__9:
                    self.state = 793
                    self.oC_RelationshipDetail()


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


                self.state = 799
                self.oC_Dash()
                self.state = 801
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 800
                    self.match(CypherParser.SP)


                self.state = 803
                self.oC_RightArrowHead()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 805
                self.oC_Dash()
                self.state = 807
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
                if la_ == 1:
                    self.state = 806
                    self.match(CypherParser.SP)


                self.state = 810
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.T__9:
                    self.state = 809
                    self.oC_RelationshipDetail()


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


                self.state = 815
                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, 86, self.RULE_oC_RelationshipDetail)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 819
            self.match(CypherParser.T__9)
            self.state = 821
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 820
                self.match(CypherParser.SP)


            self.state = 827
            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 = 823
                self.oC_Variable()
                self.state = 825
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 824
                    self.match(CypherParser.SP)




            self.state = 833
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__11:
                self.state = 829
                self.oC_RelationshipTypes()
                self.state = 831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 830
                    self.match(CypherParser.SP)




            self.state = 836
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__6:
                self.state = 835
                self.oC_RangeLiteral()


            self.state = 842
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__1 or _la==CypherParser.T__25:
                self.state = 838
                self.oC_Properties()
                self.state = 840
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 839
                    self.match(CypherParser.SP)




            self.state = 844
            self.match(CypherParser.T__10)
        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, 88, self.RULE_oC_Properties)
        try:
            self.state = 848
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__1]:
                self.enterOuterAlt(localctx, 1)
                self.state = 846
                self.oC_MapLiteral()
                pass
            elif token in [CypherParser.T__25]:
                self.enterOuterAlt(localctx, 2)
                self.state = 847
                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, 90, self.RULE_oC_RelationshipTypes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 850
            self.match(CypherParser.T__11)
            self.state = 852
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 851
                self.match(CypherParser.SP)


            self.state = 854
            self.oC_RelTypeName()
            self.state = 868
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,142,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 856
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 855
                        self.match(CypherParser.SP)


                    self.state = 858
                    self.match(CypherParser.T__12)
                    self.state = 860
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.T__11:
                        self.state = 859
                        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 = 865
                    self.oC_RelTypeName() 
                self.state = 870
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,142,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, 92, self.RULE_oC_NodeLabels)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 871
            self.oC_NodeLabel()
            self.state = 878
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,144,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 873
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 872
                        self.match(CypherParser.SP)


                    self.state = 875
                    self.oC_NodeLabel() 
                self.state = 880
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,144,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, 94, self.RULE_oC_NodeLabel)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 881
            self.match(CypherParser.T__11)
            self.state = 883
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 882
                self.match(CypherParser.SP)


            self.state = 885
            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, 96, self.RULE_oC_RangeLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 887
            self.match(CypherParser.T__6)
            self.state = 889
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 888
                self.match(CypherParser.SP)


            self.state = 895
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (CypherParser.HexInteger - 95)) | (1 << (CypherParser.DecimalInteger - 95)) | (1 << (CypherParser.OctalInteger - 95)))) != 0):
                self.state = 891
                self.oC_IntegerLiteral()
                self.state = 893
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 892
                    self.match(CypherParser.SP)




            self.state = 907
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.T__13:
                self.state = 897
                self.match(CypherParser.T__13)
                self.state = 899
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 898
                    self.match(CypherParser.SP)


                self.state = 905
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (CypherParser.HexInteger - 95)) | (1 << (CypherParser.DecimalInteger - 95)) | (1 << (CypherParser.OctalInteger - 95)))) != 0):
                    self.state = 901
                    self.oC_IntegerLiteral()
                    self.state = 903
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 902
                        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, 98, self.RULE_oC_LabelName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 909
            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, 100, self.RULE_oC_RelTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 911
            self.oC_SchemaName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PropertyExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_PropertyExpression

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

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

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




    def oC_PropertyExpression(self):

        localctx = CypherParser.OC_PropertyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_oC_PropertyExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 913
            self.oC_Atom()
            self.state = 918 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 915
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 914
                        self.match(CypherParser.SP)


                    self.state = 917
                    self.oC_PropertyLookup()

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

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


    class OC_ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Expression

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

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

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




    def oC_Expression(self):

        localctx = CypherParser.OC_ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_oC_Expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 922
            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, 106, self.RULE_oC_OrExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 924
            self.oC_XorExpression()
            self.state = 931
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,155,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 925
                    self.match(CypherParser.SP)
                    self.state = 926
                    self.match(CypherParser.OR)
                    self.state = 927
                    self.match(CypherParser.SP)
                    self.state = 928
                    self.oC_XorExpression() 
                self.state = 933
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,155,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, 108, self.RULE_oC_XorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 934
            self.oC_AndExpression()
            self.state = 941
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 935
                    self.match(CypherParser.SP)
                    self.state = 936
                    self.match(CypherParser.XOR)
                    self.state = 937
                    self.match(CypherParser.SP)
                    self.state = 938
                    self.oC_AndExpression() 
                self.state = 943
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,156,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, 110, self.RULE_oC_AndExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 944
            self.oC_NotExpression()
            self.state = 951
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,157,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 945
                    self.match(CypherParser.SP)
                    self.state = 946
                    self.match(CypherParser.AND)
                    self.state = 947
                    self.match(CypherParser.SP)
                    self.state = 948
                    self.oC_NotExpression() 
                self.state = 953
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,157,self._ctx)

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


    class OC_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, 112, self.RULE_oC_NotExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 960
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CypherParser.NOT:
                self.state = 954
                self.match(CypherParser.NOT)
                self.state = 956
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 955
                    self.match(CypherParser.SP)


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

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


    class OC_ComparisonExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_ComparisonExpression

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

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

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




    def oC_ComparisonExpression(self):

        localctx = CypherParser.OC_ComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_oC_ComparisonExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 965
            self.oC_StringListNullPredicateExpression()
            self.state = 972
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,161,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 967
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 966
                        self.match(CypherParser.SP)


                    self.state = 969
                    self.oC_PartialComparisonExpression() 
                self.state = 974
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,161,self._ctx)

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


    class OC_PartialComparisonExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_PartialComparisonExpression

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

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

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




    def oC_PartialComparisonExpression(self):

        localctx = CypherParser.OC_PartialComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_oC_PartialComparisonExpression)
        self._la = 0 # Token type
        try:
            self.state = 1005
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 975
                self.match(CypherParser.T__4)
                self.state = 977
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 976
                    self.match(CypherParser.SP)


                self.state = 979
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [CypherParser.T__14]:
                self.enterOuterAlt(localctx, 2)
                self.state = 980
                self.match(CypherParser.T__14)
                self.state = 982
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 981
                    self.match(CypherParser.SP)


                self.state = 984
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [CypherParser.T__15]:
                self.enterOuterAlt(localctx, 3)
                self.state = 985
                self.match(CypherParser.T__15)
                self.state = 987
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 986
                    self.match(CypherParser.SP)


                self.state = 989
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [CypherParser.T__16]:
                self.enterOuterAlt(localctx, 4)
                self.state = 990
                self.match(CypherParser.T__16)
                self.state = 992
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 991
                    self.match(CypherParser.SP)


                self.state = 994
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [CypherParser.T__17]:
                self.enterOuterAlt(localctx, 5)
                self.state = 995
                self.match(CypherParser.T__17)
                self.state = 997
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 996
                    self.match(CypherParser.SP)


                self.state = 999
                self.oC_StringListNullPredicateExpression()
                pass
            elif token in [CypherParser.T__18]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1000
                self.match(CypherParser.T__18)
                self.state = 1002
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1001
                    self.match(CypherParser.SP)


                self.state = 1004
                self.oC_StringListNullPredicateExpression()
                pass
            else:
                raise NoViableAltException(self)

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


    class OC_StringListNullPredicateExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_StringListNullPredicateExpression

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

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

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




    def oC_StringListNullPredicateExpression(self):

        localctx = CypherParser.OC_StringListNullPredicateExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_oC_StringListNullPredicateExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1007
            self.oC_AddOrSubtractExpression()
            self.state = 1013
            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 = 1011
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
                    if la_ == 1:
                        self.state = 1008
                        self.oC_StringPredicateExpression()
                        pass

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

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

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

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

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


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

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_StringPredicateExpression

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

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

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




    def oC_StringPredicateExpression(self):

        localctx = CypherParser.OC_StringPredicateExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_oC_StringPredicateExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1026
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
            if la_ == 1:
                self.state = 1016
                self.match(CypherParser.SP)
                self.state = 1017
                self.match(CypherParser.STARTS)
                self.state = 1018
                self.match(CypherParser.SP)
                self.state = 1019
                self.match(CypherParser.WITH)
                pass

            elif la_ == 2:
                self.state = 1020
                self.match(CypherParser.SP)
                self.state = 1021
                self.match(CypherParser.ENDS)
                self.state = 1022
                self.match(CypherParser.SP)
                self.state = 1023
                self.match(CypherParser.WITH)
                pass

            elif la_ == 3:
                self.state = 1024
                self.match(CypherParser.SP)
                self.state = 1025
                self.match(CypherParser.CONTAINS)
                pass


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


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


    class OC_ListPredicateExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ListPredicateExpression

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

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

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




    def oC_ListPredicateExpression(self):

        localctx = CypherParser.OC_ListPredicateExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_oC_ListPredicateExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1033
            self.match(CypherParser.SP)
            self.state = 1034
            self.match(CypherParser.IN)
            self.state = 1036
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1035
                self.match(CypherParser.SP)


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


    class OC_NullPredicateExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_NullPredicateExpression

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

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

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




    def oC_NullPredicateExpression(self):

        localctx = CypherParser.OC_NullPredicateExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_oC_NullPredicateExpression)
        try:
            self.state = 1050
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1040
                self.match(CypherParser.SP)
                self.state = 1041
                self.match(CypherParser.IS)
                self.state = 1042
                self.match(CypherParser.SP)
                self.state = 1043
                self.match(CypherParser.NULL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1044
                self.match(CypherParser.SP)
                self.state = 1045
                self.match(CypherParser.IS)
                self.state = 1046
                self.match(CypherParser.SP)
                self.state = 1047
                self.match(CypherParser.NOT)
                self.state = 1048
                self.match(CypherParser.SP)
                self.state = 1049
                self.match(CypherParser.NULL)
                pass


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


    class OC_AddOrSubtractExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_AddOrSubtractExpression

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

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

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




    def oC_AddOrSubtractExpression(self):

        localctx = CypherParser.OC_AddOrSubtractExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_oC_AddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1052
            self.oC_MultiplyDivideModuloExpression()
            self.state = 1071
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,180,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1069
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
                    if la_ == 1:
                        self.state = 1054
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1053
                            self.match(CypherParser.SP)


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


                        self.state = 1060
                        self.oC_MultiplyDivideModuloExpression()
                        pass

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


                        self.state = 1064
                        self.match(CypherParser.T__20)
                        self.state = 1066
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1065
                            self.match(CypherParser.SP)


                        self.state = 1068
                        self.oC_MultiplyDivideModuloExpression()
                        pass

             
                self.state = 1073
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,180,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, 128, self.RULE_oC_MultiplyDivideModuloExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1074
            self.oC_PowerOfExpression()
            self.state = 1101
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,188,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1099
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
                    if la_ == 1:
                        self.state = 1076
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1075
                            self.match(CypherParser.SP)


                        self.state = 1078
                        self.match(CypherParser.T__6)
                        self.state = 1080
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1079
                            self.match(CypherParser.SP)


                        self.state = 1082
                        self.oC_PowerOfExpression()
                        pass

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


                        self.state = 1086
                        self.match(CypherParser.T__21)
                        self.state = 1088
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1087
                            self.match(CypherParser.SP)


                        self.state = 1090
                        self.oC_PowerOfExpression()
                        pass

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


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


                        self.state = 1098
                        self.oC_PowerOfExpression()
                        pass

             
                self.state = 1103
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,188,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, 130, self.RULE_oC_PowerOfExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1104
            self.oC_UnaryAddOrSubtractExpression()
            self.state = 1115
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,191,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1106
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1105
                        self.match(CypherParser.SP)


                    self.state = 1108
                    self.match(CypherParser.T__23)
                    self.state = 1110
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1109
                        self.match(CypherParser.SP)


                    self.state = 1112
                    self.oC_UnaryAddOrSubtractExpression() 
                self.state = 1117
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,191,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_ListOperatorExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_ListOperatorExpressionContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_UnaryAddOrSubtractExpression

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

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

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




    def oC_UnaryAddOrSubtractExpression(self):

        localctx = CypherParser.OC_UnaryAddOrSubtractExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_oC_UnaryAddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.state = 1124
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__1, CypherParser.T__7, CypherParser.T__9, CypherParser.T__25, CypherParser.ALL, CypherParser.NULL, CypherParser.COUNT, CypherParser.CASE, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.EXISTS, CypherParser.TRUE, CypherParser.FALSE, CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger, CypherParser.HexLetter, CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal, CypherParser.StringLiteral, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1118
                self.oC_ListOperatorExpression()
                pass
            elif token in [CypherParser.T__19, CypherParser.T__20]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1119
                _la = self._input.LA(1)
                if not(_la==CypherParser.T__19 or _la==CypherParser.T__20):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1120
                    self.match(CypherParser.SP)


                self.state = 1123
                self.oC_ListOperatorExpression()
                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_ListOperatorExpressionContext(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_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 getRuleIndex(self):
            return CypherParser.RULE_oC_ListOperatorExpression

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

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

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




    def oC_ListOperatorExpression(self):

        localctx = CypherParser.OC_ListOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_oC_ListOperatorExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1126
            self.oC_PropertyOrLabelsExpression()
            self.state = 1148
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,199,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1146
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
                    if la_ == 1:
                        self.state = 1128
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1127
                            self.match(CypherParser.SP)


                        self.state = 1130
                        self.match(CypherParser.T__9)
                        self.state = 1131
                        self.oC_Expression()
                        self.state = 1132
                        self.match(CypherParser.T__10)
                        pass

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


                        self.state = 1137
                        self.match(CypherParser.T__9)
                        self.state = 1139
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__1) | (1 << CypherParser.T__7) | (1 << CypherParser.T__9) | (1 << CypherParser.T__19) | (1 << CypherParser.T__20) | (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.CASE - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 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.StringLiteral - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                            self.state = 1138
                            self.oC_Expression()


                        self.state = 1141
                        self.match(CypherParser.T__13)
                        self.state = 1143
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__1) | (1 << CypherParser.T__7) | (1 << CypherParser.T__9) | (1 << CypherParser.T__19) | (1 << CypherParser.T__20) | (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.CASE - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 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.StringLiteral - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                            self.state = 1142
                            self.oC_Expression()


                        self.state = 1145
                        self.match(CypherParser.T__10)
                        pass

             
                self.state = 1150
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,199,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_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, 136, self.RULE_oC_PropertyOrLabelsExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1151
            self.oC_Atom()
            self.state = 1158
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,201,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1153
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1152
                        self.match(CypherParser.SP)


                    self.state = 1155
                    self.oC_PropertyLookup() 
                self.state = 1160
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,201,self._ctx)

            self.state = 1165
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
            if la_ == 1:
                self.state = 1162
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1161
                    self.match(CypherParser.SP)


                self.state = 1164
                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_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, 138, self.RULE_oC_PropertyLookup)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1167
            self.match(CypherParser.T__24)
            self.state = 1169
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1168
                self.match(CypherParser.SP)


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


    class OC_AtomContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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

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

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


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


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


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


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


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


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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Atom

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

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

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




    def oC_Atom(self):

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

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

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

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


                self.state = 1180
                self.match(CypherParser.T__7)
                self.state = 1182
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1181
                    self.match(CypherParser.SP)


                self.state = 1184
                self.match(CypherParser.T__6)
                self.state = 1186
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1185
                    self.match(CypherParser.SP)


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

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

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

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

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1192
                self.oC_PatternPredicate()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1193
                self.oC_ParenthesizedExpression()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1194
                self.oC_FunctionInvocation()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1195
                self.oC_ExistentialSubquery()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1196
                self.oC_Variable()
                pass


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


    class OC_CaseExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_CaseExpression

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

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

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




    def oC_CaseExpression(self):

        localctx = CypherParser.OC_CaseExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_oC_CaseExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1221
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,214,self._ctx)
            if la_ == 1:
                self.state = 1199
                self.match(CypherParser.CASE)
                self.state = 1204 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1201
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1200
                            self.match(CypherParser.SP)


                        self.state = 1203
                        self.oC_CaseAlternative()

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

                pass

            elif la_ == 2:
                self.state = 1208
                self.match(CypherParser.CASE)
                self.state = 1210
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1209
                    self.match(CypherParser.SP)


                self.state = 1212
                self.oC_Expression()
                self.state = 1217 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1214
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1213
                            self.match(CypherParser.SP)


                        self.state = 1216
                        self.oC_CaseAlternative()

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

                pass


            self.state = 1231
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,217,self._ctx)
            if la_ == 1:
                self.state = 1224
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1223
                    self.match(CypherParser.SP)


                self.state = 1226
                self.match(CypherParser.ELSE)
                self.state = 1228
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1227
                    self.match(CypherParser.SP)


                self.state = 1230
                self.oC_Expression()


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


            self.state = 1236
            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, 144, self.RULE_oC_CaseAlternative)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1238
            self.match(CypherParser.WHEN)
            self.state = 1240
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1239
                self.match(CypherParser.SP)


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


            self.state = 1246
            self.match(CypherParser.THEN)
            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_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ListComprehensionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ListComprehension

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

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

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




    def oC_ListComprehension(self):

        localctx = CypherParser.OC_ListComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_oC_ListComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1252
            self.match(CypherParser.T__9)
            self.state = 1254
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1253
                self.match(CypherParser.SP)


            self.state = 1256
            self.oC_FilterExpression()
            self.state = 1265
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
            if la_ == 1:
                self.state = 1258
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1257
                    self.match(CypherParser.SP)


                self.state = 1260
                self.match(CypherParser.T__12)
                self.state = 1262
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1261
                    self.match(CypherParser.SP)


                self.state = 1264
                self.oC_Expression()


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


            self.state = 1270
            self.match(CypherParser.T__10)
        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, 148, self.RULE_oC_PatternComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1272
            self.match(CypherParser.T__9)
            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 = 1284
            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 = 1276
                self.oC_Variable()
                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 = 1280
                self.match(CypherParser.T__4)
                self.state = 1282
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1281
                    self.match(CypherParser.SP)




            self.state = 1286
            self.oC_RelationshipsPattern()
            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 = 1294
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.WHERE:
                self.state = 1290
                self.oC_Where()
                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 = 1296
            self.match(CypherParser.T__12)
            self.state = 1298
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1297
                self.match(CypherParser.SP)


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


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


    class OC_QuantifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_Quantifier

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

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

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




    def oC_Quantifier(self):

        localctx = CypherParser.OC_QuantifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_oC_Quantifier)
        self._la = 0 # Token type
        try:
            self.state = 1362
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.ALL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1306
                self.match(CypherParser.ALL)
                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__7)
                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 = 1314
                self.oC_FilterExpression()
                self.state = 1316
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1315
                    self.match(CypherParser.SP)


                self.state = 1318
                self.match(CypherParser.T__8)
                pass
            elif token in [CypherParser.ANY]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1320
                self.match(CypherParser.ANY)
                self.state = 1322
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1321
                    self.match(CypherParser.SP)


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


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


                self.state = 1332
                self.match(CypherParser.T__8)
                pass
            elif token in [CypherParser.NONE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1334
                self.match(CypherParser.NONE)
                self.state = 1336
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1335
                    self.match(CypherParser.SP)


                self.state = 1338
                self.match(CypherParser.T__7)
                self.state = 1340
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1339
                    self.match(CypherParser.SP)


                self.state = 1342
                self.oC_FilterExpression()
                self.state = 1344
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1343
                    self.match(CypherParser.SP)


                self.state = 1346
                self.match(CypherParser.T__8)
                pass
            elif token in [CypherParser.SINGLE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1348
                self.match(CypherParser.SINGLE)
                self.state = 1350
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1349
                    self.match(CypherParser.SP)


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


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


                self.state = 1360
                self.match(CypherParser.T__8)
                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_FilterExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_FilterExpression

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

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

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




    def oC_FilterExpression(self):

        localctx = CypherParser.OC_FilterExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_oC_FilterExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1364
            self.oC_IdInColl()
            self.state = 1369
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,250,self._ctx)
            if la_ == 1:
                self.state = 1366
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1365
                    self.match(CypherParser.SP)


                self.state = 1368
                self.oC_Where()


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


    class OC_PatternPredicateContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_PatternPredicate

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

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

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




    def oC_PatternPredicate(self):

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


    class OC_ParenthesizedExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_ParenthesizedExpression

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

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

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




    def oC_ParenthesizedExpression(self):

        localctx = CypherParser.OC_ParenthesizedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_oC_ParenthesizedExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 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_Expression()
            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__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_IdInCollContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_IdInColl

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

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

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




    def oC_IdInColl(self):

        localctx = CypherParser.OC_IdInCollContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_oC_IdInColl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1383
            self.oC_Variable()
            self.state = 1384
            self.match(CypherParser.SP)
            self.state = 1385
            self.match(CypherParser.IN)
            self.state = 1386
            self.match(CypherParser.SP)
            self.state = 1387
            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, 160, self.RULE_oC_FunctionInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1389
            self.oC_FunctionName()
            self.state = 1391
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1390
                self.match(CypherParser.SP)


            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 = 1401
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.DISTINCT:
                self.state = 1397
                self.match(CypherParser.DISTINCT)
                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 = 1420
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__1) | (1 << CypherParser.T__7) | (1 << CypherParser.T__9) | (1 << CypherParser.T__19) | (1 << CypherParser.T__20) | (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.CASE - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 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.StringLiteral - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                self.state = 1403
                self.oC_Expression()
                self.state = 1405
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1404
                    self.match(CypherParser.SP)


                self.state = 1417
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CypherParser.T__3:
                    self.state = 1407
                    self.match(CypherParser.T__3)
                    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 = 1411
                    self.oC_Expression()
                    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 = 1419
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



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

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

        def oC_Namespace(self):
            return self.getTypedRuleContext(CypherParser.OC_NamespaceContext,0)


        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_FunctionName

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

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

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




    def oC_FunctionName(self):

        localctx = CypherParser.OC_FunctionNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_oC_FunctionName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1424
            self.oC_Namespace()
            self.state = 1425
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ExistentialSubqueryContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def oC_Pattern(self):
            return self.getTypedRuleContext(CypherParser.OC_PatternContext,0)


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ExistentialSubquery

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

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

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




    def oC_ExistentialSubquery(self):

        localctx = CypherParser.OC_ExistentialSubqueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_oC_ExistentialSubquery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1427
            self.match(CypherParser.EXISTS)
            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.match(CypherParser.T__1)
            self.state = 1433
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1432
                self.match(CypherParser.SP)


            self.state = 1443
            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 = 1435
                self.oC_RegularQuery()
                pass
            elif token in [CypherParser.T__7, CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.state = 1436
                self.oC_Pattern()
                self.state = 1441
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,265,self._ctx)
                if la_ == 1:
                    self.state = 1438
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1437
                        self.match(CypherParser.SP)


                    self.state = 1440
                    self.oC_Where()


                pass
            else:
                raise NoViableAltException(self)

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


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


    class OC_ExplicitProcedureInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_ProcedureName(self):
            return self.getTypedRuleContext(CypherParser.OC_ProcedureNameContext,0)


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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ExplicitProcedureInvocation

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

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

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




    def oC_ExplicitProcedureInvocation(self):

        localctx = CypherParser.OC_ExplicitProcedureInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_oC_ExplicitProcedureInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1450
            self.oC_ProcedureName()
            self.state = 1452
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1451
                self.match(CypherParser.SP)


            self.state = 1454
            self.match(CypherParser.T__7)
            self.state = 1456
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1455
                self.match(CypherParser.SP)


            self.state = 1475
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__1) | (1 << CypherParser.T__7) | (1 << CypherParser.T__9) | (1 << CypherParser.T__19) | (1 << CypherParser.T__20) | (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.CASE - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 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.StringLiteral - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                self.state = 1458
                self.oC_Expression()
                self.state = 1460
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1459
                    self.match(CypherParser.SP)


                self.state = 1472
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CypherParser.T__3:
                    self.state = 1462
                    self.match(CypherParser.T__3)
                    self.state = 1464
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1463
                        self.match(CypherParser.SP)


                    self.state = 1466
                    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 = 1474
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



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

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

        def oC_ProcedureName(self):
            return self.getTypedRuleContext(CypherParser.OC_ProcedureNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ImplicitProcedureInvocation

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

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

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




    def oC_ImplicitProcedureInvocation(self):

        localctx = CypherParser.OC_ImplicitProcedureInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_oC_ImplicitProcedureInvocation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1479
            self.oC_ProcedureName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ProcedureResultFieldContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ProcedureResultField

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

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

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




    def oC_ProcedureResultField(self):

        localctx = CypherParser.OC_ProcedureResultFieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_oC_ProcedureResultField)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1481
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ProcedureNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_Namespace(self):
            return self.getTypedRuleContext(CypherParser.OC_NamespaceContext,0)


        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ProcedureName

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

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

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




    def oC_ProcedureName(self):

        localctx = CypherParser.OC_ProcedureNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_oC_ProcedureName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1483
            self.oC_Namespace()
            self.state = 1484
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NamespaceContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Namespace

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

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

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




    def oC_Namespace(self):

        localctx = CypherParser.OC_NamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_oC_Namespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1491
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,275,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1486
                    self.oC_SymbolicName()
                    self.state = 1487
                    self.match(CypherParser.T__24) 
                self.state = 1493
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,275,self._ctx)

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


    class OC_VariableContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Variable

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

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

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




    def oC_Variable(self):

        localctx = CypherParser.OC_VariableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_oC_Variable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1494
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


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

        def oC_ListLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_ListLiteralContext,0)


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Literal

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

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

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




    def oC_Literal(self):

        localctx = CypherParser.OC_LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_oC_Literal)
        try:
            self.state = 1502
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.TRUE, CypherParser.FALSE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1496
                self.oC_BooleanLiteral()
                pass
            elif token in [CypherParser.NULL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1497
                self.match(CypherParser.NULL)
                pass
            elif token in [CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger, CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1498
                self.oC_NumberLiteral()
                pass
            elif token in [CypherParser.StringLiteral]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1499
                self.match(CypherParser.StringLiteral)
                pass
            elif token in [CypherParser.T__9]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1500
                self.oC_ListLiteral()
                pass
            elif token in [CypherParser.T__1]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1501
                self.oC_MapLiteral()
                pass
            else:
                raise NoViableAltException(self)

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


    class OC_BooleanLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_BooleanLiteral

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

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

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




    def oC_BooleanLiteral(self):

        localctx = CypherParser.OC_BooleanLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_oC_BooleanLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1504
            _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_NumberLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_DoubleLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_DoubleLiteralContext,0)


        def oC_IntegerLiteral(self):
            return self.getTypedRuleContext(CypherParser.OC_IntegerLiteralContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_NumberLiteral

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

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

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




    def oC_NumberLiteral(self):

        localctx = CypherParser.OC_NumberLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_oC_NumberLiteral)
        try:
            self.state = 1508
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1506
                self.oC_DoubleLiteral()
                pass
            elif token in [CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1507
                self.oC_IntegerLiteral()
                pass
            else:
                raise NoViableAltException(self)

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


    class OC_IntegerLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_IntegerLiteral

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

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

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




    def oC_IntegerLiteral(self):

        localctx = CypherParser.OC_IntegerLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_oC_IntegerLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1510
            _la = self._input.LA(1)
            if not(((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & ((1 << (CypherParser.HexInteger - 95)) | (1 << (CypherParser.DecimalInteger - 95)) | (1 << (CypherParser.OctalInteger - 95)))) != 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 = 1512
            _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_ListLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ListLiteral

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

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

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




    def oC_ListLiteral(self):

        localctx = CypherParser.OC_ListLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_oC_ListLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1514
            self.match(CypherParser.T__9)
            self.state = 1516
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1515
                self.match(CypherParser.SP)


            self.state = 1535
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__1) | (1 << CypherParser.T__7) | (1 << CypherParser.T__9) | (1 << CypherParser.T__19) | (1 << CypherParser.T__20) | (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.CASE - 76)) | (1 << (CypherParser.ANY - 76)) | (1 << (CypherParser.NONE - 76)) | (1 << (CypherParser.SINGLE - 76)) | (1 << (CypherParser.EXISTS - 76)) | (1 << (CypherParser.TRUE - 76)) | (1 << (CypherParser.FALSE - 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.StringLiteral - 76)) | (1 << (CypherParser.FILTER - 76)) | (1 << (CypherParser.EXTRACT - 76)) | (1 << (CypherParser.UnescapedSymbolicName - 76)) | (1 << (CypherParser.EscapedSymbolicName - 76)))) != 0):
                self.state = 1518
                self.oC_Expression()
                self.state = 1520
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1519
                    self.match(CypherParser.SP)


                self.state = 1532
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CypherParser.T__3:
                    self.state = 1522
                    self.match(CypherParser.T__3)
                    self.state = 1524
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1523
                        self.match(CypherParser.SP)


                    self.state = 1526
                    self.oC_Expression()
                    self.state = 1528
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1527
                        self.match(CypherParser.SP)


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



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


    class OC_MapLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_MapLiteral

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

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

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




    def oC_MapLiteral(self):

        localctx = CypherParser.OC_MapLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_oC_MapLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1539
            self.match(CypherParser.T__1)
            self.state = 1541
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1540
                self.match(CypherParser.SP)


            self.state = 1576
            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.STARTS - 64)) | (1 << (CypherParser.ENDS - 64)) | (1 << (CypherParser.CONTAINS - 64)) | (1 << (CypherParser.IN - 64)) | (1 << (CypherParser.IS - 64)) | (1 << (CypherParser.NULL - 64)) | (1 << (CypherParser.COUNT - 64)) | (1 << (CypherParser.CASE - 64)) | (1 << (CypherParser.ELSE - 64)) | (1 << (CypherParser.END - 64)) | (1 << (CypherParser.WHEN - 64)) | (1 << (CypherParser.THEN - 64)) | (1 << (CypherParser.ANY - 64)) | (1 << (CypherParser.NONE - 64)) | (1 << (CypherParser.SINGLE - 64)) | (1 << (CypherParser.EXISTS - 64)) | (1 << (CypherParser.TRUE - 64)) | (1 << (CypherParser.FALSE - 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 = 1543
                self.oC_PropertyKeyName()
                self.state = 1545
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1544
                    self.match(CypherParser.SP)


                self.state = 1547
                self.match(CypherParser.T__11)
                self.state = 1549
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1548
                    self.match(CypherParser.SP)


                self.state = 1551
                self.oC_Expression()
                self.state = 1553
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1552
                    self.match(CypherParser.SP)


                self.state = 1573
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CypherParser.T__3:
                    self.state = 1555
                    self.match(CypherParser.T__3)
                    self.state = 1557
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1556
                        self.match(CypherParser.SP)


                    self.state = 1559
                    self.oC_PropertyKeyName()
                    self.state = 1561
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1560
                        self.match(CypherParser.SP)


                    self.state = 1563
                    self.match(CypherParser.T__11)
                    self.state = 1565
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1564
                        self.match(CypherParser.SP)


                    self.state = 1567
                    self.oC_Expression()
                    self.state = 1569
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1568
                        self.match(CypherParser.SP)


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



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


    class OC_PropertyKeyNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_PropertyKeyName

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

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

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




    def oC_PropertyKeyName(self):

        localctx = CypherParser.OC_PropertyKeyNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_oC_PropertyKeyName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1580
            self.oC_SchemaName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_Parameter

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

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

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




    def oC_Parameter(self):

        localctx = CypherParser.OC_ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_oC_Parameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1582
            self.match(CypherParser.T__25)
            self.state = 1585
            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 = 1583
                self.oC_SymbolicName()
                pass
            elif token in [CypherParser.DecimalInteger]:
                self.state = 1584
                self.match(CypherParser.DecimalInteger)
                pass
            else:
                raise NoViableAltException(self)

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


    class OC_SchemaNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext,0)


        def oC_ReservedWord(self):
            return self.getTypedRuleContext(CypherParser.OC_ReservedWordContext,0)


        def getRuleIndex(self):
            return CypherParser.RULE_oC_SchemaName

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

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

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




    def oC_SchemaName(self):

        localctx = CypherParser.OC_SchemaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_oC_SchemaName)
        try:
            self.state = 1589
            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 = 1587
                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.STARTS, CypherParser.ENDS, CypherParser.CONTAINS, CypherParser.IN, CypherParser.IS, CypherParser.NULL, CypherParser.CASE, CypherParser.ELSE, CypherParser.END, CypherParser.WHEN, CypherParser.THEN, CypherParser.EXISTS, CypherParser.TRUE, CypherParser.FALSE, 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 = 1588
                self.oC_ReservedWord()
                pass
            else:
                raise NoViableAltException(self)

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


    class OC_ReservedWordContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_ReservedWord

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

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

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




    def oC_ReservedWord(self):

        localctx = CypherParser.OC_ReservedWordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_oC_ReservedWord)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1591
            _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.STARTS - 64)) | (1 << (CypherParser.ENDS - 64)) | (1 << (CypherParser.CONTAINS - 64)) | (1 << (CypherParser.IN - 64)) | (1 << (CypherParser.IS - 64)) | (1 << (CypherParser.NULL - 64)) | (1 << (CypherParser.CASE - 64)) | (1 << (CypherParser.ELSE - 64)) | (1 << (CypherParser.END - 64)) | (1 << (CypherParser.WHEN - 64)) | (1 << (CypherParser.THEN - 64)) | (1 << (CypherParser.EXISTS - 64)) | (1 << (CypherParser.TRUE - 64)) | (1 << (CypherParser.FALSE - 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, 200, self.RULE_oC_SymbolicName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1593
            _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, 202, self.RULE_oC_LeftArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1595
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__15) | (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, 204, self.RULE_oC_RightArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1597
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__16) | (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, 206, self.RULE_oC_Dash)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1599
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__20) | (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





